comprodls-sdk 2.86.2-valky → 2.89.0

package/dist/comprodls-sdk.js

@@ -207,18 +207,6 @@ exports.REALM_HOSTS = {
       ANALYTICS: 'http://dls-asgard-thor-1453383019.us-west-2.elb.amazonaws.com/lb-analytics',
       INTEGRATION: 'http://dls-asgard-thor-1453383019.us-west-2.elb.amazonaws.com/lb-integrations',
       DRIVE: 'http://dls-asgard-thor-1453383019.us-west-2.elb.amazonaws.com/lb-drive'
-    },
-    VALKY: {
-      PUB: 'http://internal-dls-asgard-valky-1830585247.us-west-2.elb.amazonaws.com/lb-pub',
-      AUTH: 'http://internal-dls-asgard-valky-1830585247.us-west-2.elb.amazonaws.com/lb-auth',
-      AUTHEXTN: 'http://internal-dls-asgard-valky-1830585247.us-west-2.elb.amazonaws.com/lb-authextn',
-      PUSHX: 'http://internal-dls-asgard-valky-1830585247.us-west-2.elb.amazonaws.com/lb-pushx',
-      XAPI: 'http://internal-dls-asgard-valky-1830585247.us-west-2.elb.amazonaws.com/lb-xapi',
-      ATTEMPTS: 'http://internal-dls-asgard-valky-1830585247.us-west-2.elb.amazonaws.com/lb-attempts',
-      PRODUCT: 'http://internal-dls-asgard-valky-1830585247.us-west-2.elb.amazonaws.com/lb-product',
-      ANALYTICS: 'http://internal-dls-asgard-valky-1830585247.us-west-2.elb.amazonaws.com/lb-analytics',
-      INTEGRATION: 'http://internal-dls-asgard-valky-1830585247.us-west-2.elb.amazonaws.com/lb-integrations',
-      DRIVE: 'http://internal-dls-asgard-valky-1830585247.us-west-2.elb.amazonaws.com/lb-drive'
     }
   },
   CUP: {
@@ -935,9 +923,7 @@ function validateGenericAPICaller(apiName, method, url, params) {
 var ERROR_TYPES = {
     "API_ERROR": "API_ERROR",
     "SDK_ERROR": "SDK_ERROR",
-    "CHANNEL_SUBSCRIPTION": "CHANNEL_SUBSCRIPTION",
-    "UNEXPECTED_ERROR": "UNEXPECTED_ERROR",
-    "POLLING_INITIATION": "POLLING_INITIATION"
+    "CHANNEL_SUBSCRIPTION": "CHANNEL_SUBSCRIPTION"
 };
 
 var ERROR_CATEGORY = {
@@ -13006,7 +12992,10 @@ function _connect(pubnubCW, options) {
       'subscribeKey': options.subscribeKey,
       'ssl': true,
       'suppressLeaveEvents': true
-    }
+    },
+    'pollingEndpoint': options.pollingEndpoint,
+    'pollingIterations': options.pollingIterations || 10, // Default polling iterations is 10
+    'pollingInterval': options.pollingInterval, // Default polling interval is exponential backoff
   });
 }
 
