comprodls-sdk 2.90.3-development → 2.91.0-thor

package/lib/services/pushX/pubnubClientWrapper.js

@@ -1,5 +1,6 @@
-var pubNub = require("pubnub");
-var EventEmitter = require("events").EventEmitter;
+var pubNub = require('pubnub');
+var request = require('superagent');
+var EventEmitter = require('events').EventEmitter;
 var helpers = require('../../helpers');
 
 var PUSHXError = helpers.errors.PUSHXError;
@@ -12,200 +13,426 @@ var CHANNEL_DELIMITER = '$';
  * implementation details - allowing future switch (to a different Saas provider).
  */
 module.exports = function () {
-    "use strict";
+  'use strict';
 
-    /** ====== MODULE GLOBALS */
-    var _pubnubClient; //SAAS provider client SDK (PubNub).
-    var _eventEmitter = new EventEmitter();
-    var _userOptions;
-    var _globalSubscription = [];
-    var _globalSubscriptionStatus = {};
-    var bStatusSubscribed = false;
+  /** ====== MODULE GLOBALS */
+  var _pubnubClient; //SAAS provider client SDK (PubNub).
+  var _eventEmitter = new EventEmitter();
+  var _userOptions;
+  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 */
+  /** ###### END OF MODULE GLOBALS */
 
-    /** ====== UTILITY FUNCTIONS */
+  /** ====== UTILITY FUNCTIONS */
 
 
-    /**
-    * Call this function to make a new client adaptor.
-      This adapter exposes functions to send message, update user state etc.
-    * @return (object) : client adapter.
-    */
-    var _constructClientAdaptor = function () {
-        //Returning the adaptor (Plain Javascript object)
-        return {
-            "on": function (channelObj, handler) {
-                var pubNubChannel;
-                var channelContext = [];
-
-                if((channelObj.orgid || channelObj.userid) || channelObj.accountid ||
-                    channelObj.productid || channelObj.classid)
-                {
-                  if(channelObj.accountid) { channelContext.push('a-' + channelObj.accountid); }
-                  else {
-                    if(channelObj.orgid) { channelContext.push('o-' + channelObj.orgid); }
-                    if(channelObj.userid) { channelContext.push('u-' + channelObj.userid); }
-                    if(channelObj.productid) { channelContext.push('p-' + channelObj.productid); }
-                    if(channelObj.classid) { channelContext.push('c-' + channelObj.classid); }
-                  }
-                  pubNubChannel = channelContext.join(CHANNEL_DELIMITER) + CHANNEL_DELIMITER +
-                                  channelObj.channel;
-                  if(!_globalSubscription.includes(pubNubChannel)) {
-                    _globalSubscription.push(pubNubChannel);
-                    _globalSubscriptionStatus[pubNubChannel] = {
-                        status: 'pending'
-                    };
-                    _eventEmitter.on(pubNubChannel, handler);
-                    _subscribeToPubNubChannels(pubNubChannel);
-                  }
-                }
-                else if(channelObj.channel === 'pushx_status' && ! bStatusSubscribed) {
-                    _eventEmitter.on(channelObj.channel, handler);
-                    bStatusSubscribed = true;
-                }
-            },
-            "getMySubscriptionStatus": __getMySubscriptionStatus
-        };
-    };
+  /**
+  * Call this function to make a new client adaptor.
+    This adapter exposes functions to send message, update user state etc.
+  * @return (object) : client adapter.
+  */
+  var _constructClientAdaptor = 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 = [];
 
-    var _translatePubnubMessage = function (pubNubEventData) {
-        var subscribedChannel = pubNubEventData.subscribedChannel;
-        var message = pubNubEventData.message;
-        _eventEmitter.emit(subscribedChannel, message);
+          if((channelObj.orgid || channelObj.userid) || channelObj.accountid ||
+            channelObj.productid || channelObj.classid)
+          {
+            if(channelObj.accountid) { channelContext.push('a-' + channelObj.accountid); }
+            else {
+              if(channelObj.orgid) { channelContext.push('o-' + channelObj.orgid); }
+              if(channelObj.userid) { channelContext.push('u-' + channelObj.userid); }
+              if(channelObj.productid) { channelContext.push('p-' + channelObj.productid); }
+              if(channelObj.classid) { channelContext.push('c-' + channelObj.classid); }
+            }
+            pubNubChannel = channelContext.join(CHANNEL_DELIMITER) + CHANNEL_DELIMITER +
+                            channelObj.channel;
+            if(!_globalSubscription.includes(pubNubChannel)) {
+              _globalSubscription.push(pubNubChannel);
+              _globalSubscriptionStatus[pubNubChannel] = {
+                  status: 'pending'
+              };
+              _eventEmitter.on(pubNubChannel, handler);
+              _subscribeToPubNubChannels(pubNubChannel);
+            }
+          }
+          else if(channelObj.channel === 'pushx_status' && ! bStatusSubscribed) {
+            _eventEmitter.on(channelObj.channel, handler);
+            bStatusSubscribed = true;
+          }
+
+          // Clean up the old events
+          _checkOldBubbledEvents();
+      },
+      'getMySubscriptionStatus': __getMySubscriptionStatus
     };
