push - guidelines

Author: Cookiezaurs

plugins/push/api/api.js

@@ -14,6 +14,7 @@ var plugin = {},
     plugins.internalEvents.push('[CLY]_push_action');
     plugins.internalDrillEvents.push('[CLY]_push_action');
 
+    /** function sets up commons */
     function setUpCommons() {
         let creds = require('./parts/credentials.js');
         for (let k in creds.DB_MAP) {
@@ -67,15 +68,15 @@ var plugin = {},
                         }
                         else {
                             pushEvents.forEach(event => {
-                                var msg = msgs.filter(msg => ('' + msg._id) === event.segmentation.i)[0],
+                                var msg = msgs.filter(msg1 => ('' + msg1._id) === event.segmentation.i)[0],
                                     inc = {};
                                 if (msg) {
                                     event.segmentation.a = msg.auto || false;
 
-                                    if (event.key == '[CLY]_push_open') {
+                                    if (event.key === '[CLY]_push_open') {
                                         inc['result.delivered'] = event.count;
                                     }
-                                    else if (event.key == '[CLY]_push_action') {
+                                    else if (event.key === '[CLY]_push_action') {
                                         inc['result.actioned'] = event.count;
                                         if (event.segmentation && event.segmentation.b !== undefined) {
                                             inc['result.actioned|' + event.segmentation.b] = event.count;
@@ -187,7 +188,7 @@ var plugin = {},
                 updateUsersMonth['d.' + params.time.day + '.' + common.dbMap['messaging-enabled']] = 1;
             }
 
-            if (userLastSeenDate.getFullYear() == params.time.yearly &&
+            if (userLastSeenDate.getFullYear() === parseInt(params.time.yearly) &&
                 Math.ceil(common.moment(userLastSeenDate).tz(params.appTimezone).format('DDD') / 7) < params.time.weekly && messagingTokenKeys(dbAppUser).length) {
                 updateUsersZero['d.w' + params.time.weekly + '.' + common.dbMap['messaging-enabled']] = 1;
             }
@@ -230,7 +231,10 @@ var plugin = {},
     plugins.register('/consent/change', ({params, changes}) => {
         push.onConsentChange(params, changes);
     });
-
+    /** collects messaging token keys
+     * @param {object} dbAppUser - data
+     * @returns {array} list of tokens
+     */
     function messagingTokenKeys(dbAppUser) {
         var a = [];
         for (var k in dbAppUser[common.dbUserMap.tokens]) {

plugins/push/api/jobs/clear.js

@@ -4,17 +4,28 @@ const job = require('../../../../api/parts/jobs/job.js'),
     log = require('../../../../api/utils/log.js')('job:push:clear'),
     N = require('../parts/note.js'),
     retry = require('../../../../api/parts/jobs/retry.js');
-
+/** clear job class */
 class ClearJob extends job.Job {
+    /** constructs clear job  
+     * @param {string} name - name
+     * @param {object} data  - data
+     */
     constructor(name, data) {
         super(name, data);
         log.d('Preparing to clear %j', this.data);
     }
 
+    /** function returns NoretryPolicy
+        @returns {object} retrypolicy
+    */
     retryPolicy() {
         return new retry.NoRetryPolicy();
     }
 
+    /** function runs clearing job
+     * @param {object} db - db connection
+     * @param {function} done - callback function, having error as first returned parameter
+     */
     run(db, done) {
         log.d('Clearing %j', this.data);
 
@@ -49,12 +60,12 @@ class ClearJob extends job.Job {
                         done();
                     }
                     else {
-                        db.collection('credentials').remove({_id: db.ObjectID(this.data.cid)}, (err, ok) => {
-                            if (err) {
-                                done(err);
+                        db.collection('credentials').remove({_id: db.ObjectID(this.data.cid)}, (err1, ok1) => {
+                            if (err1) {
+                                done(err1);
                             }
                             else {
-                                log.d('Cleared credentials %j: %j', this.data.cid, ok);
+                                log.d('Cleared credentials %j: %j', this.data.cid, ok1);
                                 done();
                             }
                         });

plugins/push/api/jobs/process.js

@@ -13,8 +13,12 @@ const FORK_WHEN_MORE_THAN = 100000,
     FORK_MAX = 5,
     SEND_AHEAD = 5 * 60000,
     BATCH = 50000;
-
+/** proces jo class */
 class ProcessJob extends J.IPCJob {
+    /** class constructr
+     * @param {string} name - name
+     * @param {object} data - data
+     */
     constructor(name, data) {
         super(name, data);
         if (this.isFork) {
@@ -23,26 +27,46 @@ class ProcessJob extends J.IPCJob {
         log.d('initializing ProcessJob with %j & %j', name, data);
     }
 
+    /** gets cid
+     * @returns {string} cid
+     */
     get cid() {
         return this.data.cid;
     }
 
+    /** gets aid
+     * @returns {string} aid
+     */
     get aid() {
         return this.data.aid;
     }
 
+    /** gets data.field
+     * @returns {object} data.field
+     */
     get field() {
         return this.data.field;
     }
 
+    /** gets platform
+     * @returns {string} data.field.substr(0, 1)
+     */
     get platform() {
         return this.data.field.substr(0, 1);
     }
 
+    /** checks if is fork
+     * @returns {boolean} true - if fork
+     */
     get isFork() {
         return !!this.data.fork;
     }
 
+    /** prepares job
+     * @param {object} manager - manager
+     * @param {object} db - db connection
+     * @returns {Promise} - resolved or rejected
+     */
     prepare(manager, db) {
         log.d('Loading credentials for %j', this.data);
         this.creds = new C.Credentials(this.data.cid);
@@ -77,22 +101,41 @@ class ProcessJob extends J.IPCJob {
         });
     }
 
+    /** gets resource name
+     * @returns {string} name
+     */
     resourceName() {
         return 'process:' + this.cid + ':' + this.field;
     }
 
+    /** creates resource
+     * @param {string} _id - id
+     * @param {string} name - name
+     * @param {object} db - db connection
+     * @returns {object} Resource
+     */
     createResource(_id, name, db) {
         return new Resource(_id, name, {cid: this.cid, field: this.field}, db);
     }
 
+    /** gets new retry policy
+     * @returns {object} retry policy
+     */
     retryPolicy() {
         return new R.IPCRetryPolicy(3);
     }
 
+    /** rescedule
+     * @param {number} date - timestamp
+     * @returns {Promise} - resolved if updated
+     */
     reschedule(date) {
         return this.replaceAfter(date);
     }
 
+    /** fork 
+     *  @returns {Promise} promise
+     */
     fork() {
         if (!this.maxFork) {
             this.maxFork = 0;
@@ -102,10 +145,18 @@ class ProcessJob extends J.IPCJob {
         return ProcessJob.insert(this.db(), {name: this.name, status: 0, data: data, next: Date.now()});
     }
 
+    /** gets current timestamp
+     * @returns {number} timestamp
+     */
     now() {
         return Date.now();
     }
 
+    /** 
+     * @param {object} notes - notes
+     * @param {object} msgs - messages
+     * @returns {object} m
+     */
     compile(notes, msgs) {
         // let pm, pn, pp, po;
 
@@ -126,6 +177,9 @@ class ProcessJob extends J.IPCJob {
         }).filter(m => !!m.m);
     }
 
+    /** finish
+     * @param {object} err - error message or object
+     */
     async _finish(err) {
         if (err) {
             let counts = await this.loader.counts(Date.now() + SEND_AHEAD, this._id);
@@ -148,18 +202,23 @@ class ProcessJob extends J.IPCJob {
         return await super._finish(err);
     }
 
+    /** run
+     * @param {object} db - db connection
+     * @param {function} done - callback function
+     */
     async run(db, done) {
         let resourceError, affected;
         try {
             let count = await this.loader.count(this.now() + SEND_AHEAD), recheck = [], sending = new Set();
 
-            if (count == 0) {
+            if (count === 0) {
                 return done();
             }
             else if (this.isFork && count < FORK_WHEN_MORE_THAN) {
                 return done();
             }
 
+
             do {
                 let date = this.now() + SEND_AHEAD,
                     discarded = await this.loader.discard(date - 3600000);
@@ -181,9 +240,9 @@ class ProcessJob extends J.IPCJob {
                 // check for aborted or deleted messages, delete notes if needed
                 if (!this.isFork) {
                     await Promise.all(Object.values(notes).filter(n => (n.result.status & (N.Status.Aborted | N.Status.Deleted)) > 0).map(note => {
-                        let count = counts[note._id.toString()];
-                        log.w('Note %s has been aborted, clearing %d notifications', note._id, count);
-                        return this.loader.abortNote(note._id, count, this.now(), this.field, (note.result.status & N.Status.Aborted) ? 'Aborted' : 'Deleted');
+                        let count1 = counts[note._id.toString()];
+                        log.w('Note %s has been aborted, clearing %d notifications', note._id, count1);
+                        return this.loader.abortNote(note._id, count1, this.now(), this.field, (note.result.status & N.Status.Aborted) ? 'Aborted' : 'Deleted');
                     }));
                 }
 
@@ -473,13 +532,18 @@ class ProcessJob extends J.IPCJob {
             try {
                 await this.loader.reload(this._id);
             }
-            catch (e) {
-                log.e('Error when reloading for %s: %j', this._id, e);
+            catch (err) {
+                log.e('Error when reloading for %s: %j', this._id, err);
             }
             done(e);
         }
     }
 
+    /** result handling
+     * @param {object} resourceError - error object or string 
+     * @param {array} affected - list of affected
+     * @returns {boolean} true or false
+     */
     async handleResults(resourceError, affected) {
         // in case main job ends with resource error, record it in all messages affected
         // when too much same errors gathered in messages within retry period of 30 minutes, don't reschedule this process job

plugins/push/api/jobs/schedule.js

@@ -4,24 +4,39 @@ const J = require('../../../../api/parts/jobs/job.js'),
     log = require('../../../../api/utils/log.js')('job:push:schedule:' + process.pid),
     S = require('../parts/store.js'),
     N = require('../parts/note.js');
-
+/** schedule job class */
 class ScheduleJob extends J.Job {
+    /** class constructr
+     * @param {string} name - name
+     * @param {object} data - data
+     */
     constructor(name, data) {
         super(name, data);
         log.d('initializing ScheduleJob with %j & %j', name, data);
     }
 
+    /** prepares job
+     * @param {object} manager - not used
+     * @param {object} db - db connection
+     */
     async prepare(manager, db /*, apps */) {
         log.d('Loading notification %s', this.data.mid);
         this.note = await N.Note.load(db, this.data.mid);
         log.d('Loaded notification %s', this.note && this.note._id);
         this.sg = new S.StoreGroup(db);
     }
 
+    /** _timeoutCancelled()
+     * @returns {boolean} true(always)
+     */
     _timeoutCancelled() {
         return true;
     }
 
+    /** run
+     * @param {object} db - data base connection
+     * @param {function} done - callback function
+     */
     async run(db, done) {
         let update, error;
 

plugins/push/api/jobs/validate.js

@@ -4,36 +4,59 @@
 
 const job = require('../../../../api/parts/jobs/job.js'),
     log = require('../../../../api/utils/log.js')('job:push:validate'),
-    creds = require('../parts/credentials.js'),
+    //creds = require('../parts/credentials.js'),
     ConnectionResource = require('../parts/res.js'),
     retry = require('../../../../api/parts/jobs/retry.js');
 
-
+/** class - ValidateJob */
 class ValidateJob extends job.TransientJob {
+    /** constructor
+      * @param {string} name - name
+      * @param {object} data  - data
+      */
     constructor(name, data) {
         super(name, data);
     }
 
-    prepare(manager, db) {
+    /** prepare
+     * @returns {Promise} promise, resolved(always)
+     */
+    prepare(/*manager, db*/) {
         return Promise.resolve();
     }
 
+    /** resource name
+     * @returns {string} 'validate:' + this.data.cid
+     */
     resourceName() {
         return 'validate:' + this.data.cid;
     }
 
+    /** create resource
+     * @param {string} _id - id
+     * @param {string} name  - name
+     * @returns {object} ConnectionResource
+     */
     createResource(_id, name) {
         return new ConnectionResource(_id, name, {cid: this.data.cid, test: false, field: 'ip'}, this.db());
     }
 
+    /** release Resource (call close() on it, returns result)
+     * @param {object} resource to call on
+     * @returns {object} result on close
+     */
     releaseResource(resource) {
         return resource.close();
     }
 
+    /** function returns NoretryPolicy
+        @returns {object} retrypolicy
+    */
     retryPolicy() {
         return new retry.NoRetryPolicy();
     }
 
+    /** function runs job */
     async run() {
         log.i('[%d] validating credentials %s', process.pid, this.data.cid);