@@ -13178,6 +13167,7 @@ function getPushedEvents(options) {
 
 },{"../../helpers":3,"./pubnubClientWrapper":26,"agentkeepalive":36,"q":42,"superagent":45}],26:[function(require,module,exports){
 var pubNub = require("pubnub");
+var request = require('superagent');
 var EventEmitter = require("events").EventEmitter;
 var helpers = require('../../helpers');
 
@@ -13200,6 +13190,13 @@ module.exports = function () {
     var _globalSubscription = [];
     var _globalSubscriptionStatus = {};
     var bStatusSubscribed = false;
+    /** ID of the setTimeout - used for Polling events when PubNub fails */
+    var _setTimeoutIDForPolling;
+    /** Timestamp from when the events need to be fetched */
+    var _startTimestampForPolling;
+    /** Counter for polling */
+    var _pollingCounter;
+    var bPollingInitiated = false;
 
     /** ###### END OF MODULE GLOBALS */
 
@@ -13215,6 +13212,9 @@ module.exports = function () {
         //Returning the adaptor (Plain Javascript object)
         return {
             "on": function (channelObj, handler) {
+                // If PubNub fails, we will fetch the events from this timestamp
+                _startTimestampForPolling = Date.now();
+
                 var pubNubChannel;
                 var channelContext = [];
 
@@ -13243,6 +13243,9 @@ module.exports = function () {
                     _eventEmitter.on(channelObj.channel, handler);
                     bStatusSubscribed = true;
                 }
+
+                // Clean up the old events
+                _checkOldBubbledEvents();
             },
             "getMySubscriptionStatus": __getMySubscriptionStatus
         };
@@ -13256,6 +13259,10 @@ module.exports = function () {
 
     var _translatePubnubStatus = function(status, options) {
         var channels = [], error, successObj;
+
+        // If polling has been initiated, ignore all punnub status
+        if (bPollingInitiated) return;
+
         switch (status.category) {
             case "PNConnectedCategory":
                 if(status.operation === "PNSubscribeOperation") {
@@ -13317,11 +13324,10 @@ module.exports = function () {
                 break;
             case "PNNetworkIssuesCategory":
                 if(status.operation === 'PNSubscribeOperation') {
-                    if(!options.accountId) {
+                    if(!options.accountId || !_userOptions.pollingEndpoint) {
                         error = {
-                            message: "Missing mandatory parameters to initiate polling operation - accountId",
-                            status: status.statusCode,
-                            type: helpers.errors.ERROR_TYPES.POLLING_INITIATION,
+                            message: "Polling initiation error: Missing mandatory parameters to initiate polling operation - [accountId, pollingEndpoint]",
+                            status: status.statusCode
                         };
                         error = new PUSHXError(helpers.errors.ERROR_CATEGORY.PUSHX, error);
                         _eventEmitter.emit('pushx_status', error);
@@ -13335,6 +13341,9 @@ module.exports = function () {
                          * The wrapper supports multiple channels, but the APP currently uses a single channel only.
                          * Polling will also limited to a single channel.
                          */
+                        _pollingCounter = 0;
+                        _pollForEvents();
+                        bPollingInitiated = true;
                     }
                 }
                 else {
@@ -13347,9 +13356,8 @@ module.exports = function () {
             default:
                 // Emit error for other status-category received from pubnub
                 error = {
-                    message: "PushX Error",
+                    message: "PushX Error: unexpected error",
                     status: status.statusCode,
-                    type: helpers.errors.ERROR_TYPES.UNEXPECTED_ERROR,
                     pushXError: status
                 };
                 error = new PUSHXError(helpers.errors.ERROR_CATEGORY.PUSHX, error);
@@ -13386,6 +13394,7 @@ module.exports = function () {
      * @returns PROMISE.
      */
     var __setup = function (userOptions) {
+
         var pubnubConfig = userOptions.pubnub;
         pubnubConfig.uuid = userOptions.userid;
         var accountId = userOptions.accountid;
@@ -13424,8 +13433,169 @@ module.exports = function () {
             _globalSubscription = [];
             bStatusSubscribed = false;
             _globalSubscriptionStatus = {};
+            bPollingInitiated = false;
         }
         _pubnubClient = undefined;
+
+        // Clear the Polling
+        if (_setTimeoutIDForPolling) {
+            clearTimeout(_setTimeoutIDForPolling);
+            // Setting the start time to now to clear the old events
+            _startTimestampForPolling = Date.now();
+            _checkOldBubbledEvents();
+            _setTimeoutIDForPolling = undefined;
+            _pollingCounter = undefined;
+            _startTimestampForPolling = undefined;
+        }
+    };
+
+    /**
+     * Polling function
+     */
+    var _pollForEvents = function () {
+        // Setup request params
+        var params = {
+            accountid: _userOptions.accountid,
+            channelname: _globalSubscription[0],
+            starttime: _startTimestampForPolling,
+            endtime: Date.now()
+        };
+
+        // Safe check to avoid poll for events if the channel name or start time is not set
+        // This handles an edge condition where the clearTimeout doesn't work as expected
+        if (!params.channelname || !params.starttime) {
+            return;
+        }
+
+        var requestAPI = request.get(_userOptions.pollingEndpoint).query(params);
+    
+        requestAPI
+            .end(function(error, response) {
+                
+                if (!error) {
+                    // Bubble the connected status
+                    if (_pollingCounter === 0) {
+                        // Set the status of the channel to subscribed
+                        if(_globalSubscriptionStatus[_globalSubscription[0]]) {
+                            _globalSubscriptionStatus[_globalSubscription[0]].status = 'subscribed';
+                        }
+
+                        var successObj = {
+                            category: 'PUSHX',
+                            type: 'CHANNEL_SUBSCRIPTION',
+                            status: 'SUCCESS',
+                            message: 'Success: Subscribed successfully.',
+                            httpcode: 200,
+                            data: {
+                                payload: {
+                                    channels: _globalSubscription
+                                },
+                                message: 'Success: Subscribed successfully.'
+                            }
+                        };
+                        _eventEmitter.emit('pushx_status', successObj);
+                    }
+
+                    // Bubble the received events
+                    _bubblePolledEvents(response.body);
+
+                    // Increase the counter
+                    _pollingCounter++;
+                }
+
+                // Polling will be done only for specific number of times
+                if (_pollingCounter > _userOptions.pollingIterations) {
+                    var error = {
+                        message: "Polling error: Polling limit exceeded",
+                        status: 429
+                    };
+                    error = new PUSHXError(helpers.errors.ERROR_CATEGORY.PUSHX, error);
+                    _eventEmitter.emit('pushx_status', error);
+                } else {
+                    var timeoutDelay;
+
+                    // If the polling interval is provided, use that
+                    if (_userOptions.pollingInterval) {
+                        timeoutDelay = _userOptions.pollingInterval * 60 * 1000;
+                    } else {
+                        // Else, use exponential backoff
+                        timeoutDelay = parseInt(Math.pow(1.3, _pollingCounter) * 10 * 1000, 10);
+                    }
+
+                    // Set timeout for next poll
+                    if (timeoutDelay) {
+                        _setTimeoutIDForPolling = setTimeout(_pollForEvents, timeoutDelay);
+                    }
+                }
+        });
+    };
+
+    /**
+     * Bubble the polled events to the FE APP
+     * @param {*} events - Events recieved from the polling endpoint 
+     */
+    var _bubblePolledEvents = function (events) {
+        // Load the old events from the session storage
+        var oldEventData = _checkOldBubbledEvents();
+
+        var oldEvents = oldEventData.events;
+        var sessionStorageKey = oldEventData.key;
+
+        for (var i = 0; i < events.entities.length; i++) {
+            var event = events.entities[i];
+            var eventId = event.pk + '_' + event.sk;
+
+            // Check if the event is already emitted
+            if (!oldEvents[eventId]) {
+                oldEvents[eventId] = event.context.start_time;
+
+                // Emit the event
+                _eventEmitter.emit(_globalSubscription[0], event);
+            }
+        }
+
+        // Save the bubbled events to session storage
+        sessionStorage.setItem(sessionStorageKey, JSON.stringify(oldEvents));
+    };
+
+    /**
+     * Check the old bubbled events and remove the events that are older than the start timestamp
+     * @returns {object} - Object containing the key and the events
+     */
+    var _checkOldBubbledEvents = function () {
+        var sessionStorageKey = 'comprodls.old_pushx_events.' + _userOptions.userid + '.' + _globalSubscription[0];
+        var oldEvents = sessionStorage.getItem(sessionStorageKey);
+
+        if (oldEvents) {
+            try {
+                oldEvents = JSON.parse(oldEvents);
+            } catch (e) {
+                oldEvents = {};
+            }
+
+            var oldEventIds = Object.keys(oldEvents);
+
+            // Remove the events that are older than the start timestamp
+            for (var i = 0; i < oldEventIds.length; i++) {
+                var oldEventId = oldEventIds[i];
+
+                if (oldEvents[oldEventId] < _startTimestampForPolling) {
+                    delete oldEvents[oldEventId];
+                }
+            }
+
+            // If the number of events has changed, save the events
+            if (oldEventIds.length !== Object.keys(oldEvents).length) {
+                sessionStorage.setItem(sessionStorageKey, JSON.stringify(oldEvents));
+            }
+        } else {
+            oldEvents = {};
+        }
+
+        return {
+            key: sessionStorageKey,
+            events: oldEvents
+        };
     };
 
     return { // Return public methods for the wrapper
@@ -13435,7 +13605,7 @@ module.exports = function () {
 
 }; //End of Client Wrapper module
 
-},{"../../helpers":3,"events":38,"pubnub":41}],27:[function(require,module,exports){
+},{"../../helpers":3,"events":38,"pubnub":41,"superagent":45}],27:[function(require,module,exports){
 /*************************************************************************
  *
  * COMPRO CONFIDENTIAL