quickblox 2.13.10 → 2.14.0

package/README.md

@@ -16,7 +16,7 @@ Check out our [API Reference](https://quickblox.github.io/quickblox-javascript-s
 ## Dependencies for browser
 
 ```html
-<script src="https://unpkg.com/quickblox@2.13.9/quickblox.min.js"></script>
+<script src="https://unpkg.com/quickblox@2.14.0/quickblox.min.js"></script>
 ```
 
 ## Bower and RequireJS
@@ -40,10 +40,10 @@ npm install quickblox --save
 And you're ready to go:
 
 ```javascript
-var QB = require('quickblox');
+var QB = require("quickblox");
 
 // OR to create many QB instances
-var QuickBlox = require('quickblox').QuickBlox;
+var QuickBlox = require("quickblox").QuickBlox;
 var QB1 = new QuickBlox();
 var QB2 = new QuickBlox();
 ```
@@ -54,9 +54,9 @@ var QB2 = new QuickBlox();
 
 # Browsers support
 
-| Edge   | Firefox | Chrome | Safari | Opera | Node.js |
-|:----:|:-------:|:------:|:------:|:-----:|:-------:|
-| 14+  |  52+    | 50+    |  11.1+  |  36+  |    6+   |
+| Edge | Firefox | Chrome | Safari | Opera | Node.js |
+| :--: | :-----: | :----: | :----: | :---: | :-----: |
+| 14+  |   52+   |  50+   | 11.1+  |  36+  |   6+    |
 
 # Documentation
 
@@ -69,7 +69,9 @@ Please raise questions, requests for help etc. via https://stackoverflow.com/que
 Feedback and suggestions for improvement always welcome :)
 
 # How to contribute
