syncromatics-track-api
Version:
Library to interact with the Syncromatics Track API
1,593 lines (1,228 loc) • 594 kB
JavaScript
(function webpackUniversalModuleDefinition(root, factory) {
if(typeof exports === 'object' && typeof module === 'object')
module.exports = factory();
else if(typeof define === 'function' && define.amd)
define([], factory);
else {
var a = factory();
for(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];
}
})(this, function() {
return /******/ (function(modules) { // webpackBootstrap
/******/ // The module cache
/******/ var installedModules = {};
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/ // Check if module is in cache
/******/ if(installedModules[moduleId])
/******/ return installedModules[moduleId].exports;
/******/ // Create a new module (and put it into the cache)
/******/ var module = installedModules[moduleId] = {
/******/ exports: {},
/******/ id: moduleId,
/******/ loaded: false
/******/ };
/******/ // Execute the module function
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/ // Flag the module as loaded
/******/ module.loaded = true;
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/ // expose the modules object (__webpack_modules__)
/******/ __webpack_require__.m = modules;
/******/ // expose the module cache
/******/ __webpack_require__.c = installedModules;
/******/ // __webpack_public_path__
/******/ __webpack_require__.p = "";
/******/ // Load entry module and return exports
/******/ return __webpack_require__(0);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ (function(module, exports, __webpack_require__) {
module.exports = __webpack_require__(1);
/***/ }),
/* 1 */
/***/ (function(module, exports, __webpack_require__) {
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var _resources = __webpack_require__(2);
var _resources2 = _interopRequireDefault(_resources);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
exports.default = _resources2.default;
/***/ }),
/* 2 */
/***/ (function(module, exports, __webpack_require__) {
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();
var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
__webpack_require__(3);
var _base = __webpack_require__(5);
var _base2 = _interopRequireDefault(_base);
var _Resource2 = __webpack_require__(7);
var _Resource3 = _interopRequireDefault(_Resource2);
var _Customer = __webpack_require__(8);
var _Customer2 = _interopRequireDefault(_Customer);
var _ExternalApi = __webpack_require__(75);
var _ExternalApi2 = _interopRequireDefault(_ExternalApi);
var _ExternalApisContext = __webpack_require__(76);
var _ExternalApisContext2 = _interopRequireDefault(_ExternalApisContext);
var _Role = __webpack_require__(108);
var _Role2 = _interopRequireDefault(_Role);
var _RolesContext = __webpack_require__(109);
var _RolesContext2 = _interopRequireDefault(_RolesContext);
var _User = __webpack_require__(68);
var _User2 = _interopRequireDefault(_User);
var _Client = __webpack_require__(110);
var _Client2 = _interopRequireDefault(_Client);
var _RealTimeClient = __webpack_require__(117);
var _RealTimeClient2 = _interopRequireDefault(_RealTimeClient);
var _responses = __webpack_require__(116);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
/**
* Root of the Track API resources
*/
var Track = function (_Resource) {
_inherits(Track, _Resource);
/**
* @callback onAutoRenew
* @param {Object} user the claim of the JWT payload (user object)
*/
/**
* Creates a new Track resource
* @param {Object} [options] Options for the Track API
* @param {Boolean} [options.autoRenew=true] Determines whether to automatically renew a token
* when it nears its expiration
* @param {Number} [options.autoRenewMinutesBeforeExpiration=5] Minutes before the expiration of
* a token when automatic renewal will take place
* @param {onAutoRenew} [options.onAutoRenew] Callback called when auto-renew takes place
*/
function Track(options) {
_classCallCheck(this, Track);
var client = new _Client2.default(options);
var _this = _possibleConstructorReturn(this, (Track.__proto__ || Object.getPrototypeOf(Track)).call(this, client));
_this.realTimeClient = new _RealTimeClient2.default(client, options);
_this.options = _extends({
autoRenew: true,
autoRenewMinutesBeforeExpiration: 5,
onAutoRenew: function onAutoRenew() {}
}, options, {
token: undefined,
apiKey: undefined,
username: undefined,
password: undefined
});
return _this;
}
/**
* Halts the automatic renewal of a token
* @returns {void}
*/
_createClass(Track, [{
key: 'stopAutoRenew',
value: function stopAutoRenew() {
if (this.autoRenewTimeout) {
clearTimeout(this.autoRenewTimeout);
this.autoRenewTimeout = null;
}
}
/**
* Parse JSON Web Token into its payload
* @param {string} token JSON Web Token to read and parse
* @returns {{token: string, header: Object, claim: Object, signature: string}} Parsed payload
*/
}, {
key: 'parseToken',
value: function parseToken() {
var token = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
var prefix = _Client2.default.TokenPrefix;
if (prefix && token.indexOf(prefix) === 0) {
return this.parseToken(token.substring(prefix.length));
}
var _token$split = token.split('.'),
_token$split2 = _slicedToArray(_token$split, 3),
encodedHeader = _token$split2[0],
encodedClaim = _token$split2[1],
_token$split2$ = _token$split2[2],
signature = _token$split2$ === undefined ? '' : _token$split2$;
return {
token: token,
header: JSON.parse(_base2.default.decode(encodedHeader)),
claim: JSON.parse(_base2.default.decode(encodedClaim)),
signature: signature
};
}
/**
* Validates the JSON Web Token's expiration and not-before claims
* @param {JWT} jwt Parsed JSON Web Token payload
* @returns {boolean} Indicates whether the JWT is valid
*/
}, {
key: 'authenticateToken',
/**
* Authenticates and validates a token
* @param {string} token JSON Web Token to authenticate and validate
* @returns {Promise} If successful, the claim of the JWT payload (user object).
* Otherwise an error.
*/
value: function authenticateToken(token) {
var _this2 = this;
return Promise.resolve(token).then(function (t) {
return _this2.parseToken(t);
}).then(function (payload) {
if (Track.validateJwt(payload)) {
_this2.client.setJwt(payload);
_this2.stopAutoRenew();
if (_this2.options.autoRenew) {
var msBeforeExp = _this2.options.autoRenewMinutesBeforeExpiration * 60 * 1000;
/* payload.claim.exp used to be milliseconds, but this was a mis-implementation
* in the spec; this is rough logic to handle backwards compatibility.
*/
var expMs = payload.claim.exp / 1000000000 > 1000 ? payload.claim.exp : payload.claim.exp * 1000;
var ms = Math.max(expMs - msBeforeExp - new Date().getTime(), 0);
var onAutoRenew = _this2.options.onAutoRenew || function () {};
_this2.autoRenewTimeout = setTimeout(function () {
return _this2.renewAuthentication().then(onAutoRenew);
}, ms);
}
_this2.client.setAuthenticated(payload.claim);
return payload.claim;
}
_this2.client.setJwt(null);
_this2.client.unsetAuthenticated();
return Promise.reject(new Error('Invalid token or payload'));
});
}
/**
* Logs in and maintains the authentication state for the lifetime of this instance.
*
* This can be used to log in by token (JWT), API key, or username and password.
* @example <caption>Token authentication/renewal</caption>
* const api = new Track();
* api.logIn({ token: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...' });
* @example <caption>API key authentication</caption>
* const api = new Track();
* api.logIn({ apiKey: '00000000-0000-0000-0000-000000000000' });
* @example <caption>Username and password authentication</caption>
* const api = new Track();
* api.logIn({ username: 'csingh@example.com', password: 'securepassword' });
* @param {Object} options Options for logging in
* @param {string} [options.token] Token (JWT) to use directly in authentication
* @param {string} [options.apiKey] API key to use for authentication
* @param {string} [options.username] Username to use for authentication
* @param {string} [options.password] Password to use for authentication
* @returns {Promise} If successful, result of authenticateToken. Otherwise, an ErrorResponse
* @see authenticateToken
* @see ErrorResponse
*/
}, {
key: 'logIn',
value: function logIn(options) {
var _this3 = this;
var uri = void 0;
var headers = {
Accept: 'text/plain'
};
if (options.token) {
uri = '/1/login/renew';
headers = _extends({}, headers, {
Authorization: 'Bearer ' + options.token.replace(/^Bearer /i, '')
});
} else if (options.apiKey) {
uri = '/1/login';
headers = _extends({}, headers, {
'Api-Key': options.apiKey
});
} else if (options.username && options.password) {
uri = '/1/login';
headers = _extends({}, headers, {
Authorization: 'Basic ' + _base2.default.encode(options.username + ':' + options.password)
});
}
return this.client.post(uri, { headers: headers }).then(function (response) {
return response.text();
}).then(function (token) {
return _this3.authenticateToken(token);
}).catch(function (errorResponse) {
if (errorResponse instanceof _responses.ForbiddenResponse) {
return _this3.logOut().then(function () {
return Promise.reject(new _responses.ForbiddenResponse(errorResponse.response, 'Invalid credentials'));
});
}
return Promise.reject(errorResponse);
});
}
/**
* Clears the authentication state internally, effectively "logging out"
* @returns {Promise} Immediately-resolved promise
*/
}, {
key: 'logOut',
value: function logOut() {
this.stopAutoRenew();
this.client.setJwt(null);
this.client.unsetAuthenticated();
return Promise.resolve();
}
/**
* Triggers the renewal of the token.
*
* This will return a rejected Promise if not logged in.
* @returns {Promise} If successful, result of logIn. Otherwise, an error.
* @see logIn
*/
}, {
key: 'renewAuthentication',
value: function renewAuthentication() {
var _client$getJwt = this.client.getJwt(),
token = _client$getJwt.token;
if (token) return this.logIn({ token: token });
return Promise.reject(new Error('Not logged in.'));
}
/**
* Gets a list of customers.
*
* This will only resolve after the client is authenticated.
* @returns {Promise} List of customers contained within the token
*/
}, {
key: 'customers',
value: function customers() {
return this.client.authenticated.then(function (user) {
return Object.keys(user.cust).map(function (code) {
return {
code: code,
name: user.cust[code]
};
});
});
}
/**
* Gets a customer resource.
* @param {string} code Customer code
* @returns {Customer} Customer resource
*/
}, {
key: 'customer',
value: function customer(code) {
return this.resource(_Customer2.default, this.realTimeClient, code);
}
/**
* Gets a context for querying this customer's external APIs
* @returns {ExternalApisContext} Context for querying this customer's external APIs
*/
}, {
key: 'externalApis',
value: function externalApis() {
return this.resource(_ExternalApisContext2.default);
}
/**
* Gets an external API resource by id
* @param {Number} id Identity of the external API
* @returns {ExternalApi} ExternalApi resource
*/
}, {
key: 'externalApi',
value: function externalApi(id) {
return this.resource(_ExternalApi2.default, _ExternalApi2.default.makeHref(id));
}
/**
* Gets a context for querying system-wide roles
* @returns {RolesContext} Context for querying system-wide roles
*/
}, {
key: 'roles',
value: function roles() {
return this.resource(_RolesContext2.default);
}
/**
* Gets a role resource by id
* @param {Number} id Identity of the role
* @returns {Role} Role resource
*/
}, {
key: 'role',
value: function role(id) {
return this.resource(_Role2.default, _Role2.default.makeHref(id));
}
/**
* Gets a user resource. Defaults to user for current authenticated session.
* @param {number|string} [id=me] User ID
* @returns {User} User resource
*/
}, {
key: 'user',
value: function user() {
var id = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'me';
return this.resource(_User2.default, _User2.default.makeHref(id));
}
}], [{
key: 'validateJwt',
value: function validateJwt(_ref) {
var claim = _ref.claim;
if (!claim) return false;
var now = Date.now() / 1000;
var exp = claim.exp,
nbf = claim.nbf;
if (exp && exp < now) return false;
if (nbf && nbf > now) return false;
return true;
}
}]);
return Track;
}(_Resource3.default);
exports.default = Track;
/***/ }),
/* 3 */
/***/ (function(module, exports, __webpack_require__) {
// the whatwg-fetch polyfill installs the fetch() function
// on the global object (window or self)
//
// Return that as the export for use in Webpack, Browserify etc.
__webpack_require__(4);
module.exports = self.fetch.bind(self);
/***/ }),
/* 4 */
/***/ (function(module, exports) {
(function(self) {
'use strict';
if (self.fetch) {
return
}
var support = {
searchParams: 'URLSearchParams' in self,
iterable: 'Symbol' in self && 'iterator' in Symbol,
blob: 'FileReader' in self && 'Blob' in self && (function() {
try {
new Blob()
return true
} catch(e) {
return false
}
})(),
formData: 'FormData' in self,
arrayBuffer: 'ArrayBuffer' in self
}
if (support.arrayBuffer) {
var viewClasses = [
'[object Int8Array]',
'[object Uint8Array]',
'[object Uint8ClampedArray]',
'[object Int16Array]',
'[object Uint16Array]',
'[object Int32Array]',
'[object Uint32Array]',
'[object Float32Array]',
'[object Float64Array]'
]
var isDataView = function(obj) {
return obj && DataView.prototype.isPrototypeOf(obj)
}
var isArrayBufferView = ArrayBuffer.isView || function(obj) {
return obj && viewClasses.indexOf(Object.prototype.toString.call(obj)) > -1
}
}
function normalizeName(name) {
if (typeof name !== 'string') {
name = String(name)
}
if (/[^a-z0-9\-#$%&'*+.\^_`|~]/i.test(name)) {
throw new TypeError('Invalid character in header field name')
}
return name.toLowerCase()
}
function normalizeValue(value) {
if (typeof value !== 'string') {
value = String(value)
}
return value
}
// Build a destructive iterator for the value list
function iteratorFor(items) {
var iterator = {
next: function() {
var value = items.shift()
return {done: value === undefined, value: value}
}
}
if (support.iterable) {
iterator[Symbol.iterator] = function() {
return iterator
}
}
return iterator
}
function Headers(headers) {
this.map = {}
if (headers instanceof Headers) {
headers.forEach(function(value, name) {
this.append(name, value)
}, this)
} else if (Array.isArray(headers)) {
headers.forEach(function(header) {
this.append(header[0], header[1])
}, this)
} else if (headers) {
Object.getOwnPropertyNames(headers).forEach(function(name) {
this.append(name, headers[name])
}, this)
}
}
Headers.prototype.append = function(name, value) {
name = normalizeName(name)
value = normalizeValue(value)
var oldValue = this.map[name]
this.map[name] = oldValue ? oldValue+','+value : value
}
Headers.prototype['delete'] = function(name) {
delete this.map[normalizeName(name)]
}
Headers.prototype.get = function(name) {
name = normalizeName(name)
return this.has(name) ? this.map[name] : null
}
Headers.prototype.has = function(name) {
return this.map.hasOwnProperty(normalizeName(name))
}
Headers.prototype.set = function(name, value) {
this.map[normalizeName(name)] = normalizeValue(value)
}
Headers.prototype.forEach = function(callback, thisArg) {
for (var name in this.map) {
if (this.map.hasOwnProperty(name)) {
callback.call(thisArg, this.map[name], name, this)
}
}
}
Headers.prototype.keys = function() {
var items = []
this.forEach(function(value, name) { items.push(name) })
return iteratorFor(items)
}
Headers.prototype.values = function() {
var items = []
this.forEach(function(value) { items.push(value) })
return iteratorFor(items)
}
Headers.prototype.entries = function() {
var items = []
this.forEach(function(value, name) { items.push([name, value]) })
return iteratorFor(items)
}
if (support.iterable) {
Headers.prototype[Symbol.iterator] = Headers.prototype.entries
}
function consumed(body) {
if (body.bodyUsed) {
return Promise.reject(new TypeError('Already read'))
}
body.bodyUsed = true
}
function fileReaderReady(reader) {
return new Promise(function(resolve, reject) {
reader.onload = function() {
resolve(reader.result)
}
reader.onerror = function() {
reject(reader.error)
}
})
}
function readBlobAsArrayBuffer(blob) {
var reader = new FileReader()
var promise = fileReaderReady(reader)
reader.readAsArrayBuffer(blob)
return promise
}
function readBlobAsText(blob) {
var reader = new FileReader()
var promise = fileReaderReady(reader)
reader.readAsText(blob)
return promise
}
function readArrayBufferAsText(buf) {
var view = new Uint8Array(buf)
var chars = new Array(view.length)
for (var i = 0; i < view.length; i++) {
chars[i] = String.fromCharCode(view[i])
}
return chars.join('')
}
function bufferClone(buf) {
if (buf.slice) {
return buf.slice(0)
} else {
var view = new Uint8Array(buf.byteLength)
view.set(new Uint8Array(buf))
return view.buffer
}
}
function Body() {
this.bodyUsed = false
this._initBody = function(body) {
this._bodyInit = body
if (!body) {
this._bodyText = ''
} else if (typeof body === 'string') {
this._bodyText = body
} else if (support.blob && Blob.prototype.isPrototypeOf(body)) {
this._bodyBlob = body
} else if (support.formData && FormData.prototype.isPrototypeOf(body)) {
this._bodyFormData = body
} else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
this._bodyText = body.toString()
} else if (support.arrayBuffer && support.blob && isDataView(body)) {
this._bodyArrayBuffer = bufferClone(body.buffer)
// IE 10-11 can't handle a DataView body.
this._bodyInit = new Blob([this._bodyArrayBuffer])
} else if (support.arrayBuffer && (ArrayBuffer.prototype.isPrototypeOf(body) || isArrayBufferView(body))) {
this._bodyArrayBuffer = bufferClone(body)
} else {
throw new Error('unsupported BodyInit type')
}
if (!this.headers.get('content-type')) {
if (typeof body === 'string') {
this.headers.set('content-type', 'text/plain;charset=UTF-8')
} else if (this._bodyBlob && this._bodyBlob.type) {
this.headers.set('content-type', this._bodyBlob.type)
} else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
this.headers.set('content-type', 'application/x-www-form-urlencoded;charset=UTF-8')
}
}
}
if (support.blob) {
this.blob = function() {
var rejected = consumed(this)
if (rejected) {
return rejected
}
if (this._bodyBlob) {
return Promise.resolve(this._bodyBlob)
} else if (this._bodyArrayBuffer) {
return Promise.resolve(new Blob([this._bodyArrayBuffer]))
} else if (this._bodyFormData) {
throw new Error('could not read FormData body as blob')
} else {
return Promise.resolve(new Blob([this._bodyText]))
}
}
this.arrayBuffer = function() {
if (this._bodyArrayBuffer) {
return consumed(this) || Promise.resolve(this._bodyArrayBuffer)
} else {
return this.blob().then(readBlobAsArrayBuffer)
}
}
}
this.text = function() {
var rejected = consumed(this)
if (rejected) {
return rejected
}
if (this._bodyBlob) {
return readBlobAsText(this._bodyBlob)
} else if (this._bodyArrayBuffer) {
return Promise.resolve(readArrayBufferAsText(this._bodyArrayBuffer))
} else if (this._bodyFormData) {
throw new Error('could not read FormData body as text')
} else {
return Promise.resolve(this._bodyText)
}
}
if (support.formData) {
this.formData = function() {
return this.text().then(decode)
}
}
this.json = function() {
return this.text().then(JSON.parse)
}
return this
}
// HTTP methods whose capitalization should be normalized
var methods = ['DELETE', 'GET', 'HEAD', 'OPTIONS', 'POST', 'PUT']
function normalizeMethod(method) {
var upcased = method.toUpperCase()
return (methods.indexOf(upcased) > -1) ? upcased : method
}
function Request(input, options) {
options = options || {}
var body = options.body
if (input instanceof Request) {
if (input.bodyUsed) {
throw new TypeError('Already read')
}
this.url = input.url
this.credentials = input.credentials
if (!options.headers) {
this.headers = new Headers(input.headers)
}
this.method = input.method
this.mode = input.mode
if (!body && input._bodyInit != null) {
body = input._bodyInit
input.bodyUsed = true
}
} else {
this.url = String(input)
}
this.credentials = options.credentials || this.credentials || 'omit'
if (options.headers || !this.headers) {
this.headers = new Headers(options.headers)
}
this.method = normalizeMethod(options.method || this.method || 'GET')
this.mode = options.mode || this.mode || null
this.referrer = null
if ((this.method === 'GET' || this.method === 'HEAD') && body) {
throw new TypeError('Body not allowed for GET or HEAD requests')
}
this._initBody(body)
}
Request.prototype.clone = function() {
return new Request(this, { body: this._bodyInit })
}
function decode(body) {
var form = new FormData()
body.trim().split('&').forEach(function(bytes) {
if (bytes) {
var split = bytes.split('=')
var name = split.shift().replace(/\+/g, ' ')
var value = split.join('=').replace(/\+/g, ' ')
form.append(decodeURIComponent(name), decodeURIComponent(value))
}
})
return form
}
function parseHeaders(rawHeaders) {
var headers = new Headers()
rawHeaders.split(/\r?\n/).forEach(function(line) {
var parts = line.split(':')
var key = parts.shift().trim()
if (key) {
var value = parts.join(':').trim()
headers.append(key, value)
}
})
return headers
}
Body.call(Request.prototype)
function Response(bodyInit, options) {
if (!options) {
options = {}
}
this.type = 'default'
this.status = 'status' in options ? options.status : 200
this.ok = this.status >= 200 && this.status < 300
this.statusText = 'statusText' in options ? options.statusText : 'OK'
this.headers = new Headers(options.headers)
this.url = options.url || ''
this._initBody(bodyInit)
}
Body.call(Response.prototype)
Response.prototype.clone = function() {
return new Response(this._bodyInit, {
status: this.status,
statusText: this.statusText,
headers: new Headers(this.headers),
url: this.url
})
}
Response.error = function() {
var response = new Response(null, {status: 0, statusText: ''})
response.type = 'error'
return response
}
var redirectStatuses = [301, 302, 303, 307, 308]
Response.redirect = function(url, status) {
if (redirectStatuses.indexOf(status) === -1) {
throw new RangeError('Invalid status code')
}
return new Response(null, {status: status, headers: {location: url}})
}
self.Headers = Headers
self.Request = Request
self.Response = Response
self.fetch = function(input, init) {
return new Promise(function(resolve, reject) {
var request = new Request(input, init)
var xhr = new XMLHttpRequest()
xhr.onload = function() {
var options = {
status: xhr.status,
statusText: xhr.statusText,
headers: parseHeaders(xhr.getAllResponseHeaders() || '')
}
options.url = 'responseURL' in xhr ? xhr.responseURL : options.headers.get('X-Request-URL')
var body = 'response' in xhr ? xhr.response : xhr.responseText
resolve(new Response(body, options))
}
xhr.onerror = function() {
reject(new TypeError('Network request failed'))
}
xhr.ontimeout = function() {
reject(new TypeError('Network request failed'))
}
xhr.open(request.method, request.url, true)
if (request.credentials === 'include') {
xhr.withCredentials = true
}
if ('responseType' in xhr && support.blob) {
xhr.responseType = 'blob'
}
request.headers.forEach(function(value, name) {
xhr.setRequestHeader(name, value)
})
xhr.send(typeof request._bodyInit === 'undefined' ? null : request._bodyInit)
})
}
self.fetch.polyfill = true
})(typeof self !== 'undefined' ? self : this);
/***/ }),
/* 5 */
/***/ (function(module, exports, __webpack_require__) {
var __WEBPACK_AMD_DEFINE_RESULT__;/* WEBPACK VAR INJECTION */(function(module, global) {/*! https://mths.be/base64 v1.0.0 by @mathias | MIT license */
;(function(root) {
// Detect free variables `exports`.
var freeExports = typeof exports == 'object' && exports;
// Detect free variable `module`.
var freeModule = typeof module == 'object' && module &&
module.exports == freeExports && module;
// Detect free variable `global`, from Node.js or Browserified code, and use
// it as `root`.
var freeGlobal = typeof global == 'object' && global;
if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {
root = freeGlobal;
}
/*--------------------------------------------------------------------------*/
var InvalidCharacterError = function(message) {
this.message = message;
};
InvalidCharacterError.prototype = new Error;
InvalidCharacterError.prototype.name = 'InvalidCharacterError';
var error = function(message) {
// Note: the error messages used throughout this file match those used by
// the native `atob`/`btoa` implementation in Chromium.
throw new InvalidCharacterError(message);
};
var TABLE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
// http://whatwg.org/html/common-microsyntaxes.html#space-character
var REGEX_SPACE_CHARACTERS = /[\t\n\f\r ]/g;
// `decode` is designed to be fully compatible with `atob` as described in the
// HTML Standard. http://whatwg.org/html/webappapis.html#dom-windowbase64-atob
// The optimized base64-decoding algorithm used is based on @atk’s excellent
// implementation. https://gist.github.com/atk/1020396
var decode = function(input) {
input = String(input)
.replace(REGEX_SPACE_CHARACTERS, '');
var length = input.length;
if (length % 4 == 0) {
input = input.replace(/==?$/, '');
length = input.length;
}
if (
length % 4 == 1 ||
// http://whatwg.org/C#alphanumeric-ascii-characters
/[^+a-zA-Z0-9/]/.test(input)
) {
error(
'Invalid character: the string to be decoded is not correctly encoded.'
);
}
var bitCounter = 0;
var bitStorage;
var buffer;
var output = '';
var position = -1;
while (++position < length) {
buffer = TABLE.indexOf(input.charAt(position));
bitStorage = bitCounter % 4 ? bitStorage * 64 + buffer : buffer;
// Unless this is the first of a group of 4 characters…
if (bitCounter++ % 4) {
// …convert the first 8 bits to a single ASCII character.
output += String.fromCharCode(
0xFF & bitStorage >> (-2 * bitCounter & 6)
);
}
}
return output;
};
// `encode` is designed to be fully compatible with `btoa` as described in the
// HTML Standard: http://whatwg.org/html/webappapis.html#dom-windowbase64-btoa
var encode = function(input) {
input = String(input);
if (/[^\0-\xFF]/.test(input)) {
// Note: no need to special-case astral symbols here, as surrogates are
// matched, and the input is supposed to only contain ASCII anyway.
error(
'The string to be encoded contains characters outside of the ' +
'Latin1 range.'
);
}
var padding = input.length % 3;
var output = '';
var position = -1;
var a;
var b;
var c;
var buffer;
// Make sure any padding is handled outside of the loop.
var length = input.length - padding;
while (++position < length) {
// Read three bytes, i.e. 24 bits.
a = input.charCodeAt(position) << 16;
b = input.charCodeAt(++position) << 8;
c = input.charCodeAt(++position);
buffer = a + b + c;
// Turn the 24 bits into four chunks of 6 bits each, and append the
// matching character for each of them to the output.
output += (
TABLE.charAt(buffer >> 18 & 0x3F) +
TABLE.charAt(buffer >> 12 & 0x3F) +
TABLE.charAt(buffer >> 6 & 0x3F) +
TABLE.charAt(buffer & 0x3F)
);
}
if (padding == 2) {
a = input.charCodeAt(position) << 8;
b = input.charCodeAt(++position);
buffer = a + b;
output += (
TABLE.charAt(buffer >> 10) +
TABLE.charAt((buffer >> 4) & 0x3F) +
TABLE.charAt((buffer << 2) & 0x3F) +
'='
);
} else if (padding == 1) {
buffer = input.charCodeAt(position);
output += (
TABLE.charAt(buffer >> 2) +
TABLE.charAt((buffer << 4) & 0x3F) +
'=='
);
}
return output;
};
var base64 = {
'encode': encode,
'decode': decode,
'version': '1.0.0'
};
// Some AMD build optimizers, like r.js, check for specific condition patterns
// like the following:
if (
true
) {
!(__WEBPACK_AMD_DEFINE_RESULT__ = function() {
return base64;
}.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
} else if (freeExports && !freeExports.nodeType) {
if (freeModule) { // in Node.js or RingoJS v0.8.0+
freeModule.exports = base64;
} else { // in Narwhal or RingoJS v0.7.0-
for (var key in base64) {
base64.hasOwnProperty(key) && (freeExports[key] = base64[key]);
}
}
} else { // in Rhino or a web browser
root.base64 = base64;
}
}(this));
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(6)(module), (function() { return this; }())))
/***/ }),
/* 6 */
/***/ (function(module, exports) {
module.exports = function(module) {
if(!module.webpackPolyfill) {
module.deprecate = function() {};
module.paths = [];
// module.parent = undefined by default
module.children = [];
module.webpackPolyfill = 1;
}
return module;
}
/***/ }),
/* 7 */
/***/ (function(module, exports) {
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
/**
* Base "Resource" context type for all other resources
*/
var Resource = function () {
/**
* Creates a new resource
* @param {Client} client Instance of pre-configured client
*/
function Resource(client) {
_classCallCheck(this, Resource);
if (!client) {
throw new Error('Argument "client" is not specified');
}
/**
* Instance of pre-configured client
* @instance
*/
this.client = client;
/**
* Determines whether the resource has been hydrated with data from a call through the client
* @instance
*/
this.hydrated = false;
}
/**
* Convenience method for getting an instance of another Resource
* @param {Object} Type Type of resource to create
* @param {Array} rest Arguments to pass into constructor of Type
* @returns {Object} Instance of Type constructed with the given arguments
*/
_createClass(Resource, [{
key: 'resource',
value: function resource(Type) {
for (var _len = arguments.length, rest = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
rest[_key - 1] = arguments[_key];
}
return new (Function.prototype.bind.apply(Type, [null].concat([this.client], rest)))();
}
}]);
return Resource;
}();
exports.default = Resource;
/***/ }),
/* 8 */
/***/ (function(module, exports, __webpack_require__) {
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _RealTimeContextFactory = __webpack_require__(9);
var _RealTimeContextFactory2 = _interopRequireDefault(_RealTimeContextFactory);
var _Resource2 = __webpack_require__(7);
var _Resource3 = _interopRequireDefault(_Resource2);
var _Agency = __webpack_require__(35);
var _Agency2 = _interopRequireDefault(_Agency);
var _Area = __webpack_require__(36);
var _Area2 = _interopRequireDefault(_Area);
var _AreasContext = __webpack_require__(47);
var _AreasContext2 = _interopRequireDefault(_AreasContext);
var _Asset = __webpack_require__(61);
var _Asset2 = _interopRequireDefault(_Asset);
var _AssetsContext = __webpack_require__(62);
var _AssetsContext2 = _interopRequireDefault(_AssetsContext);
var _AssignableRoute = __webpack_require__(63);
var _AssignableRoute2 = _interopRequireDefault(_AssignableRoute);
var _AssignableRoutesContext = __webpack_require__(64);
var _AssignableRoutesContext2 = _interopRequireDefault(_AssignableRoutesContext);
var _AssignableStop = __webpack_require__(65);
var _AssignableStop2 = _interopRequireDefault(_AssignableStop);
var _AssignableStopsContext = __webpack_require__(66);
var _AssignableStopsContext2 = _interopRequireDefault(_AssignableStopsContext);
var _Assignment = __webpack_require__(38);
var _Assignment2 = _interopRequireDefault(_Assignment);
var _Block = __webpack_require__(44);
var _Block2 = _interopRequireDefault(_Block);
var _CustomerUsersContext = __webpack_require__(67);
var _CustomerUsersContext2 = _interopRequireDefault(_CustomerUsersContext);
var _Call = __webpack_require__(69);
var _Call2 = _interopRequireDefault(_Call);
var _CallParticipant = __webpack_require__(70);
var _CallParticipant2 = _interopRequireDefault(_CallParticipant);
var _DispatchMessage = __webpack_require__(71);
var _DispatchMessage2 = _interopRequireDefault(_DispatchMessage);
var _DispatchMessagesContext = __webpack_require__(72);
var _DispatchMessagesContext2 = _interopRequireDefault(_DispatchMessagesContext);
var _DispatchMessageBatch = __webpack_require__(73);
var _DispatchMessageBatch2 = _interopRequireDefault(_DispatchMessageBatch);
var _Driver = __webpack_require__(39);
var _Driver2 = _interopRequireDefault(_Driver);
var _DriversContext = __webpack_require__(74);
var _DriversContext2 = _interopRequireDefault(_DriversContext);
var _ExternalApi = __webpack_require__(75);
var _ExternalApi2 = _interopRequireDefault(_ExternalApi);
var _ExternalApisContext = __webpack_require__(76);
var _ExternalApisContext2 = _interopRequireDefault(_ExternalApisContext);
var _Incident = __webpack_require__(77);
var _Incident2 = _interopRequireDefault(_Incident);
var _EnplugScreenshot = __webpack_require__(78);
var _EnplugScreenshot2 = _interopRequireDefault(_EnplugScreenshot);
var _EnplugConfiguration = __webpack_require__(79);
var _EnplugConfiguration2 = _interopRequireDefault(_EnplugConfiguration);
var _Message = __webpack_require__(80);
var _Message2 = _interopRequireDefault(_Message);
var _MessagesContext = __webpack_require__(84);
var _MessagesContext2 = _interopRequireDefault(_MessagesContext);
var _MessageChannels = __webpack_require__(85);
var _MessageChannels2 = _interopRequireDefault(_MessageChannels);
var _DispatchMessageStatus = __webpack_require__(86);
var _DispatchMessageStatus2 = _interopRequireDefault(_DispatchMessageStatus);
var _Pattern = __webpack_require__(40);
var _Pattern2 = _interopRequireDefault(_Pattern);
var _PatternsContext = __webpack_require__(87);
var _PatternsContext2 = _interopRequireDefault(_PatternsContext);
var _ReportingTicket = __webpack_require__(88);
var _ReportingTicket2 = _interopRequireDefault(_ReportingTicket);
var _RiderAppConfiguration = __webpack_require__(89);
var _RiderAppConfiguration2 = _interopRequireDefault(_RiderAppConfiguration);
var _Route = __webpack_require__(41);
var _Route2 = _interopRequireDefault(_Route);
var _RoutesContext = __webpack_require__(90);
var _RoutesContext2 = _interopRequireDefault(_RoutesContext);
var _Run = __webpack_require__(42);
var _Run2 = _interopRequireDefault(_Run);
var _Service = __webpack_require__(45);
var _Service2 = _interopRequireDefault(_Service);
var _ServicePackage = __webpack_require__(91);
var _ServicePackage2 = _interopRequireDefault(_ServicePackage);
var _ServicePackagesContext = __webpack_require__(92);
var _ServicePackagesContext2 = _interopRequireDefault(_ServicePackagesContext);
var _Settings = __webpack_require__(93);
var _Settings2 = _interopRequireDefault(_Settings);
var _Sign = __webpack_require__(94);
var _Sign2 = _interopRequireDefault(_Sign);
var _SignsContext = __webpack_require__(95);
var _SignsContext2 = _interopRequireDefault(_SignsContext);
var _Stop = __webpack_require__(82);
var _Stop2 = _interopRequireDefault(_Stop);
var _StopsContext = __webpack_require__(96);
var _StopsContext2 = _interopRequireDefault(_StopsContext);
var _Tag = __webpack_require__(83);
var _Tag2 = _interopRequireDefault(_Tag);
var _TagsContext = __webpack_require__(97);
var _TagsContext2 = _interopRequireDefault(_TagsContext);
var _Trip = __webpack_require__(43);
var _Trip2 = _interopRequireDefault(_Trip);
var _TwitterOAuth = __webpack_require__(98);
var _TwitterOAuth2 = _interopRequireDefault(_TwitterOAuth);
var _TwitterOAuthRequest = __webpack_require__(99);
var _TwitterOAuthRequest2 = _interopRequireDefault(_TwitterOAuthRequest);
var _TwitterUsername = __webpack_require__(100);
var _TwitterUsername2 = _interopRequireDefault(_TwitterUsername);
var _Vehicle = __webpack_require__(37);
var _Vehicle2 = _interopRequireDefault(_Vehicle);
var _VehiclesContext = __webpack_require__(101);
var _VehiclesContext2 = _interopRequireDefault(_VehiclesContext);
var _VoipTicket = __webpack_require__(102);
var _VoipTicket2 = _interopRequireDefault(_VoipTicket);
var _VoipCallRecordsContext = __webpack_require__(103);
var _VoipCallRecordsContext2 = _interopRequireDefault(_VoipCallRecordsContext);
var _VoipCallRecord = __webpack_require__(104);
var _VoipCallRecord2 = _interopRequireDefault(_VoipCallRecord);
var _TripCancelationBatch = __webpack_require__(105);
var _TripCancelationBatch2 = _interopRequireDefault(_TripCancelationBatch);
var _Detour = __webpack_require__(107);
var _Detour2 = _interopRequireDefault(_Detour);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
/**
* Customer resource
*
* This acts as the context for accessing all customer-specific data.
*/
var Customer = function (_Resource) {
_inherits(Customer, _Resource);
/**
* Creates a new resource
* @param {Client} client Instance of pre-configured client
* @param {RealTimeClient} realTimeClient Instance of pre-configured realtime client
* @param {string} customerCode Customer code
*/
function Customer(client, realTimeClient, customerCode) {
_classCallCheck(this, Customer);
var _this = _possibleConstructorReturn(this, (Customer.__proto__ || Object.getPrototypeOf(Customer)).call(this, client));
_this.realTimeClient = realTimeClient;
/**
* Customer code
* @instance
*/
_this.code = customerCode;
return _this;
}
/**
* Gets a context for receiving realtime updates for this customer's data.
* @returns {RealTimeContext} Context for receiving realtime updates for this customer's data.
*/
_createClass(Customer, [{
key: 'realTime',
value: function realTime() {
return new _RealTimeContextFactory2.default(this.realTimeClient, this.code);
}
/**
* Gets the single agency record associated with this customer
* @param {Object} [payload={}] Optional values with which to initialize this agency.
* @returns {Agency} Agency resource
*/
}, {
key: 'agency',
value: function agency() {
var payload = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
return this.resource(_Agency2.default, _Agency2.default.makeHref(this.code), payload);
}
/**
* Gets an area resource by id
* @param {Number} id Identity of the area
* @returns {Area} Area resource
*/
}, {
key: 'area',
value: function area(id) {
return this.resource(_Area2.default, _Area2.default.makeHref(this.code, id));
}
/**
* Gets a context for querying this customer's areas
* @returns {AreasContext} Context for querying this customer's areas
*/
}, {
key: 'areas',
value: function areas() {
return this.resource(_AreasContext2.default, this.code);
}
/**
* Gets an asset resource by id
* @param {Object} payload Identity of the asset or object representing a new call
* @returns {Asset} Asset resource
*/
}, {
key: 'asset',
value: function asset(payload) {
if (!isNaN(parseFloat(payload)) && isFinite(payload)) {
return this.resource(_Asset2.default, _Asset2.default.makeHref(this.code, payload));
}
return this.resource(_Asset2.default, _extends({ code: this.code }, payload));
}
/**
* Gets a context for querying this customer's assets
* @returns {AssetsContext} Context for querying this customer's assets
*/
}, {
key: 'assets',
value: function assets() {
return this.resource(_AssetsContext2.default, this.code);
}
/**
* Gets an assignable route resource by id
* @param {Number} id Identity of the assignable route
* @returns {AssignableRoute} Assignable route resource
*/
}, {
key: 'assignableRoute',
value: function assignableRoute(id) {
return this.resource(_Assigna