comprodls-sdk 2.74.0 → 2.75.0

package/dist/comprodls-sdk.js

@@ -504,6 +504,7 @@ exports.PUB_API_URLS = {
 exports.PUSHX_API_URLS = {
     grantByUserOrgId: '/orgs/{orgId}/grants',
     grantByAccountId: '/accounts/{accountId}/grants',
+    grantV2: '/ver/v2/grants',
     getPushedEvents: '/accounts/{accountId}/pushed-events/channels'
 };
 
@@ -12827,15 +12828,16 @@ var keepaliveAgent = new Agent({
  * Public Function definitions
  **********************************/
 function pushX() {
-    var _pubnubClientWrapper = pubnubClientWrapper();
-    return {
-        "connect": _connect.bind(this, _pubnubClientWrapper),
-        "cleanup": _cleanup.bind(this, _pubnubClientWrapper),
-        "grantByUserOrgId": grantByUserOrgId.bind(this),
-        "grantByAccountId": grantByAccountId.bind(this),
-        "grantByAccountIdOnExtUserId": grantByAccountIdOnExtUserId.bind(this),
-        "getPushedEvents": getPushedEvents.bind(this)
-    };
+  var _pubnubClientWrapper = pubnubClientWrapper();
+  return {
+    "connect": _connect.bind(this, _pubnubClientWrapper),
+    "cleanup": _cleanup.bind(this, _pubnubClientWrapper),
+    "grantByUserOrgId": grantByUserOrgId.bind(this),
+    "grantByAccountId": grantByAccountId.bind(this),
+    "grantByAccountIdOnExtUserId": grantByAccountIdOnExtUserId.bind(this),
+    "grantV2": grantV2.bind(this),
+    "getPushedEvents": getPushedEvents.bind(this)
+  };
 }
 
 /*********************************
@@ -12843,146 +12845,146 @@ function pushX() {
  **********************************/
 
 function _connect(pubnubCW, options) {
-    var bpubnubV7 = true; // If pubnub v7 or higher in package.json, set it true
-    if (bpubnubV7 && !options.userid) {
-        var err = {};
-        err.message = err.description = 'Mandatory parameter userid not found in request options.';
-        err = new DLSError(helpers.errors.ERROR_TYPES.PUSHX_ERROR, err);
-        throw err;
-    }
-
-    // Adding SSL flag
-    return pubnubCW.setup({
-      'userid': options.userid,
-      'accountid': options.accountid,
-      'pubnub': {
-        'publishKey': options.publishKey,
-        'subscribeKey': options.subscribeKey,
-        'authKey': options.authKey,
-        'ssl': true
-      }
-    });
+  var bpubnubV7 = true; // If pubnub v7 or higher in package.json, set it true
+  if (bpubnubV7 && !options.userid) {
+    var err = {};
+    err.message = err.description = 'Mandatory parameter userid not found in request options.';
+    err = new DLSError(helpers.errors.ERROR_TYPES.PUSHX_ERROR, err);
+    throw err;
+  }
+
+  // Adding SSL flag
+  return pubnubCW.setup({
+    'userid': options.userid,
+    'accountid': options.accountid,
+    'token': options.token,
+    'pubnub': {
+      'publishKey': options.publishKey,
+      'subscribeKey': options.subscribeKey,
+      'ssl': true
+    }
+  });
 }
 
 function _cleanup(pubnubCW) { pubnubCW.cleanup(); }
 
 /*options = {
-  authKey: <authKey>
+  orgId: <orgId>, userId: <userId>
 }*/
 function grantByUserOrgId(options) {
-    var self = this;
-    var dfd = q.defer();  // Initializing promise
-    // Validations
-    var err = helpers.validations.isAuthenticated(self.orgId, self.token);
-    if(err) { dfd.reject(err); }
-    else {
-        // Passed all validations, Construct API url
-        var url = self.config.DEFAULT_HOSTS.PUSHX + self.config.PUSHX_API_URLS.grantByUserOrgId;
-        url = helpers.api.constructAPIUrl(url, { orgId: self.orgId });
-        // Setup request with URL and Params
-        var requestAPI = request.post(url)
-                         .set('Content-Type', 'application/json')
-                         .set('Accept', 'application/json');
-
-        var body = {};
-        if(options.authKey) { body.authKey = options.authKey; }
-
-        requestAPI.send(body);
-
-        //Setup token in Authorization header
-        requestAPI = helpers.api.setupAPIToken(requestAPI, self.token);
-        if(self.traceid) { requestAPI.set('X-Amzn-Trace-Id', self.traceid); }
-
-        // Call Change Password Api
-        requestAPI.end(function(err, response) {
-            if(err) {
-                err = new DLSError(helpers.errors.ERROR_TYPES.API_ERROR, err);
-                dfd.reject(err);
-            }
-            else { dfd.resolve(response.body); }
-        });
-    }
-    return dfd.promise;
+  var dfd = q.defer();  // Initializing promise
+  var allowedChannels = ['jobs', 'systemevents'];
+  var baseChannelName = "o-" + options.orgId + "\\$u-" + options.userId + "\\$";
+  var patterns = [];
+  for(var i in allowedChannels) {
+    var channelName = baseChannelName + allowedChannels[i] + "\\..*";
+    patterns.push(channelName);
+  }
+  options.channels = {};
+  options.channels.patterns = patterns;
+  grantV2.call(this, options)
+  .then(function (res) {
+    dfd.resolve(res);
+  })
+  .catch(function(err) {
+    dfd.reject(err);
+  });
+  return dfd.promise;
 }
 
 /*options = {
     accountId: <accountid>,
-    refId: <extRefId>,
-    authKey: <authKey>
+    refId: <extRefId>
 }*/
 function grantByAccountId(options) {
-	var self = this, err ={};
-    var dfd = q.defer();  // Initializing promise
-
-    if(options.accountId && options.refId) {
-        // Passed all validations, Construct API url
-        var url = self.config.DEFAULT_HOSTS.PUSHX + self.config.PUSHX_API_URLS.grantByAccountId;
-        url = helpers.api.constructAPIUrl(url, { accountId: options.accountId });
-        // Setup request with URL and Params
-        var requestAPI = request.post(url)
-                         .set('Content-Type', 'application/json')
-                         .set('Accept', 'application/json');
-        if(self.traceid) { requestAPI.set('X-Amzn-Trace-Id', self.traceid); }
-
-        var body = { refId: options.refId };
-        if(options.authKey) { body.authKey = options.authKey; }
+	var err ={};
+  var dfd = q.defer();  // Initializing promise
 
-        requestAPI.send(body);
-        requestAPI.end(function(err, response) {
-            if(err) {
-                err = new DLSError(helpers.errors.ERROR_TYPES.API_ERROR, err);
-                dfd.reject(err);
-            }
-            else { dfd.resolve(response.body); }
-        });
-    }
-    else {
-        err.message = err.description = "Required parameter ['accountId', 'refId'] " +
-                                        "not found in request options";
-        err = new DLSError(helpers.errors.ERROR_TYPES.SDK_ERROR, err);
-        dfd.reject(err);
-    }
-    return dfd.promise;
+  if(options.accountId && options.refId) {
+    var channel = "a-" + options.accountId + "$refid." + options.refId;
+    var exactMatch = [channel];
+    options.channels = {};
+    options.channels.exactMatch = exactMatch;
+    grantV2.call(this, options)
+    .then(function (res) {
+      dfd.resolve(res);
+    })
+    .catch(function(err) {
+      dfd.reject(err);
+    });
+  }
+  else {
+    err.message = err.description = "Required parameter ['accountId', 'refId'] " +
+                                    "not found in request options";
+    err = new DLSError(helpers.errors.ERROR_TYPES.SDK_ERROR, err);
+    dfd.reject(err);
+  }
+  return dfd.promise;
 }
 
 /*options = {
     accountId: <accountid>,
     extUserId: <extUserId>, //mandatory
-    authKey: <authKey>
 }*/
 function grantByAccountIdOnExtUserId(options) {
-	var self = this, err ={};
-    var dfd = q.defer();  // Initializing promise
+	var err ={};
+  var dfd = q.defer();  // Initializing promise
 
-    if(options.accountId && options.extUserId) {
-        // Passed all validations, Construct API url
-        var url = self.config.DEFAULT_HOSTS.PUSHX + self.config.PUSHX_API_URLS.grantByAccountId;
-        url = helpers.api.constructAPIUrl(url, { accountId: options.accountId });
-        // Setup request with URL and Params
-        var requestAPI = request.post(url)
-                         .set('Content-Type', 'application/json')
-                         .set('Accept', 'application/json');
-        if(self.traceid) { requestAPI.set('X-Amzn-Trace-Id', self.traceid); }
+  if(options.accountId && options.extUserId) {
+    var channel = "a-" + options.accountId + "$u-" + options.extUserId;
+    var exactMatch = [channel];
+    options.channels = {};
+    options.channels.exactMatch = exactMatch;
+    grantV2.call(this, options)
+    .then(function (res) {
+      dfd.resolve(res);
+    })
+    .catch(function(err) {
+      dfd.reject(err);
+    });
+  }
+  else {
+    err.message = err.description = "Required parameter ['accountId', 'extUserId'] " +
+                                    "not found in request options";
+    err = new DLSError(helpers.errors.ERROR_TYPES.SDK_ERROR, err);
+    dfd.reject(err);
+  }
+  return dfd.promise;
+}
 
-        var body = { extUserId: options.extUserId };
-        if(options.authKey) { body.authKey = options.authKey; }
+/**
+ * This function provides grant token on given channels
+ * @param { channels: { exactMatch: [], patterns: [] } } options 
+ * @returns { token, publishKey, subscribeKey }
+ */
+function grantV2(options) {
+  var self = this, err = {};
+  var dfd = q.defer();
+  var body = { channels: {} };
+  if(!options.channels) {
+    err.message = err.description = "channels not given in input body.";
+    err = new DLSError(helpers.errors.ERROR_TYPES.SDK_ERROR, err);
+    dfd.reject(err);
+    return dfd.promise;
+  }
+  body.channels = options.channels;
+  // Passed all validations, Construct API url
+  var url = self.config.DEFAULT_HOSTS.PUSHX + self.config.PUSHX_API_URLS.grantV2;
+  // Setup request with URL and Params
+  var requestAPI = request.post(url)
+                    .set('Content-Type', 'application/json')
+                    .set('Accept', 'application/json');
+  if(self.traceid) { requestAPI.set('X-Amzn-Trace-Id', self.traceid); }
 
-        requestAPI.send(body);
-        requestAPI.end(function(err, response) {
-            if(err) {
-                err = new DLSError(helpers.errors.ERROR_TYPES.API_ERROR, err);
-                dfd.reject(err);
-            }
-            else { dfd.resolve(response.body); }
-        });
-    }
-    else {
-        err.message = err.description = "Required parameter ['accountId', 'extUserId'] " +
-                                        "not found in request options";
-        err = new DLSError(helpers.errors.ERROR_TYPES.SDK_ERROR, err);
-        dfd.reject(err);
+  requestAPI.send(body);
+  requestAPI.end(function(err, response) {
+    if(err) {
+      err = new DLSError(helpers.errors.ERROR_TYPES.API_ERROR, err);
+      dfd.reject(err);
     }
-    return dfd.promise;
+    else { dfd.resolve(response.body); }
+  });
+  return dfd.promise;
 }
 
 /**
@@ -13139,8 +13141,10 @@ module.exports = function () {
                 break;
             case "PNAccessDeniedCategory":
                 if(status.operation === "PNSubscribeOperation") {
+                    var errorText = status.errorData.response && status.errorData.response.text;
+                    var errorJSON = errorText ? JSON.parse(errorText) : undefined;
                     var errorData = {
-                        payload: JSON.parse(status.errorData.response.text).payload,
+                        payload: errorJSON && errorJSON.payload || status.errorData.payload,
                         message: 'Forbidden: Subscription failed.',
                         errorDetails: {
                             operation: status.operation,
@@ -13242,10 +13246,12 @@ module.exports = function () {
     var __setup = function (userOptions) {
         var pubnubConfig = userOptions.pubnub;
         pubnubConfig.uuid = userOptions.userid;
-        accountId = userOptions.accountid
+        var accountId = userOptions.accountid;
+        var token = userOptions.token;
 
         if (!_pubnubClient && pubnubConfig) {
             _pubnubClient = new pubNub(pubnubConfig); //Connect with PubNub SDK
+            _pubnubClient.setToken(token);
             processSetup();
         } else {
             return new Error('Already Initialized');