+
 See more information at [contributing.md](https://github.com/QuickBlox/quickblox-javascript-sdk/blob/gh-pages/.github/CONTRIBUTING.md)
 
 # License
+
 Apache 2.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "quickblox",
   "description": "QuickBlox JavaScript SDK",
-  "version": "2.13.10",
+  "version": "2.14.0",
   "homepage": "https://quickblox.com/developers/Javascript",
   "main": "src/qbMain.js",
   "license": "(Apache-2.0)",
@@ -76,6 +76,7 @@
     }
   },
   "scripts": {
+    "dev": "NODE_ENV=develop gulp watch",
     "setDependencies": "npm i && npm i -g gulp-cli && npm install rimraf -g && npm install -g jasmine",
     "lint": "jshint src --reporter=node_modules/jshint-stylish",
     "build": "cross-env NODE_ENV=production npm run lint && gulp build && gulp minify",

package/quickblox.js

@@ -46183,6 +46183,9 @@ function ChatProxy(service) {
     this._isLogout = false;
 
     this._checkConnectionTimer = undefined;
+    // this._checkConnectionPingTimer = undefined; //artan: 13/09/2022 at 16:30
+    this._checkExpiredSessionTimer = undefined;
+    this._sessionHasExpired = false;
     this._pings = {};
     //
     this.helpers = new Helpers();
@@ -46237,6 +46240,7 @@ function ChatProxy(service) {
      * - onLastUserActivityListener (userId, seconds)
      * - onDisconnectedListener
      * - onReconnectListener
+     * - onSessionExpiredListener
      */
 
     /**
@@ -46856,7 +46860,7 @@ ChatProxy.prototype = {
                     case Strophe.Status.AUTHFAIL:
                         self.isConnected = false;
                         self._isConnecting = false;
-                        
+
                         err = Utils.getError(401, 'Status.AUTHFAIL - The authentication attempt failed', 'QBChat');
                         
                         if (isInitialConnect) {
@@ -46864,6 +46868,7 @@ ChatProxy.prototype = {
                         }
                         
                         if(!self.isConnected && typeof self.onReconnectFailedListener === 'function'){
+                            // TODO: investigate problem reconnect field
                             Utils.safeCallbackCall(self.onReconnectFailedListener, err);
                         }
                         
@@ -46884,7 +46889,50 @@ ChatProxy.prototype = {
                         self.connection.XAddTrackedHandler(self._onIQ, null, 'iq');
                         self.connection.XAddTrackedHandler(self._onSystemMessageListener, null, 'message', 'headline');
                         self.connection.XAddTrackedHandler(self._onMessageErrorListener, null, 'message', 'error');
-                    
+
+                        // var noTimerId = typeof self._checkConnectionPingTimer === 'undefined';  //artan: 13/09/2022 at 16:30
+                        // noTimerId = config.pingLocalhostTimeInterval === 0 ? false : noTimerId;
+                        // if (noTimerId) {
+                        //     Utils.QBLog('[QBChat]', 'Init ping to localhost at ', Utils.getCurrentTime());
+                        //     self._checkConnectionPingTimer = setInterval(function() {
+                        //         self._ping(userJid,
+                        //             function(error) {
+                        //                 if (error) {
+                        //                     Utils.QBLog('[QBChat]',
+                        //                         'Local Ping: ',
+                        //                         'failed, at ', Utils.getCurrentTime(),
+                        //                         ' error: ', error);
+                        //                 } else {
+                        //                     Utils.QBLog('[QBChat]',
+                        //                         'Local Ping: ',
+                        //                         'ok, at ', Utils.getCurrentTime());
+                        //                 }
+                        //             });
+                        //     }, config.pingLocalhostTimeInterval * 1000);
+                        // }
+
+                        if (typeof self.onSessionExpiredListener === 'function') {
+                            var noExpiredSessionTimerId = typeof self._checkExpiredSessionTimer === 'undefined';
+                            if (noExpiredSessionTimerId) {
+                                Utils.QBLog('[QBChat]', 'Init timer for check session expired at ', ((new Date()).toTimeString().split(' ')[0]));
+                                self._checkExpiredSessionTimer = setInterval(function() {
+                                    var timeNow = new Date();
+                                    if (typeof config.qbTokenExpirationDate !== 'undefined') {
+                                        var timeLag = Math.round((timeNow.getTime() - config.qbTokenExpirationDate.getTime()) / (1000 * 60));
+                                        //artan 25-08-2022
+                                        // TODO: need to delete in task [CROS-815]
+                                        console.log('timeLag: ', timeLag);
+                                        if (timeLag >= 0) {
+                                            self._sessionHasExpired = true;
+                                            Utils.safeCallbackCall(self.onSessionExpiredListener, null);
+                                        }
+                                    }
+                                    // TODO: in task [CROS-815], may by need to change 5 * 1000 to config.liveSessionInterval * 1000
+                                }, 5 * 1000);
+
+                            }
+                        }
+
                         self._postConnectActions(function(roster) {
                             callback(null, roster);
                         }, isInitialConnect);
@@ -47005,10 +47053,13 @@ ChatProxy.prototype = {
     _postConnectActions: function(callback, isInitialConnect) {
         Utils.QBLog('[QBChat]', 'Status.CONNECTED at ' + chatUtils.getLocalTime());
 
-        var self = this,
-            xmppClient = Utils.getEnv().browser ? self.connection : self.Client,
-            presence = Utils.getEnv().browser ? $pres() : chatUtils.createStanza(XMPP.Stanza, null, 'presence');
-                
+        var self = this;
+        var isBrowser = Utils.getEnv().browser;
+        var xmppClient = isBrowser ? self.connection : self.Client;
+        var presence = isBrowser ?
+            $pres() :
+            chatUtils.createStanza(XMPP.Stanza, null, 'presence');
+
         if (config.streamManagement.enable && config.chatProtocol.active === 2) {
             self.streamManagement.enable(self.connection, null);
             self.streamManagement.sentMessageCallback = self._sentMessageCallback;
@@ -47018,6 +47069,7 @@ ChatProxy.prototype = {
         
         self.isConnected = true;
         self._isConnecting = false;
+        self._sessionHasExpired = false;
 
         self._enableCarbons();
 
@@ -47046,16 +47098,21 @@ ChatProxy.prototype = {
     },
 
     _establishConnection: function(params) {
+        //  TODO: must to call if only qbTokenExpirationDate is not expried
         var self = this;
-        
+        Utils.QBLog('[QBChat]', '_establishConnection called');
         if (self._isLogout || self._checkConnectionTimer) {
+            Utils.QBLog('[QBChat]', '_establishConnection return');
             return;
         }
 
         var _connect = function() {
-            if (!self.isConnected && !self._isConnecting) {
+            Utils.QBLog('[QBChat]', 'call _connect() in _establishConnection ');
+            if (!self.isConnected && !self._isConnecting && !self._sessionHasExpired) {
+                Utils.QBLog('[QBChat]', 'call connect() again in _establishConnection ');
                 self.connect(params);
             } else {
+                Utils.QBLog('[QBChat]', 'stop timer in _establishConnection ');
                 clearInterval(self._checkConnectionTimer);
                 self._checkConnectionTimer = undefined;
             }
@@ -47063,6 +47120,8 @@ ChatProxy.prototype = {
 
         _connect();
 
+
+        // TODO: investigate problem with interval connection
         self._checkConnectionTimer = setInterval(function() {
             _connect();
         }, config.chatReconnectionTimeInterval * 1000);
@@ -47076,6 +47135,7 @@ ChatProxy.prototype = {
      * @returns {String} messageId - The current message id (was generated by SDK)
      * */
     send: function(jid_or_user_id, message) {
+        Utils.QBLog('[QBChat]', 'Call send ' + JSON.stringify(message));
         var self = this,
             builder = Utils.getEnv().browser ? $msg : XMPP.Stanza;
 
@@ -47138,6 +47198,7 @@ ChatProxy.prototype = {
      * @returns {String} messageId - The current message id (was generated by SDK)
      * */
     sendSystemMessage: function(jid_or_user_id, message) {
+        Utils.QBLog('[QBChat]', 'Call sendSystemMessage ' + JSON.stringify(message));
         var self = this,
             builder = Utils.getEnv().browser ? $msg : XMPP.Stanza,
             paramsCreateMsg = {
@@ -47186,6 +47247,7 @@ ChatProxy.prototype = {
      * @param {String | Number} jid_or_user_id - Use opponent id or jid for 1 to 1 chat, and room jid for group chat.
      * */
     sendIsTypingStatus: function(jid_or_user_id) {
+        Utils.QBLog('[QBChat]', 'Call sendIsTypingStatus ');
         var self = this,
             stanzaParams = {
                 from: self.helpers.getUserCurrentJid(),
@@ -47200,10 +47262,12 @@ ChatProxy.prototype = {
             xmlns: chatUtils.MARKERS.STATES
         });
 
-        if(Utils.getEnv().browser){
-            self.connection.send(stanza);
-        } else {
-            self.Client.send(stanza);
+        if (self.connection.connected) {
+            if(Utils.getEnv().browser){
+                self.connection.send(stanza);
+            } else {
+                self.Client.send(stanza);
+            }
         }
     },
 
@@ -47213,6 +47277,7 @@ ChatProxy.prototype = {
      * @param {String | Number} jid_or_user_id - Use opponent id or jid for 1 to 1 chat, and room jid for group chat.
      * */
     sendIsStopTypingStatus: function(jid_or_user_id) {
+        Utils.QBLog('[QBChat]', 'Call sendIsStopTypingStatus ');
         var self = this,
             stanzaParams = {
                 from: self.helpers.getUserCurrentJid(),
@@ -47227,10 +47292,12 @@ ChatProxy.prototype = {
             xmlns: chatUtils.MARKERS.STATES
         });
 
-        if(Utils.getEnv().browser){
-            self.connection.send(stanza);
-        } else {
-            self.Client.send(stanza);
+        if (self.connection.connected) {
+            if(Utils.getEnv().browser){
+                self.connection.send(stanza);
+            } else {
+                self.Client.send(stanza);
+            }
         }
     },
 
@@ -47243,6 +47310,7 @@ ChatProxy.prototype = {
      * @param {Number} params.dialogId - The dialog id
      * */
     sendDeliveredStatus: function(params) {
+        Utils.QBLog('[QBChat]', 'Call sendDeliveredStatus ');
         var self = this,
             stanzaParams = {
                 type: 'chat',
@@ -47279,6 +47347,7 @@ ChatProxy.prototype = {
      * @param {Number} params.dialogId - The dialog id
      * */
     sendReadStatus: function(params) {
+        Utils.QBLog('[QBChat]', 'Call sendReadStatus ' + JSON.stringify(params));
         var self = this,
             stanzaParams = {
                 type: 'chat',
@@ -47312,6 +47381,7 @@ ChatProxy.prototype = {
      * @param {(Number|String)} jid_or_user_id - The user id or jid, that the last activity we want to know
      * */
     getLastUserActivity: function(jid_or_user_id) {
+        Utils.QBLog('[QBChat]', 'Call getLastUserActivity ');
         var iqParams,
             builder,
             iq;
@@ -47338,7 +47408,47 @@ ChatProxy.prototype = {
         }
     },
 
+    _ping: function(jid_or_user_id, callback){
+        var self = this;
+        var id = this.helpers.getUniqueId('ping');
+        var builder = Utils.getEnv().browser ? $iq : XMPP.Stanza;
+        var to;
+        var _callback;
+        var stanza;
+
+        //to = config.endpoints.chat;
+        to = 'http://localhost';
+        _callback = callback;
+
+
+        var iqParams = {
+            from: this.helpers.getUserCurrentJid(),
+            id: id,
+            to: to,
+            type: 'get'
+        };
+        stanza = chatUtils.createStanza(builder, iqParams, 'iq');
+        stanza.c('ping', { xmlns: "urn:xmpp:ping" });
+
+        var noAnswer = function () {
+            _callback('No answer');
+            self._pings[id] = undefined;
+            delete self._pings[id];
+        };
+        if (Utils.getEnv().browser) {
+            this.connection.send(stanza);
+        } else {
+            this.Client.send(stanza);
+        }
+        this._pings[id] = {
+            callback: _callback,
+            interval: setTimeout(noAnswer, config.pingTimeout * 1000)
+        };
+        return id;
+    },
+
     ping: function (jid_or_user_id, callback) {
+        Utils.QBLog('[QBChat]', 'Call ping ');
         var self = this;
         var id = this.helpers.getUniqueId('ping');
         var builder = Utils.getEnv().browser ? $iq : XMPP.Stanza;
@@ -47390,8 +47500,11 @@ ChatProxy.prototype = {
      * @memberof QB.chat
      * */
     disconnect: function() {
+        Utils.QBLog('[QBChat]', 'Call disconnect ');
         clearInterval(this._checkConnectionTimer);
+        clearInterval(this._checkExpiredSessionTimer);
         this._checkConnectionTimer = undefined;
+        this._checkExpiredSessionTimer = undefined;
         this.muc.joinedRooms = {};
         this._isLogout = true;
         this.helpers.setUserCurrentJid('');
@@ -53454,6 +53567,8 @@ function StreamManagement(options) {
     // The client send stanza counter.
     this._clientSentStanzasCounter = null;
 
+    this._intervalId = null;
+    
     this._timeInterval = 2000;
 
     this.sentMessageCallback = null;
@@ -53538,7 +53653,12 @@ StreamManagement.prototype._addEnableHandlers = function () {
         if(tagName === 'enabled'){
             self._isStreamManagementEnabled = true;
 
-            setInterval(self._timeoutCallback.bind(self), self._timeInterval);
+            return true;
+        }
+
+        if (self._isStreamManagementEnabled && tagName === 'message') {
+            clearInterval(self._intervalId);
+            self._intervalId = setInterval(self._timeoutCallback.bind(self), self._timeInterval);
 
             return true;
         }
@@ -53578,17 +53698,22 @@ StreamManagement.prototype.send = function (stanza, message) {
         bodyContent = chatUtils.getElementText(stanzaXML, 'body') || '',
         attachments = chatUtils.getAllElements(stanzaXML, 'attachment') || '';
 
-    self._originalSend.call(self._c, stanza);
-
-    if (tagName === 'message' && (type === 'chat' || type === 'groupchat') && (bodyContent || attachments.length)) {
-        self._sendStanzasRequest({
-            message: message,
-            time: Date.now() + self._timeInterval,
-            expect: self._clientSentStanzasCounter
-        });
+    try {
+        self._originalSend.call(self._c, stanza);
+    } catch (e) {
+        Utils.QBLog('[QBChat]', e.message);
+    } finally {
+        if (tagName === 'message' && (type === 'chat' || type === 'groupchat') && (bodyContent || attachments.length)) {
+            self._sendStanzasRequest({
+                message: message,
+                time: Date.now() + self._timeInterval,
+                expect: self._clientSentStanzasCounter
+            });
+        }
+    
+        self._clientSentStanzasCounter++;
     }
 
-    self._clientSentStanzasCounter++;
 };
 
 StreamManagement.prototype._sendStanzasRequest = function (data) {
@@ -53597,10 +53722,14 @@ StreamManagement.prototype._sendStanzasRequest = function (data) {
     if(self._isStreamManagementEnabled){
         self._stanzasQueue.push(data);
 
-        var stanza = Utils.getEnv().browser ? $build('r', { xmlns: self._NS}) :
-            chatUtils.createStanza(self._nodeBuilder, { xmlns: self._NS}, 'r');
+        var stanza = Utils.getEnv().browser ? $build('r', { xmlns: self._NS }) :
+            chatUtils.createStanza(self._nodeBuilder, { xmlns: self._NS }, 'r');
 
-        self._originalSend.call(self._c, stanza);
+        if (self._c.connected) {
+            self._originalSend.call(self._c, stanza);
+        } else {
+            self._checkCounterOnIncomeStanza();
+        }
     }
 };
 
@@ -53609,13 +53738,15 @@ StreamManagement.prototype.getClientSentStanzasCounter = function(){
 };
 
 StreamManagement.prototype._checkCounterOnIncomeStanza = function (count){
-    if (this._stanzasQueue[0].expect !== count){
-        this.sentMessageCallback(this._stanzasQueue[0].message);
-    } else {
-        this.sentMessageCallback(null, this._stanzasQueue[0].message);
+    if (this._stanzasQueue.length) {
+        if (this._stanzasQueue[0].expect !== count){
+            this.sentMessageCallback(this._stanzasQueue[0].message);
+        } else {
+            this.sentMessageCallback(null, this._stanzasQueue[0].message);
+        }
+    
+        this._stanzasQueue.shift();
     }
-
-    this._stanzasQueue.shift();
 };
 
 StreamManagement.prototype._increaseReceivedStanzasCounter = function(){
@@ -53639,16 +53770,16 @@ module.exports = StreamManagement;
  */
 
 var config = {
-  version: '2.13.10',
-  buildNumber: '1104',
+  version: '2.14.0',
+  buildNumber: '1135',
   creds: {
-    appId: '',
-    authKey: '',
-    authSecret: '',
-    accountKey: ''
+    'appId': 0,
+    'authKey': '',
+    'authSecret': '',
+    'accountKey': ''
   },
   endpoints: {
-    api: 'api.quickblox.com',
+    api: 'apistage6.quickblox.com/',
     chat: 'chat.quickblox.com',
     muc: 'muc.chat.quickblox.com'
   },
@@ -53662,6 +53793,7 @@ var config = {
     active: 2
   },
   pingTimeout: 30,
+  pingLocalhostTimeInterval: 5,
   chatReconnectionTimeInterval: 5,
   webrtc: {
     answerTimeInterval: 60,
@@ -53672,7 +53804,7 @@ var config = {
     statsReportTimeInterval: false,
     iceServers: [
       {
-        urls: 'turn:turn.quickblox.com',
+        urls: ['turn:turn.quickblox.com', 'stun:turn.quickblox.com'],
         username: 'quickblox',
         credential: 'baccb97ba2d92d71e26eb9886da5f1e0'
       }
@@ -53699,10 +53831,12 @@ var config = {
   },
   timeout: null,
   debug: {
-    mode: 0,
+    mode: 1,
     file: null
   },
-  addISOTime: false
+  addISOTime: false,
+  qbTokenExpirationDate: null,
+  liveSessionInterval: 120,
 };
 
 config.set = function(options) {
@@ -53732,6 +53866,25 @@ config.set = function(options) {
   });
 };
 
+/*
+* 17.08.22 artan: waiting for backend fix, look at tasks:
+* [CROS-815] - Update sessionExpirationDate on each request
+* [SR-1322] - Set param Access-Control-Expose-Headerson server side
+ */
+config.updateSessionExpirationDate = function (tokenExpirationDate, headerHasToken = false) {
+  var connectionTimeLag = 1; // minute
+  var newDate = new Date(tokenExpirationDate);
+  newDate.setMinutes ( newDate.getMinutes() - connectionTimeLag);
+  // TODO: need to check in [CROS-815]
+  if (!headerHasToken) {
+    console.log('in date: ', newDate);
+    newDate.setMinutes ( newDate.getMinutes() + config.liveSessionInterval );
+    console.log('out date: ', newDate);
+  }
+  config.qbTokenExpirationDate = newDate;
+  console.log('updateSessionExpirationDate ... Set value: ', tokenExpirationDate);
+};
+
 module.exports = config;
 
 },{}],255:[function(require,module,exports){
@@ -53765,12 +53918,24 @@ QuickBlox.prototype = {
     _getOS: Utils.getOS.bind(Utils),
 
     /**
+     * Init QuickBlox SDK with User Account data for start session with token.
      * @memberof QB
-     * @param {Number | String} appIdOrToken - Application ID (from your admin panel) or Session Token.
-     * @param {String | Number} authKeyOrAppId - Authorization key or Application ID. You need to set up Application ID if you use session token as appIdOrToken parameter.
-     * @param {String} authSecret - Authorization secret key (from your admin panel).
+     * @param {Number} appId - Application ID (from your admin panel).
+     * @param {String | Number} accountKey - Account key (from your admin panel).
      * @param {Object} configMap - Settings object for QuickBlox SDK.
      */
+    initWithAppId: function(appId, accountKey, configMap) {
+        if (typeof appId !== 'number') {
+            throw new Error('Type of appId must be a number');
+        }
+        if (appId === '' || appId === undefined || appId === null ||
+            accountKey === '' || accountKey === undefined || accountKey === null) {
+            throw new Error('Cannot init QuickBlox without app credentials (app ID, auth key)');
+        } else {
+            this.init('', appId, null, accountKey, configMap);
+        }
+    },
+
     init: function(appIdOrToken, authKeyOrAppId, authSecret, accountKey, configMap) {
         if (typeof accountKey === 'string' && accountKey.length) {
             if (configMap && typeof configMap === 'object') {
@@ -53885,6 +54050,37 @@ QuickBlox.prototype = {
         this.auth.getSession(callback);
     },
 
+    /**
+     * Set up user session token to current session and return it
+     * @memberof QB
+     * @param {String} token - a User Session Token
+     * @param {getSessionCallback} callback - The getSessionCallback function.
+     * @callback getSessionCallback
+     * @param {Object} error - The error object
+     * @param {Object} session - Contains of session object
+     * */
+    startSessionWithToken: function(token, callback) {
+        if (token === undefined) throw new Error('Cannot start session with undefined token');
+        else if (token === '') throw new Error('Cannot start session with empty string token');
+        else if (token === null) throw new Error('Cannot start session with null value token');
+        else if (typeof callback !== 'function') throw new Error('Cannot start session without callback function');
+        else {
+            try {
+                this.service.setSession({token: token});
+            } catch (err) {
+                callback(err, null);
+            }
+            if (typeof callback === 'function') {
+                try{
+                    this.auth.getSession(callback);
+                }
+                catch(er){
+                    callback(er, null);
+                }
+            }
+        }
+    },
+
     /**
      * Creat new session. {@link https://quickblox.com/developers/Javascript#Authorization More info}
      * @memberof QB
@@ -54101,6 +54297,15 @@ ServiceProxy.prototype = {
             .then(function(response) {
                 qbResponse = response;
 
+                if (qbRequest.method === 'GET' || qbRequest.method === 'POST'){
+                    // TODO: need to check in [CROS-815]
+                    var qbTokenExpirationDate = qbResponse.headers.get('qb-token-expirationdate');
+                    var headerHasToken  = !(qbTokenExpirationDate === null ||
+                        typeof qbTokenExpirationDate === 'undefined');
+                    qbTokenExpirationDate  = (headerHasToken) ? qbTokenExpirationDate : new Date();
+                    self.qbInst.config.updateSessionExpirationDate(qbTokenExpirationDate, headerHasToken);
+                }
+
                 if (qbDataType === 'text') {
                     return response.text();
                 } else {
@@ -54116,6 +54321,8 @@ ServiceProxy.prototype = {
             }).then(function(body) {
             _requestCallback(null, qbResponse, body);
         }, function(error) {
+                // TODO: review in [CROS-815]
+            console.log('Error: ', error);
             _requestCallback(error);
         });
 
@@ -54413,6 +54620,10 @@ var Utils = {
             '000000'.substr(0, 6 - increment.length) + increment;
     },
 
+    getCurrentTime: function() {
+      return ((new Date()).toTimeString().split(' ')[0]);
+    },
+
     injectISOTimes: function(data) {
         if (data.created_at) {
             if (typeof data.created_at === 'number') data.iso_created_at = new Date(data.created_at * 1000).toISOString();