@nec-baas/jssdk
Version:
NEC Mobile Backend Platform JavaScript SDK
1,313 lines (1,307 loc) • 217 kB
JavaScript
/*!
* NEC Mobile Backend Platform JavaScript SDK version 7.5.0
*
* Copyright 2014-2018, NEC Corporation.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
"use strict";
var XMLHttpRequest, localStorage;
(function(root, setup) {
var _module = {exports: {}};
var _exports = _module.exports;
setup.call(root, _module, _exports);
if (typeof module !== "undefined" &&
typeof module.exports !== "undefined" &&
typeof process !== "undefined" &&
typeof require !== "undefined") {
module.exports = _exports;
} else {
root.Nebula = _exports.Nebula;
}
})(this, function(module, exports) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
exports.root = this;
exports.nbError = function (message) {
if (typeof console !== "undefined") {
console.log("[BAAS ERROR] : " + message);
}
};
exports.nbLogger = function (message) {
if (exports.Nebula.getDebugMode() === "debug" && typeof console !== "undefined") {
console.log("[BAAS] : " + message);
}
};
exports._doBadRequestCallback = function (callbacks, name) {
exports.nbLogger(name + "#invalid parameter.");
var error = exports._createError(400, "Invalid Arguments", "Invalid Arguments");
if (callbacks && callbacks.error) {
callbacks.error(error);
return;
}
else {
return Promise.reject(error);
}
};
exports._promisify = function (promise, callbacks) {
if (callbacks) {
promise.then(function (arg) {
if (callbacks.success) {
callbacks.success(arg);
}
}).catch(function (err) {
if (callbacks.error) {
callbacks.error(err);
}
});
return undefined;
}
else {
return promise;
}
};
exports._createError = function (status, statusText, responseText, data) {
var error = new Error(statusText + "(" + status + ")");
error.status = status;
error.statusText = statusText;
error.responseText = responseText;
if (data) {
error.data = data;
}
return error;
};
exports._errorText = function (error) {
if (error && error.message) {
return error.message;
}
return error;
};
exports._isObject = function (value) {
var type = typeof value;
return value && type === 'object' || type === 'function';
};
exports._compareObject = function (src, target) {
var srcKeys = Object.keys(src);
var targetKeys = Object.keys(target);
if (srcKeys.length !== targetKeys.length) {
return false;
}
for (var _i = 0, srcKeys_1 = srcKeys; _i < srcKeys_1.length; _i++) {
var key = srcKeys_1[_i];
if (exports._isObject(src[key]) && exports._isObject(target[key])) {
if (!exports._compareObject(src[key], target[key])) {
return false;
}
}
else {
if (src[key] !== target[key]) {
return false;
}
}
}
return true;
};
exports.nbAssert = function (assert, message) {
if (!assert) {
if (exports.Nebula.getDebugMode() === "debug") {
throw new Error("Assertion failed. " + message);
}
else {
exports.nbError("Assertion failed. " + message);
}
}
};
exports.isNodeJs = function () {
return typeof require !== "undefined" && typeof process !== "undefined";
};
exports._node_require = function (module) {
try {
if (exports.isNodeJs()) {
return eval('require')(module);
}
else {
return null;
}
}
catch (e) {
return null;
}
};
exports.URL = exports._node_require('url');
exports.https = exports._node_require('https');
exports.http = exports._node_require('http');
exports.tls = exports._node_require('tls');
exports.fs = exports._node_require('fs');
exports.util = exports._node_require('util');
var __http2 = null;
try {
__http2 = exports._node_require('http2');
}
catch (e) {
}
exports.http2 = __http2;
exports._hasXhr = function () {
return typeof XMLHttpRequest !== "undefined";
};
var HttpRequestExecutor = (function () {
function HttpRequestExecutor(req) {
this._req = req;
this._resolve = req._resolve;
this._reject = req._reject;
}
HttpRequestExecutor.closeHttp2Session = function (authority) {
if (exports._hasXhr()) {
HttpXhr.closeHttp2Session(authority);
}
else {
HttpNode.closeHttp2Session(authority);
}
};
HttpRequestExecutor.create = function (req) {
if (exports._hasXhr()) {
return this._xhrFactory(req);
}
else {
return this._nodeFactory(req);
}
};
HttpRequestExecutor.setXhrFactory = function (factory) {
this._xhrFactory = factory;
};
HttpRequestExecutor.setNodeFactory = function (factory) {
this._nodeFactory = factory;
};
return HttpRequestExecutor;
}());
exports.HttpRequestExecutor = HttpRequestExecutor;
var HttpRequest = (function () {
function HttpRequest(service, path, option) {
this._rawMessage = false;
this._useHttp2 = false;
exports.nbLogger("HttpRequest#start:path = " + path);
this._service = service;
this._url = this._service.getBaseUri();
if (!(option && option.noprefix)) {
this._url += "/" + this._service.getRestApiVersion() + "/" + this._service.getTenantID();
}
this._url = encodeURI(this._url) + path;
this._headers = {};
this._contentType = null;
this._responseType = null;
this._queryParams = null;
this._data = null;
this._receiveResponseHeaders = false;
this._timeout = HttpRequest.getDefaultTimeout();
this._useHttp2 = this._service.getHttp2();
var _currentObj = this._service.getCurrentUser();
if (_currentObj === null) {
this._sessionToken = null;
}
else {
this._sessionToken = _currentObj.sessionToken;
}
}
HttpRequest.getProxy = function () {
return HttpRequest._proxy;
};
HttpRequest.setProxy = function (proxy) {
HttpRequest._proxy = proxy;
};
HttpRequest.setHttpAgent = function (agent) {
HttpRequest._httpAgent = agent;
};
HttpRequest.setHttpsAgent = function (agent, options) {
HttpRequest._httpsAgent = agent;
HttpRequest._httpsAgentOptions = options;
};
Object.defineProperty(HttpRequest.prototype, "service", {
get: function () {
return this._service;
},
enumerable: true,
configurable: true
});
Object.defineProperty(HttpRequest.prototype, "responseHeaders", {
get: function () {
return this._responseHeaders;
},
set: function (value) {
this._responseHeaders = value;
},
enumerable: true,
configurable: true
});
HttpRequest.setDefaultTimeout = function (timeout) {
this._defaultTimeout = timeout;
};
HttpRequest.getDefaultTimeout = function () {
return this._defaultTimeout;
};
Object.defineProperty(HttpRequest.prototype, "rawMessage", {
get: function () {
return this._rawMessage;
},
set: function (value) {
this._rawMessage = value;
},
enumerable: true,
configurable: true
});
Object.defineProperty(HttpRequest.prototype, "useHttp2", {
get: function () {
return this._useHttp2;
},
set: function (value) {
if (value && exports.http2 == null) {
throw new Error("No http2 support.");
}
this._useHttp2 = value;
},
enumerable: true,
configurable: true
});
HttpRequest.prototype.setReceiveResponseHeaders = function (receive) {
this._receiveResponseHeaders = receive;
return this;
};
HttpRequest.prototype.execute = function () {
var _this = this;
return new Promise(function (resolve, reject) {
_this._resolve = resolve;
_this._reject = reject;
_this._headers["X-Application-Id"] = _this._service.getAppID();
_this._headers["X-Application-Key"] = _this._service.getAppKey();
if (_this._contentType !== null) {
_this._headers["Content-Type"] = _this._contentType;
}
if (_this._sessionToken !== null) {
_this._headers["X-Session-Token"] = _this._sessionToken;
}
var url = _this._url;
if (_this._queryParams) {
var p = [];
for (var _i = 0, _a = Object.keys(_this._queryParams); _i < _a.length; _i++) {
var key = _a[_i];
if (_this._queryParams.hasOwnProperty(key)) {
p.push(encodeURIComponent(key) + "=" + encodeURIComponent(_this._queryParams[key]));
}
}
if (p.length > 0) {
url += "?" + p.join("&");
}
}
var body;
if (!(_this._data != null)) {
body = null;
}
else if ((typeof _this._data === "string") ||
(typeof Blob !== "undefined" && Blob !== null && _this._data instanceof Blob) ||
(typeof Buffer !== "undefined" && Buffer !== null && Buffer.isBuffer(_this._data))) {
body = _this._data;
}
else {
body = JSON.stringify(_this._data);
}
var executor = HttpRequestExecutor.create(_this);
if (_this._rawMessage) {
executor.setReturnRawMessage(_this._rawMessage);
}
executor.execute(_this._method, url, _this._headers, body, _this._timeout, _this._responseType, _this._receiveResponseHeaders, _this._useHttp2);
});
};
HttpRequest.closeHttp2Session = function (authority) {
HttpRequestExecutor.closeHttp2Session(authority);
};
HttpRequest.prototype.setMethod = function (method) {
this._method = method;
return this;
};
HttpRequest.prototype.setContentType = function (contentType) {
this._contentType = contentType;
return this;
};
HttpRequest.prototype.setQueryParams = function (params) {
this._queryParams = params;
return this;
};
HttpRequest.prototype.addQueryParams = function (params) {
if (params) {
for (var _i = 0, _a = Object.keys(params); _i < _a.length; _i++) {
var key = _a[_i];
this.setQueryParam(key, params[key]);
}
}
return this;
};
HttpRequest.prototype.setQueryParam = function (key, value) {
if (!this._queryParams) {
this._queryParams = {};
}
this._queryParams[key] = value;
return this;
};
HttpRequest.prototype.setData = function (data) {
this._data = data;
return this;
};
HttpRequest.prototype.setSessionToken = function (sessionToken) {
this._sessionToken = sessionToken;
return this;
};
HttpRequest.prototype.setResponseType = function (responseType) {
this._responseType = responseType;
return this;
};
HttpRequest.prototype.addRequestHeader = function (header, value) {
if (this._headers[header] !== undefined) {
exports.nbLogger("HTTP Request Warning : This header already exists.");
}
this._headers[header] = value;
return this;
};
HttpRequest._defaultTimeout = 0;
return HttpRequest;
}());
exports.HttpRequest = HttpRequest;
exports.initHttpXhr = function () {
HttpRequestExecutor.setXhrFactory(function (req) { return new HttpXhr(req); });
};
var HttpXhr = (function (_super) {
__extends(HttpXhr, _super);
function HttpXhr(req) {
var _this = _super.call(this, req) || this;
_this._onReadyStateChange = _this._onReadyStateChange.bind(_this);
return _this;
}
HttpXhr.prototype.setReturnRawMessage = function (rawMessage) {
throw new Error("Not supported");
};
HttpXhr.prototype.execute = function (method, url, headers, body, timeout, responseType, receiveResponseHeaders, useHttp2) {
var _this = this;
this._receiveResponseHeaders = receiveResponseHeaders;
this._xhr = this._createXhr();
this._xhr.open(method, url, true);
this._xhr.onreadystatechange = this._onReadyStateChange;
for (var _i = 0, _a = Object.keys(headers); _i < _a.length; _i++) {
var key = _a[_i];
var value = headers[key];
this._xhr.setRequestHeader(key, value);
}
this._xhr.timeout = timeout;
this._xhr.ontimeout = function (e) {
_this._onXhrTimeout(e);
};
try {
var userAgent = exports.root.navigator.userAgent.toLowerCase();
if (userAgent.match(/msie/) || userAgent.match(/trident/)) {
this._xhr.setRequestHeader("Pragma", "no-cache");
this._xhr.setRequestHeader("Cache-Control", "no-cache");
this._xhr.setRequestHeader("If-Modified-Since", "Thu, 01 Jun 1970 00:00:00 GMT");
}
else {
}
}
catch (e) {
}
if (responseType != null) {
this._xhr.responseType = responseType;
}
this._xhr.send(body);
};
HttpXhr.closeHttp2Session = function (authority) {
throw new Error("not support");
};
HttpXhr.prototype._createXhr = function () {
if (!exports._hasXhr()) {
throw new Error("No XMLHttpRequest");
}
return new XMLHttpRequest();
};
HttpXhr.prototype._onReadyStateChange = function () {
var xhr = this._xhr;
if (xhr.readyState === 4) {
if (xhr.status >= 200 && xhr.status < 300) {
var body = (xhr.response != null) ? xhr.response : xhr.responseText;
if (this._receiveResponseHeaders) {
return this._resolve({
body: body,
headers: xhr.getAllResponseHeaders(),
status: xhr.status
});
}
else {
return this._resolve(body);
}
}
else {
var error = exports._createError(xhr.status, xhr.statusText, "");
if (xhr.responseType !== "blob") {
error.responseText = xhr.responseText;
}
if (xhr.status === 0) {
error.statusText = "Not Found";
error.responseText = "Not found anything that matches the request URI.";
}
exports.nbError("HTTP Request Error: " + error.message + " " + error.responseText);
return this._reject(error);
}
}
};
HttpXhr.prototype._onXhrTimeout = function (e) {
var error = exports._createError(0, "Timeout error", e.toString());
exports.nbError("HTTP Response Error: Timeout Error: " + e.toString());
this._reject(error);
};
return HttpXhr;
}(HttpRequestExecutor));
exports.HttpXhr = HttpXhr;
HttpRequestExecutor.setXhrFactory(function (req) {
return new HttpXhr(req);
});
exports.initHttpNode = function () {
HttpRequestExecutor.setNodeFactory(function (req) { return new HttpNode(req); });
};
var HttpNode = (function (_super) {
__extends(HttpNode, _super);
function HttpNode(req) {
var _this = _super.call(this, req) || this;
_this._rawMessage = false;
return _this;
}
HttpNode.prototype.setReturnRawMessage = function (returnRawMessage) {
this._rawMessage = returnRawMessage;
};
HttpNode.prototype.execute = function (method, urlString, headers, body, timeout, responseType, receiveResponseHeaders, useHttp2) {
this._responseType = responseType;
this._receiveResponseHeaders = receiveResponseHeaders;
var url;
try {
url = exports.URL.parse(urlString);
}
catch (e) {
exports.nbError("Bad URL: " + urlString);
this._reject(exports._createError(0, "Bad URL: " + urlString, ""));
return;
}
var isHttps = HttpNode._isHttps(url);
var options = {
method: method,
hostname: url.hostname,
port: url.port,
path: url.path,
headers: headers,
agent: isHttps ? HttpRequest._httpsAgent : HttpRequest._httpAgent,
timeout: timeout,
pfx: null,
passphrase: null,
key: null,
cert: null,
ca: null,
privateKeyEngine: null,
privateKeyIdentifier: null,
rejectUnauthorized: true
};
if (isHttps) {
var allowedClientCertOptions = ['pfx', 'passphrase', 'key', 'cert', 'ca', 'privateKeyEngine', 'privateKeyIdentifier'];
var clientCertOptions = this._req.service._config.clientCertOptions;
if (clientCertOptions != null) {
for (var key in clientCertOptions) {
if (allowedClientCertOptions.indexOf(key) >= 0) {
options[key] = clientCertOptions[key];
}
else {
exports.nbError('invalid parameter ' + key + ' detected. value: ' + JSON.stringify(clientCertOptions[key]));
this._reject(exports._createError(0, 'invalid parameter: ' + key, ' value: ' + JSON.stringify(clientCertOptions[key])));
return;
}
}
}
if (this._req.service._config.allowSelfSignedCert) {
options.rejectUnauthorized = false;
exports.nbLogger('HTTPS Request Warning : accept self-signed certificate. make sure the risk of this setting.');
}
else {
options.rejectUnauthorized = true;
}
}
if (isHttps && options.agent != null && HttpRequest._httpsAgentOptions != null) {
try {
exports.tls.createSecureContext(HttpRequest._httpsAgentOptions);
}
catch (e) {
exports.nbError("HttpsAgentOptions invalid. check proxy options " + e.toString());
var error = exports._createError(0, "Client Error", e.toString());
this._reject(error);
return;
}
}
if (options['privateKeyEngine'] == null || options['privateKeyIdentifier'] == null) {
delete options['privateKeyEngine'];
delete options['privateKeyIdentifier'];
}
if (exports.http2 != null && useHttp2) {
this._sendHttp2Request(url, options, body);
}
else {
this._sendHttpRequest(url, options, body);
}
};
HttpNode.prototype._sendHttp2Request = function (url, options, body) {
var authority = url.protocol + '//' + url.hostname;
if (url.port != null) {
authority += ':' + url.port;
}
var sessions = HttpNode.getHttp2Sessions();
for (var key in sessions) {
var session = sessions[key];
if (session.destroyed == true || session.closed == true) {
exports.nbLogger('http2 session ' + authority + ' is destroyed or closed state');
HttpNode.closeHttp2Session(key);
}
}
var http2Session = HttpNode.getHttp2Session(authority);
if (http2Session == null) {
exports.nbLogger('create http2 session: [' + authority + ']');
var http2SessionOptions = {
allowHTTP1: true,
pfx: options['pfx'],
passphrase: options['passphrase'],
key: options['key'],
cert: options['cert'],
ca: options['ca'],
rejectUnauthorized: options['rejectUnauthorized']
};
http2Session = exports.http2.connect(authority, (HttpNode._isHttps(url) ? http2SessionOptions : undefined));
HttpNode.setHttp2Session(authority, http2Session);
}
var outgoingHttpHeaders = options.headers;
outgoingHttpHeaders[':method'] = options.method;
outgoingHttpHeaders[':path'] = url.path;
var http2Stream = http2Session.request(outgoingHttpHeaders);
if (options.timeout > 0) {
http2Stream.setTimeout(options.timeout, function () {
HttpNode._closeStream(http2Stream);
var error = exports._createError(0, "HTTP/2 Request timeout: " + options.timeout + "[msec]", "");
exports.nbError("Timeout detected: " + error);
});
}
if (this._rawMessage) {
this._resolve(http2Stream);
}
else {
this._setHttp2ResponseHandlers(http2Stream);
}
if (body != null) {
if (typeof body === "string" || body instanceof String || body instanceof Buffer) {
http2Stream.write(body);
}
else {
http2Stream.write(JSON.stringify(body));
}
}
http2Stream.end();
};
HttpNode.prototype._sendHttpRequest = function (url, options, body) {
var _this = this;
var handler = function (res) {
if (_this._rawMessage) {
_this._resolve(res);
}
else {
var status_1 = res.statusCode;
_this._req.responseHeaders = res.headers;
_this._setResponseHandlers(status_1, res);
}
};
var req = HttpNode._isHttps(url) ? exports.https.request(options, handler) : exports.http.request(options, handler);
if (options.timeout > 0) {
req.setTimeout(options.timeout, function () { return req.abort(); });
}
req.on('error', function (e) {
var error = exports._createError(0, "HTTP request error", e.toString());
exports.nbError("HTTP Request Error: " + e.toString());
_this._reject(error);
});
if (body != null) {
if (typeof body === "string" || body instanceof String || body instanceof Buffer) {
req.write(body);
}
else {
req.write(JSON.stringify(body));
}
}
req.end();
};
HttpNode._isHttps = function (url) {
return (url.protocol === 'https:');
};
HttpNode.prototype._setResponseHandlers = function (status, res) {
var _this = this;
var chunks = [];
res.on('data', function (data) {
chunks.push(data);
});
res.on('end', function () {
var buffer = Buffer.concat(chunks);
var responseBody = _this._parseNodeResponse(buffer);
if (200 <= status && status < 300) {
if (_this._receiveResponseHeaders) {
_this._resolve({
body: responseBody,
headers: res.headers,
status: status
});
}
else {
_this._resolve(responseBody);
}
}
else {
var responseText = (_this._responseType !== "buffer" && responseBody != null) ? responseBody.toString() : "";
var error = exports._createError(status, res.statusMessage, responseText, responseBody);
exports.nbError("HTTP Response Error: status=" + status + " - " + res.statusMessage);
_this._reject(error);
}
});
res.on('error', function (e) {
var error = exports._createError(0, "Client Error", e.toString());
exports.nbError("HTTP Response Error: Client Error: " + e.toString());
_this._reject(error);
});
};
HttpNode.prototype._setHttp2ResponseHandlers = function (stream) {
var _this = this;
var chunks = [];
var resHeaders = {};
var statusCode = 0;
stream.on('response', function (headers, flags) {
resHeaders = headers;
statusCode = Number(headers[exports.http2.constants.HTTP2_HEADER_STATUS]);
}).on('data', function (data) {
chunks.push(data);
}).on('end', function () {
var buffer = Buffer.concat(chunks);
var responseBody = _this._parseNodeResponse(buffer);
HttpNode._closeStream(stream);
if (200 <= statusCode && statusCode < 300) {
if (_this._receiveResponseHeaders) {
_this._resolve({
body: responseBody,
headers: resHeaders,
status: statusCode
});
}
else {
_this._resolve(responseBody);
}
}
else {
var statusMessage = (statusCode == 0) ? "Unable to get proper response" : "";
var responseText = (_this._responseType !== "buffer" && responseBody != null) ? responseBody.toString() : "";
var error = exports._createError(statusCode, statusMessage, responseText, responseBody);
exports.nbError("HTTP/2 Response Error: status=" + statusCode);
_this._reject(error);
}
}).on('error', function (e) {
HttpNode._closeStream(stream);
var error = exports._createError(0, "HTTP/2 Stream Error", e.toString());
exports.nbError("HTTP/2 Stream Error: " + e.toString());
_this._reject(error);
}).on('push', function (headers, flags) {
exports.nbLogger('HTTP/2 Stream push');
}).on('finish', function () {
exports.nbLogger('HTTP/2 Stream finish');
}).on('altsvc', function (alt, origin, streamId) {
exports.nbLogger('HTTP/2 Stream altsvc');
}).on('aborted', function () {
exports.nbLogger('HTTP/2 Stream aborted');
});
};
HttpNode.prototype._parseNodeResponse = function (buffer) {
try {
switch (this._responseType) {
default:
case 'text':
return buffer.toString('utf-8');
case 'json':
var s = buffer.toString('utf-8');
try {
return JSON.parse(s);
}
catch (e) {
return s;
}
case 'buffer':
return buffer;
}
}
catch (e) {
exports.nbError("bad response: e=" + e.toString());
return null;
}
};
HttpNode._closeSession = function (session, callback) {
if ('close' in session) {
session.close(callback);
}
else if ('shutdown' in session) {
var options = { 'graceful': true };
session.shutdown(options, callback);
}
else {
session.destroy();
session.removeAllListeners();
}
};
HttpNode._closeStream = function (stream) {
if ('close' in stream) {
stream.close();
}
else {
stream.destroy();
}
};
HttpNode.getHttp2Sessions = function () {
return HttpNode._http2Sessions;
};
HttpNode.getHttp2Session = function (authority) {
var session = null;
if (authority in HttpNode._http2Sessions) {
session = HttpNode._http2Sessions[authority];
}
return session;
};
HttpNode.setHttp2Session = function (authority, session) {
HttpNode._http2Sessions[authority] = session;
};
HttpNode.closeHttp2Session = function (authority) {
if (authority === undefined) {
for (var key in HttpNode._http2Sessions) {
HttpNode.closeHttp2Session(key);
}
return;
}
var session = HttpNode._http2Sessions[authority];
if (session != null) {
if (session.destroyed) {
session.removeAllListeners();
exports.nbLogger('HTTP/2 session [' + authority + '] is already destroyed');
}
else {
exports.nbLogger('HTTP/2 session [' + authority + '] is going to close');
HttpNode._closeSession(session, function () {
session.removeAllListeners();
exports.nbLogger('HTTP/2 session [' + authority + '] has been closed');
});
}
delete HttpNode._http2Sessions[authority];
}
};
HttpNode._http2Sessions = {};
return HttpNode;
}(HttpRequestExecutor));
exports.HttpNode = HttpNode;
HttpRequestExecutor.setNodeFactory(function (req) {
return new HttpNode(req);
});
var _SdeRequest = (function () {
function _SdeRequest(className, methodName) {
exports.nbLogger("_SdeRequest(), className=" + (className) + ", methodName=" + (methodName));
this._className = className;
this._methodName = methodName;
this._data = null;
}
_SdeRequest.prototype.setData = function (data) {
return this._data = data;
};
_SdeRequest.prototype.execute = function () {
var callbacks = {};
var promise = new Promise(function (resolve, reject) {
callbacks.success = resolve;
return callbacks.error = reject;
});
var reqId = _SdeRequest._createRequestId();
_SdeRequest._callbacks[reqId] = callbacks;
exports.nbLogger("_SdeRequest.execute(), reqId=" + reqId);
if (!(this._data != null)) {
this._data = {};
}
var data = {
data: this._data
};
var sdeParams = {
action: ((this._className) + "." + (this._methodName)),
request_id: reqId,
params: JSON.stringify(data),
callback: "Nebula._SdeRequest.sdeCallback"
};
exports.nbLogger("_SdeRequest.execute(), sdeParams=" + JSON.stringify(sdeParams));
sde.smt.common.exIfExecute("NebulaSdePlugin", "execute", sdeParams);
return promise;
};
_SdeRequest._createRequestId = function () {
for (var i = 0; i < 1000; i++) {
var requestId = "id_" + this._requestId;
this._requestId++;
if (this._requestId >= 1000) {
this._requestId = 0;
}
if (!this._callbacks[requestId]) {
exports.nbLogger("_SdeRequest._createRequestId(), requestId=" + requestId);
return requestId;
}
}
exports.nbLogger("FATAL Error: Nebula._SdeRequest._createRequestId(), callback slot full!");
throw new Error("Could not create request ID, callback slot full!");
};
_SdeRequest.sdeCallback = function (params) {
try {
exports.nbLogger("_SdeRequest.sdeCallback()");
exports.nbLogger(" params=" + JSON.stringify(params));
exports.nbLogger(" requestId=" + params.requestId);
exports.nbLogger(" status=" + params.status);
exports.nbLogger(" statusText=" + params.statusText);
exports.nbLogger(" responseText=" + params.responseText);
exports.nbLogger(" response=" + params.response);
var requestId = params.requestId;
if (requestId != null && _SdeRequest._callbacks[requestId] != null) {
var callbacks = _SdeRequest._callbacks[requestId];
exports.nbLogger(" requestId=" + requestId);
exports.nbLogger(" _callbacks[requestId]=" + callbacks);
var status_2 = params.status;
if (!status_2) {
exports.nbLogger("_SdeRequest.sdeCallback(), warning:: not found status property");
status_2 = 0;
}
if (status_2 >= 200 && status_2 < 300) {
exports.nbLogger("_SdeRequest.sdeCallback(), call success callback");
callbacks.success(JSON.stringify(params.response));
}
else {
var errorResult = exports._createError(params.status, params.statusText, params.responseText);
exports.nbLogger("Nebula._SdeRequest.sdeCallback(), call error callback: " + errorResult.message
+ " " + errorResult.responseText);
callbacks.error(errorResult);
}
delete _SdeRequest._callbacks[requestId];
exports.nbLogger("_SdeRequest.sdeCallback(), _callbacks : " + JSON.stringify(_SdeRequest._callbacks));
}
else {
exports.nbError("_SdeRequest.sdeCallback(), not found requestId=" + requestId);
}
}
catch (e) {
exports.nbError("_SdeRequest.sdeCallback(), e=" + e);
}
};
_SdeRequest._callbacks = {};
_SdeRequest._requestId = 0;
return _SdeRequest;
}());
exports._SdeRequest = _SdeRequest;
var _SdeNetworkEventListener = (function () {
function _SdeNetworkEventListener() {
}
_SdeNetworkEventListener.setCallback = function (callback) {
this._callback = callback;
exports.nbLogger("_SdeNetworkEventListener.setCallback(), callback=" + callback);
var data = {};
if (callback) {
data.set = true;
}
else {
data.set = false;
}
var sdeParams = {
action: "NebulaNetworkEventManager.setNetworkEventListener",
params: JSON.stringify(data),
callback: ""
};
exports.nbLogger("_SdeNetworkEventListener.setCallback(), sdeParams=" + JSON.stringify(sdeParams));
return sde.smt.common.exIfExecute("NebulaSdePlugin", "execute", sdeParams);
};
_SdeNetworkEventListener.onNetworkStateChanged = function (params) {
try {
exports.nbLogger("_SdeNetworkEventListener.onNetworkStateChanged(), params=" + JSON.stringify(params));
if (this._callback != null && this._callback.onNetworkStateChanged != null) {
if (params.isOnline != null) {
this._callback.onNetworkStateChanged(params.isOnline);
}
else {
exports.nbError("_SdeNetworkEventListener.onNetworkStateChanged(), invalid parameters");
}
}
else {
exports.nbLogger("_SdeNetworkEventListener.onNetworkStateChanged(), no callback");
}
}
catch (e) {
exports.nbError("_SdeNetworkEventListener.onNetworkStateChanged(), exception=" + e);
}
};
return _SdeNetworkEventListener;
}());
exports._SdeNetworkEventListener = _SdeNetworkEventListener;
var _SdeSyncEventListener = (function () {
function _SdeSyncEventListener() {
}
_SdeSyncEventListener.setListener = function (bucket, listener) {
if (bucket == null) {
exports.nbError("_SdeSyncEventListener.setCallback(), no bucket");
return;
}
exports.nbLogger("_SdeSyncEventListener.setCallback(), before : _listeners=" + JSON.stringify(this._listeners));
var bucketName = bucket.getBucketName();
var bucketMode = bucket.getBucketMode();
if (listener != null) {
this._listeners[bucketName] = listener;
this._bucketMode[bucketName] = bucketMode;
}
else {
if (this._listeners[bucketName] != null) {
delete this._listeners[bucketName];
}
if (this._bucketMode[bucketName] != null) {
delete this._bucketMode[bucketName];
}
}
exports.nbLogger("_SdeSyncEventListener.setCallback(), after : _listeners=" + JSON.stringify(this._listeners));
var data = {};
data.bucketName = bucketName;
data.bucketMode = bucketMode;
if (listener) {
data.set = true;
}
else {
data.set = false;
}
var sdeParams = {
action: "NebulaSyncEventManager.setSyncEventListener",
params: JSON.stringify(data),
callback: ""
};
exports.nbLogger("_SyncEventListener.setCallback(), sdeParams=" + JSON.stringify(sdeParams));
return sde.smt.common.exIfExecute("NebulaSdePlugin", "execute", sdeParams);
};
_SdeSyncEventListener.resolveConflict = function (data) {
exports.nbLogger("_SyncEventListener.resolveConflict(), data=" + data);
var sdeParams = {
action: "NebulaSyncEventManager.resolveConflict",
params: JSON.stringify(data),
callback: ""
};
exports.nbLogger("_SyncEventListener.resolveConflict(), sdeParams=" + JSON.stringify(sdeParams));
return sde.smt.common.exIfExecute("NebulaSdePlugin", "execute", sdeParams);
};
_SdeSyncEventListener.onSyncStart = function (params) {
try {
exports.nbLogger("_SdeSyncEventListener.onSyncStart(), params=" + JSON.stringify(params));
if (params.bucketName != null) {
var bucketName = params.bucketName;
var listener = _SdeSyncEventListener._listeners[bucketName];
if (listener && listener.onSyncStart) {
listener.onSyncStart(bucketName);
}
else {
exports.nbLogger("_SdeSyncEventListener.onSyncStart(), no callback or onSyncStart");
}
}
else {
exports.nbLogger("_SdeSyncEventListener.onSyncStart(), no bucketName");
}
}
catch (e) {
exports.nbLogger("_SdeSyncEventListener.onSyncStart(), exception=" + e);
}
};
_SdeSyncEventListener.onSyncCompleted = function (params) {
try {
exports.nbLogger("_SdeSyncEventListener.onSyncCompleted(), params=" + JSON.stringify(params));
exports.nbLogger("_SdeSyncEventListener.onSyncCompleted(), bucketName=" + params.bucketName);
exports.nbLogger("_SdeSyncEventListener.onSyncCompleted(), objectIds=" + params.objectIds);
if (params.bucketName != null && params.objectIds != null) {
var bucketName = params.bucketName;
var listener = _SdeSyncEventListener._listeners[bucketName];
if (listener && listener.onSyncCompleted) {
listener.onSyncCompleted(bucketName, params.objectIds);
}
else {
exports.nbLogger("_SdeSyncEventListener.onSyncCompleted(), no callback or onSyncCompleted");
}
}
else {
exports.nbLogger("_SdeSyncEventListener.onSyncCompleted(), no bucketName or objectIds");
}
}
catch (e) {
exports.nbLogger("_SdeSyncEventListener.onSyncCompleted(), exception=" + e);
}
};
_SdeSyncEventListener.onSyncConflicted = function (params) {
try {
exports.nbLogger("_SdeSyncEventListener.onSyncConflicted(), params=" + JSON.stringify(params));
exports.nbLogger("_SdeSyncEventListener.onSyncConflicted(), bucketName=" + params.bucketName);
exports.nbLogger("_SdeSyncEventListener.onSyncConflicted(), resolveId=" + params.resolveId);
exports.nbLogger("_SdeSyncEventListener.onSyncConflicted(), client=" + params.client);
exports.nbLogger("_SdeSyncEventListener.onSyncConflicted(), server=" + params.server);
if (params.bucketName != null && params.resolveId != null && params.client != null && params.server != null) {
var bucketName = params.bucketName;
var bucketMode = this._bucketMode[bucketName];
if (!(bucketMode != null)) {
bucketMode = exports.Nebula.BUCKET_MODE_REPLICA;
}
var listener = this._listeners[bucketName];
if (listener && listener.onSyncConflicted) {
var bucket = new exports.Nebula.ObjectBucket(bucketName, bucketMode);
bucket._setResolveId(params.resolveId);
listener.onSyncConflicted(bucket, params.client, params.server);
}
else {
exports.nbLogger("_SdeSyncEventListener.onSyncConflicted(), no callback or onSyncCompleted");
}
}
else {
exports.nbLogger("_SdeSyncEventListener.onSyncConflicted(), invalid parameters");
}
}
catch (e) {
exports.nbLogger("_SdeSyncEventListener.onSyncConflicted(), exception=" + e);
}
};
_SdeSyncEventListener.onResolveConflict = function (params) {
try {
exports.nbLogger("_SdeSyncEventListener.onResolveConflict(), params=" + JSON.stringify(params));
exports.nbLogger("_SdeSyncEventListener.onResolveConflict(), resolve=" + params.resolve);
exports.nbLogger("_SdeSyncEventListener.onResolveConflict(), object=" + params.object);
if (params.bucketName != null && params.resolve != null && params.object != null) {
var bucketName = params.bucketName;
var listener = _SdeSyncEventListener._listeners[bucketName];
if (listener && listener["onResolveConflict"]) {
listener.onResolveConflict(params.object, params.resolve);
}
else {
exports.nbLogger("Nebula._SdeSyncEventListener.onResolveConflict(), no callback or onResolveConflict");
}
}
else {
exports.nbLogger("_SdeSyncEventListener.onSyncConflicted(), invalid parameters");
}
}
catch (e) {
exports.nbLogger("_SdeSyncEventListener.onResolveConflict(), exception=" + e);
}
};
_SdeSyncEventListener.onSyncError = function (params) {
try {
exports.nbLogger("_SdeSyncEventListener.onSyncError(), params=" + JSON.stringify(params));
exports.nbLogger("_SdeSyncEventListener.onSyncError(), errorCode=" + params.errorCode);
exports.nbLogger("_SdeSyncEventListener.onSyncError(), object=" + params.object);
if (params.bucketName != null && params.errorCode != null && params.object != null) {
var bucketName = params.bucketName;
var listener = _SdeSyncEventListener._listeners[bucketName];
if (listener != null && listener.onSyncError != null) {
listener.onSyncError(params.errorCode, params.object);
}
else {
exports.nbLogger("_SdeSyncEventListener.onSyncError(), no callback or onSyncError");
}
}
else {
exports.nbLogger("_SdeSyncEventListener.onSyncError(), invalid parameters");
}
}
catch (e) {
exports.nbLogger("_SdeSyncEventListener.onSyncError(), exception=" + e);
}
};
_SdeSyncEventListener._listeners = {};
_SdeSyncEventListener._bucketMode = {};
return _SdeSyncEventListener;
}());
exports._SdeSyncEventListener = _SdeSyncEventListener;
var AccountLink = (function () {
function AccountLink() {
}
Object.defineProperty(AccountLink.prototype, "_id", {
get: function () { return this.__id; },
set: function (value) { this.__id = value; },
enumerable: true,
configurable: true
});
Object.defineProperty(AccountLink.prototype, "iss", {
get: function () { return this._iss; },
set: function (value) { this._iss = value; },
enumerable: true,
configurable: true
});
Object.defineProperty(AccountLink.prototype, "sub", {
get: function () { return this._sub; },
set: function (value) { this._sub = value; },
enumerable: true,
configurable: true
});
Object.defineProperty(AccountLink.prototype, "op", {
get: function () { return this._op; },
set: function (value) { this._op = value; },
enumerable: true,
configurable: true
});
AccountLink.prototype._setAccountLink = function (obj) {
if (obj._id != null) {
this.__id = obj._id;
}
if (obj.iss != null) {
this._iss = obj.iss;
}
if (obj.sub != null) {
this._sub = obj.sub;
}
if (obj.op != null) {
this._op = obj.op;
}
return this;
};
return AccountLink;
}());
exports.AccountLink = AccountLink;
exports.AclPermission = {
READ: "r",
WRITE: "w",
CREATE: "c",
UPDATE: "u",
DELETE: "d",
ADMIN: "admin",
OWNER: "owner"
};
exports.AclGroup = {
AUTHENTICATED: "g:authenticated",
ANONYMOUS: "g:anonymous"
};
var Acl = (function () {
function Acl(json) {
exports.nbLogger("Acl(), json=" + json);
this._acl = {
r: [],
w: [],
c: [],
u: [],
d: [],
admin: []
};
if (json) {
for (var _i = 0, _a = [Acl.OWNER, Acl.READ, Acl.WRITE, Acl.CREATE, Acl.UPDATE, Acl.DELETE, Acl.ADMIN]; _i < _a.length; _i++) {
var key = _a[_i];
if (json[key]) {
this._acl[key] = json[key];
}
}
}
}
Acl.prototype.addEntry = function (permission, entry) {
var entries = this._acl[permission];
if (!entries) {
return false;
}
if (!entry) {
return false;
}
var add = null;
if (entry instanceof User) {
add = entry._id;
}
else if (entry instanceof Group) {
add = "g:" + entry.groupname;
}
else {
add = entry;
}
var exist = false;
for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) {
var target = entries_1[_i];
if (target === add) {
exist = true;
break;
}
}
if (!exist) {
entries.push(add);
exports.nbLogger("Acl.addEntry(), added entry=" + add);
return true;
}
return false;
};
Acl.prototype.removeEntry = function (permission, entry) {
var entries = this._acl[permission];
if (!entries) {
return false;
}
if (!entry) {
return false;
}
var remove = null;
if (entry instanceof User) {
remove = entry._id;
}
else if (entry instanceof Group) {
remove = "g:" + entry.groupname;
}
else {
remove = entry;
}
for (var i = 0; i < entries.length; i++) {
var target = entries[i];
if (target === remove) {
entries.splice(i, 1);
exports.nbLogger("Acl.removeEntry(), removed entry=" + remove);
break;
}
}
};
Acl.prototype._setOwner = function (owner) {
this._acl[Acl.OWNER] = owner;
};
Acl.prototype.getOwner = function () {
if (this._acl.owner) {
return this._acl.owner;
}
return null;
};
Acl.prototype.getEntries = function (permission) {
var entries = this._acl[permission];
if (!entries) {
return null;
}
return entries;
};
Acl.prototype._set = function (acl) {
this._acl = acl;
};
Acl.prototype._hasEntry = function (permission, target) {
var entries = this._acl[permission];
if (entries) {
for (var _i = 0, entries_2 = entries; _i < entries_2.length; _i++) {
var entry = entries_2[_i];