+  };
+
+  var _translatePubnubMessage = function (pubNubEventData) {
+    var subscribedChannel = pubNubEventData.subscribedChannel;
+    var message = pubNubEventData.message;
+    _eventEmitter.emit(subscribedChannel, message);
+  };
+
+  var _translatePubnubStatus = function(status, options) {
+    var channels = [], error, successObj;
 
-    var _translatePubnubStatus = function(status) {
-        var channels = [], error, successObj;
-        switch (status.category) {
-            case "PNConnectedCategory":
-                if(status.operation === "PNSubscribeOperation") {
-                    channels = status.subscribedChannels;
-                    for(var i in channels) {
-                        if(_globalSubscriptionStatus[channels[i]]) {
-                            _globalSubscriptionStatus[channels[i]].status = 'subscribed';
-                        }
-                    }
-                    successObj = {
-                        category: 'PUSHX',
-                        type: 'CHANNEL_SUBSCRIPTION',
-                        status: 'SUCCESS',
-                        message: 'Success: Subscribed successfully.',
-                        httpcode: 200,
-                        data: {
-                            payload: {
-                                channels: status.subscribedChannels
-                            },
-                            message: 'Success: Subscribed successfully.'
-                        }
-                    };
-                    _eventEmitter.emit('pushx_status', successObj);
-                }
-                break;
-            case "PNAccessDeniedCategory":
-                if(status.operation === "PNSubscribeOperation") {
-                    var errorData = {
-                        payload: JSON.parse(status.errorData.response.text).payload,
-                        message: 'Forbidden: Subscription failed.',
-                        errorDetails: {
-                            operation: status.operation,
-                            category: status.category,
-                            statusCode: status.statusCode
-                        }
-                    };
-                    channels = errorData.payload.channels;
-                    for(var j in channels) {
-                        if(_globalSubscriptionStatus[channels[j]]) {
-                            _globalSubscriptionStatus[channels[j]].status = 'error';
-                            _globalSubscriptionStatus[channels[j]].error = error;
-                        }
-                    }
-                    error = new PUSHXError(helpers.errors.ERROR_CATEGORY.PUSHX, errorData);
-                    _eventEmitter.emit('pushx_status', error);
-                }
-                break;
-            case "PNBadRequestCategory":
-            case "PNNetworkDownCategory":
-            case "PNNetworkUpCategory":
-                error = {
-                    message: "PushX Error", status: status.statusCode,
-                    pushXError: status
-                };
-                error = new PUSHXError(helpers.errors.ERROR_CATEGORY.PUSHX, error);
-                _eventEmitter.emit('pushx_status', error);
-                break;
+    // If polling has been initiated, ignore all punnub status
+    if (bPollingInitiated) return;
+
+    switch (status.category) {
+      case 'PNConnectedCategory':
+        if(status.operation === 'PNSubscribeOperation') {
+          channels = status.subscribedChannels;
+          for(var i in channels) {
+            if(_globalSubscriptionStatus[channels[i]]) {
+              _globalSubscriptionStatus[channels[i]].status = 'subscribed';
+            }
+          }
+          successObj = {
+            category: 'PUSHX',
+            type: 'CHANNEL_SUBSCRIPTION',
+            status: 'SUCCESS',
+            message: 'Success: Subscribed successfully.',
+            httpcode: 200,
+            data: {
+              payload: {
+                channels: status.subscribedChannels
+              },
+              message: 'Success: Subscribed successfully.'
+            }
+          };
+          _eventEmitter.emit('pushx_status', successObj);
         }
-    };
+        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: errorJSON && errorJSON.payload || status.errorData.payload,
+            message: 'Forbidden: Subscription failed.',
+            errorDetails: {
+              operation: status.operation,
+              category: status.category,
+              statusCode: status.statusCode
+            }
+          };
+          channels = errorData.payload.channels;
+          for(var j in channels) {
+            if(_globalSubscriptionStatus[channels[j]]) {
+              _globalSubscriptionStatus[channels[j]].status = 'error';
+              _globalSubscriptionStatus[channels[j]].error = error;
+            }
+          }
+          error = new PUSHXError(helpers.errors.ERROR_CATEGORY.PUSHX, errorData);
+          _eventEmitter.emit('pushx_status', error);
+        }
+        break;
+      case 'PNBadRequestCategory':
+      case 'PNNetworkDownCategory':
+      case 'PNNetworkUpCategory':
+        error = {
+          message: 'PushX Error', status: status.statusCode,
+          pushXError: status
+        };
+        error = new PUSHXError(helpers.errors.ERROR_CATEGORY.PUSHX, error);
+        _eventEmitter.emit('pushx_status', error);
+        break;
+      case 'PNNetworkIssuesCategory':
+        if(status.operation === 'PNSubscribeOperation') {
+          if(!options.accountId || !_userOptions.pollingEndpoint) {
+            error = {
+              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);
+            break;
+          }
+          else {
+            /**
+             * Handle network issue category status for 'subscription' opreration
+             * Start the events polling here.
+             *
+             * 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 {
+          // Handle network issue category status for other operations like 'unsubscription'
+        }
+        break;
+      case 'PNReconnectedCategory':
+        // Handle reconnected category status.
+        break;
+      default:
+        // Emit error for other status-category received from pubnub
+        error = {
+          message: 'PushX Error: unexpected error',
+          status: status.statusCode,
+          pushXError: status
+        };
+        error = new PUSHXError(helpers.errors.ERROR_CATEGORY.PUSHX, error);
+        _eventEmitter.emit('pushx_status', error);
+        break;
+    }
+  };
 
-    var __getMySubscriptionStatus = function() {
-        return JSON.parse(JSON.stringify(_globalSubscriptionStatus));
-    };
+  var __getMySubscriptionStatus = function() {
+    return JSON.parse(JSON.stringify(_globalSubscriptionStatus));
+  };
+
+  /**
+   * Sets up necessary subscriptions (Pub/Sub) to PUSH channels. To a large extent, subscriptions are
+   * driven the student's (instructor's) roster.
+   * @param {object} groups - Roster information, provided during initialization, wrapper.setup().
+   */
+  var _subscribeToPubNubChannels = function (channel) {
+    _pubnubClient.subscribe({ // Calling Pubnub SDK
+      'channels': [channel]
+    });
+  };
+
+  /** ###### END OF UTILITY FUNCTIONS ############ */
+
+  /** ====== Client Wrapper Member functions ==> Mapped to Public Methods */
+
+  /**
+   * Initializes the library, and established a connection with the Saas/PUSH provider.
+   * Setup should be called only once i.e. ONE CONNECTION (on a page/tab) is allowed
+   * at a time. If called again, it will throw an error (failure callback).
+   *
+   * @param {object} userOptions - User auth key and pubnub credentials
+   * @returns PROMISE.
+   */
+  var __setup = function (userOptions) {
+
+    var pubnubConfig = userOptions.pubnub;
+    pubnubConfig.uuid = userOptions.userid;
+    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');
+    }
 
     /**
-     * Sets up necessary subscriptions (Pub/Sub) to PUSH channels. To a large extent, subscriptions are
-     * driven the student's (instructor's) roster.
-     * @param {object} groups - Roster information, provided during initialization, wrapper.setup().
+     * SYNC Function
      */
-    var _subscribeToPubNubChannels = function (channel) {
-        _pubnubClient.subscribe({ // Calling Pubnub SDK
-            "channels": [channel]
-        });
+    function processSetup() {
+      _userOptions = userOptions;
+      _pubnubClient.addListener({ //Setup Listeners (events will shows up after subscription)
+        'message': function (data) {
+          _translatePubnubMessage(data);
+        },
+        'status': function (status) {
+          var statusOptions = { accountId: accountId };
+          _translatePubnubStatus(status, statusOptions);
+        }
+      });
+    }
+    return _constructClientAdaptor();
+  }; //End of _setup()
+
+  var __cleanup = function () {
+    if (_pubnubClient) { //Skip cleanup if setup() was not called.
+      _pubnubClient.unsubscribeAll();
+      _pubnubClient.stop();
+      _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()
     };
 
-    /** ###### END OF UTILITY FUNCTIONS ############ */
+    // 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;
+    }
 
-    /** ====== Client Wrapper Member functions ==> Mapped to Public Methods */
+    var requestAPI = request.get(_userOptions.pollingEndpoint).query(params);
 
-    /**
-     * Initializes the library, and established a connection with the Saas/PUSH provider.
-     * Setup should be called only once i.e. ONE CONNECTION (on a page/tab) is allowed
-     * at a time. If called again, it will throw an error (failure callback).
-     *
-     * @param {object} userOptions - User auth key and pubnub credentials
-     * @returns PROMISE.
-     */
-    var __setup = function (userOptions) {
-        var pubnubConfig = userOptions.pubnub;
-        pubnubConfig.uuid = userOptions.userid;
+    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++;
+      }
 
-        if (!_pubnubClient && pubnubConfig) {
-            _pubnubClient = new pubNub(pubnubConfig); //Connect with PubNub SDK
-            processSetup();
+      // 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 {
-            return new Error('Already Initialized');
+            // Else, use exponential backoff
+            timeoutDelay = parseInt(Math.pow(1.3, _pollingCounter) * 10 * 1000, 10);
         }
 
-        /**
-         * SYNC Function
-         */
-        function processSetup() {
-            _userOptions = userOptions;
-            _pubnubClient.addListener({ //Setup Listeners (events will shows up after subscription)
-                "message": function (data) {
-                    _translatePubnubMessage(data);
-                },
-                "status": function (status) {
-                    _translatePubnubStatus(status);
-                }
-            });
+        // Set timeout for next poll
+        if (timeoutDelay) {
+            _setTimeoutIDForPolling = setTimeout(_pollForEvents, timeoutDelay);
         }
-        return _constructClientAdaptor();
-    }; //End of _setup()
-
-    var __cleanup = function () {
-        if (_pubnubClient) { //Skip cleanup if setup() was not called.
-            _pubnubClient.unsubscribeAll();
-            _pubnubClient.stop();
-            _globalSubscription = [];
-            bStatusSubscribed = false;
-            _globalSubscriptionStatus = {};
+      }
+    });
+  };
+
+  /**
+   * 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 = {};
         }
-        _pubnubClient = undefined;
-    };
 
-    return { // Return public methods for the wrapper
-        "setup": __setup,
-        "cleanup": __cleanup
+        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
+    'setup': __setup,
+    'cleanup': __cleanup
+  };
 
 }; //End of Client Wrapper module