backend-manager 3.2.169 → 3.2.171

package/dist/manager/functions/core/admin/firestore-write.js

@@ -0,0 +1,72 @@
+let Module = {
+  init: async function (Manager, data) {
+    this.Manager = Manager;
+    this.libraries = Manager.libraries;
+    this.assistant = Manager.Assistant({req: data.req, res: data.res})
+    this.req = data.req;
+    this.res = data.res;
+
+    return this;
+  },
+  main: async function() {
+    const self = this;
+    let libraries = self.libraries;
+    let assistant = self.assistant;
+    let req = self.req;
+    let res = self.res;
+    let options = self.assistant.request.data;
+    let admin = self.Manager.libraries.admin;
+
+    let response = {
+      status: 200,
+      data: {},
+    };
+
+    return libraries.cors(req, res, async () => {
+      let user = await assistant.authenticate();
+
+      // Analytics
+      let analytics = self.Manager.Analytics({
+        assistant: assistant,
+        uuid: user.auth.uid,
+      })
+      .event({
+        category: 'admin',
+        action: 'firestore-write',
+        // label: '',
+      });
+
+      // Options
+      options.path = `${options.path || ''}`
+      options.document = options.document || {};
+      options.options = options.options || {};
+      options.options.merge = typeof options.options.merge === 'undefined' ? true : options.options.merge;
+
+      if (!user.roles.admin) {
+        response.status = 401;
+        response.error = new Error('Unauthenticated, admin required.');
+      } else if (!options.path) {
+        response.status = 401;
+        response.error = new Error('Path parameter required');
+      } else {
+        await admin.firestore().doc(options.path)
+        .set(options.document, options.options)
+        .then(r => {
+          assistant.log(`Wrote to ${options.path}:`, options.document, options.options)
+        })
+        .catch(e => {
+          response.status = 500;
+          response.error = e;
+        })
+      }
+
+      if (response.status === 200) {
+        return res.status(response.status).json(response.data);
+      } else {
+        assistant.error(response.error)
+        return res.status(response.status).send(response.error.message);
+      }
+    });
+  },
+}
+module.exports = Module;

package/dist/manager/functions/core/admin/get-stats.js

@@ -0,0 +1,218 @@
+let Module = {
+  init: async function (Manager, data) {
+    this.Manager = Manager;
+    this.libraries = Manager.libraries;
+    this.assistant = Manager.Assistant({req: data.req, res: data.res})
+    this.req = data.req;
+    this.res = data.res;
+
+    return this;
+  },
+  main: async function() {
+    let self = this;
+    let libraries = self.libraries;
+    let assistant = self.assistant;
+    let req = self.req;
+    let res = self.res;
+
+    let response = {
+      status: 200,
+      data: {},
+      error: null,
+    };
+
+    return libraries.cors(req, res, async () => {
+      // authenticate admin!
+      let user = await assistant.authenticate();
+
+      // Analytics
+      let analytics = self.Manager.Analytics({
+        assistant: assistant,
+        uuid: user.auth.uid,
+      })
+      .event({
+        category: 'admin',
+        action: 'get-stats',
+        // label: '',
+      });
+
+      if (!user.roles.admin) {
+        response.status = 401;
+        response.error = new Error('Unauthenticated, admin required.');
+        assistant.error(response.error)
+      } else {
+        let stats = libraries.admin.firestore().doc(`meta/stats`)
+
+        await stats
+          .get()
+          .then(async function (doc) {
+            response.data = doc.data() || {};
+            await self.fixStats(response.data)
+              .catch(e => {
+                response.status = 500;
+                response.error = new Error(`Failed fixing stats: ${e.message}`);
+                assistant.error(response.error)
+              })
+
+            await self.updateStats()
+              .catch(e => {
+                response.status = 500;
+                response.error = new Error(`Failed updating stats: ${e.message}`);
+                assistant.error(response.error)
+              })
+
+            await stats
+              .get()
+              .then(r => {
+                response.data = r.data() || {};
+              })
+              .catch(function (e) {
+                response.status = 500;
+                response.error = e;
+                assistant.error(response.error)
+              })
+          })
+          .catch(function (e) {
+            response.status = 500;
+            response.error = e;
+            assistant.error(response.error)
+          })
+      }
+
+      // response.data = data;
+
+      assistant.log('Stats', assistant.request.data, response);
+
+      if (response.status === 200) {
+        return res.status(response.status).json(response.data);
+      } else {
+        return res.status(response.status).send(response.error.message);
+      }
+    });
+  },
+  fixStats: function (data) {
+    let self = this;
+    return new Promise(async function(resolve, reject) {
+      let stats = self.libraries.admin.firestore().doc(`meta/stats`);
+
+      if (!data || !data.users || !data.users.total || !data.subscriptions || !data.subscriptions.total) {
+        let usersTotal = 0;
+        let subscriptionsTotal = 0;
+        await self.getAllUsers()
+          .then(r => {
+            usersTotal = r.length
+          })
+          .catch(e => {
+            response.status = 500;
+            response.error = new Error(`Failed fixing stats: ${e.message}`);
+            self.assistant.error(response.error);
+          })
+        await self.getAllSubscriptions()
+          .then(r => {
+            subscriptionsTotal = r
+          })
+          .catch(e => {
+            response.status = 500;
+            response.error = new Error(`Failed fixing stats: ${e.message}`);
+            self.assistant.error(response.error);
+          })
+        await stats
+          .set({
+            users: {
+              total: usersTotal,
+            },
+            subscriptions: {
+              total: subscriptionsTotal,
+            },
+          }, { merge: true })
+          .catch(function (e) {
+            return reject(e);
+          })
+      }
+
+
+      return resolve(data);
+    });
+  },
+  updateStats: function () {
+    let self = this;
+    return new Promise(async function(resolve, reject) {
+      let stats = self.libraries.admin.firestore().doc(`meta/stats`);
+      let online = self.libraries.admin.database().ref(`gatherings/online`);
+      let onlineCount = 0;
+
+      await online
+        .once('value')
+        .then((snap) => {
+          let data = snap.val() || {};
+          let keys = Object.keys(data);
+          onlineCount = keys.length;
+        })
+        .catch(e => {
+          return reject(e);
+        })
+
+      await stats
+        .set({
+          users: {
+            online: onlineCount
+          }
+        }, { merge: true })
+        .catch(function (e) {
+          return reject(e);
+        })
+
+      return resolve();
+    });
+  },
+  getAllUsers: function () {
+    let self = this;
+    return new Promise(async function(resolve, reject) {
+      self.users = [];
+      await getUsersBatch(self)
+      .catch(e => {
+        return reject(e);
+      })
+      return resolve(self.users);
+    });
+  },
+  getAllSubscriptions: function () {
+    let self = this;
+    return new Promise(async function(resolve, reject) {
+      await self.libraries.admin.firestore().collection('notifications/subscriptions/all')
+      .get()
+      .then(function(querySnapshot) {
+        return resolve(querySnapshot.size)
+      })
+      .catch(function(e) {
+        return reject(e)
+      });
+    });
+  }
+}
+
+module.exports = Module;
+
+function getUsersBatch(self, nextPageToken) {
+  return new Promise(async function(resolve, reject) {
+    self.libraries.admin.auth().listUsers(1000, nextPageToken)
+      .then(function(listUsersResult) {
+        self.users = self.users.concat(listUsersResult.users);
+        if (listUsersResult.pageToken) {
+          // List next batch of users.
+          getUsersBatch(self, listUsersResult.pageToken)
+            .then(() => {
+              return resolve(listUsersResult.users);
+            })
+            .catch((e) => {
+              return reject(e);
+            })
+        } else {
+          return resolve(listUsersResult.users);
+        }
+      })
+      .catch(function(e) {
+        return reject(e);
+      });
+  });
+}

package/dist/manager/functions/core/admin/query.js

@@ -0,0 +1,198 @@
+const _ = require('lodash');
+const powertools = require('node-powertools');
+
+let Module = {
+  init: async function (Manager, data) {
+    this.Manager = Manager;
+    this.libraries = Manager.libraries;
+    this.assistant = Manager.Assistant({req: data.req, res: data.res})
+    this.req = data.req;
+    this.res = data.res;
+
+    return this;
+  },
+  main: async function() {
+    let self = this;
+    let libraries = self.libraries;
+    let assistant = self.assistant;
+    let req = self.req;
+    let res = self.res;
+
+    let response = {
+      status: 200,
+      data: {},
+      error: null,
+    };
+
+    return libraries.cors(req, res, async () => {
+      // authenticate admin!
+      let user = await assistant.authenticate();
+
+      // Analytics
+      let analytics = self.Manager.Analytics({
+        assistant: assistant,
+        uuid: user.auth.uid,
+      })
+      .event({
+        category: 'admin',
+        action: 'query',
+        // label: '',
+      });
+
+      if (!user.roles.admin) {
+        response.status = 401;
+        response.error = new Error('Unauthenticated, admin required.');
+        assistant.error(response.error)
+      } else {
+        self.docs = [];
+        // assistant.log('Queries', assistant.request.data.queries);
+        let queries = powertools.arrayify(assistant.request.data.queries || []);
+
+        let promises = [];
+        for (var i = 0; i < queries.length; i++) {
+          queries[i]
+          promises.push(self.runQuery(queries[i]))
+        }
+
+        await Promise.all(promises)
+          .then((r) => {
+            response.data = self.docs;
+            // assistant.log('Query result:', );
+          })
+          .catch((e) => {
+            response.error = e;
+            response.status = 400;
+            assistant.error(response.error)
+          })
+      }
+
+      assistant.log('Query', assistant.request.data, response);
+
+      if (response.status === 200) {
+        return res.status(response.status).json(response.data);
+      } else {
+        return res.status(response.status).send(response.error.message);
+      }
+    });
+  },
+  runQuery: runQuery,
+}
+module.exports = Module;
+
+// HELPERS //
+async function runQuery(payload) {
+  let self = this;
+
+  payload = payload || {};
+  payload.where = powertools.arrayify(payload.where || []);
+  payload.filter = powertools.arrayify(payload.filter || []);
+  payload.orderBy = powertools.arrayify(payload.orderBy || []);
+
+  // self.assistant.log('Query', payload);
+
+  return new Promise(function(resolve, reject) {
+    let collection;
+
+    if (!payload.collection) {
+      return resolve([]);
+      // return reject(new Error('No collection specified.'));
+    }
+
+    collection = self.libraries.admin.firestore().collection(payload.collection);
+
+    for (var i = 0; i < payload.where.length; i++) {
+      let cur = payload.where[i];
+      collection = collection.where(cur.field, cur.operator, cur.value);
+    }
+    for (var i = 0; i < payload.orderBy.length; i++) {
+      let cur = payload.orderBy[i];
+      collection = collection.orderBy(cur.field, cur.order)
+    }
+    if (payload.limit) {
+      collection = collection.limit(payload.limit)
+    }
+    if (payload.startAt) {
+      collection = collection.startAt(payload.startAt)
+    }
+    if (payload.startAfter) {
+      collection = collection.startAfter(payload.startAfter)
+    }
+    if (payload.endAt) {
+      collection = collection.endAt(payload.endAt)
+    }
+    if (payload.endBefore) {
+      collection = collection.endBefore(payload.endBefore)
+    }
+
+    collection
+    .get()
+    .then(function (querySnapshot) {
+      querySnapshot.forEach(function (doc) {
+
+        let exists = self.docs.find(item => {
+          return item.path === doc.ref.path
+        })
+
+        if (!exists && checkFilter(doc.data(), payload.filter)) {
+          self.docs.push({
+            path: doc.ref.path,
+            data: doc.data(),
+          });
+        }
+
+      });
+
+      if (payload.filterIndex) {
+        let iS = payload.filterIndex[0];
+        let iF = payload.filterIndex[1];
+        iF = iF > self.docs.length ? self.docs.length - 1 : iF;
+        self.docs = self.docs.slice(iS, iF);
+      }
+
+      return resolve(self.docs);
+    })
+    .catch(function (error) {
+      self.assistant.error(error)
+      return reject(error);
+    });
+  });
+
+}
+
+function checkFilter(data, filter) {
+
+  // Loop through all filters
+  for (var i = 0, l = filter.length; i < l; i++) {
+    // Set up field and checks
+    let field = `${filter[i].field}`.split(' || ');
+    field = powertools.arrayify(field);
+    let matches = filter[i].matches || '';
+    let regex = powertools.regexify(matches);
+
+    // Pass/fail
+    let innerPassed = false;
+
+    // Loop through each filter's fields
+    for (var i2 = 0, l2 = field.length; i2 < l2; i2++) {
+      let fieldInner = field[i2];
+      let value = _.get(data, fieldInner, undefined);
+
+      if (typeof value === 'undefined') {
+        innerPassed = false;
+        continue;
+      } else if (typeof value === 'string') {
+        if (value.match(regex)) {
+          innerPassed = true;
+          break;
+        }
+      }
+    }
+
+    // If there was not a successful innerPassed then break (innerPassed works on OR logic)
+    if (!innerPassed) {
+      return false;
+    }
+
+  }
+  return true;
+}

package/dist/manager/functions/core/admin/send-notification.js

@@ -0,0 +1,206 @@
+let Module = {
+  init: async function (Manager, data) {
+    this.Manager = Manager;
+    this.libraries = Manager.libraries;
+    this.assistant = Manager.Assistant({req: data.req, res: data.res})
+    this.req = data.req;
+    this.res = data.res
+
+    return this;
+  },
+  main: async function() {
+    let self = this;
+    let libraries = self.libraries;
+    let assistant = self.assistant;
+    let req = self.req;
+    let res = self.res;
+
+    let response = {
+      status: 200,
+      data: {},
+      error: null,
+    };
+
+    return libraries.cors(req, res, async () => {
+      // authenticate admin!
+      let user = await assistant.authenticate();
+
+      // Analytics
+      let analytics = self.Manager.Analytics({
+        assistant: assistant,
+        uuid: user.auth.uid,
+      })
+      .event({
+        category: 'admin',
+        action: 'send-notification',
+        // label: '',
+      });
+
+      let payload = self.assistant.request.data.payload || {};
+
+      if (!payload.title || !payload.body) {
+        response.status = 400;
+        response.error = new Error('Not enough notification parameters supplied.');
+        assistant.error(response.error)
+        return res.status(response.status).send(response.error.message);
+      }
+
+      if (!user.roles.admin) {
+        response.status = 401;
+        response.error = new Error('Unauthenticated, admin required.');
+        assistant.error(response.error)
+        return res.status(response.status).send(response.error.message);
+      } else {
+        await self.getTokens({tags: false});
+      }
+
+      assistant.log('Notification', assistant.request.data, response);
+
+      if (response.status === 200) {
+        return res.status(response.status).json(response.data);
+      } else {
+        return res.status(response.status).send(response.error.message);
+      }
+
+    });
+  },
+  getTokens: getTokens,
+  sendBatch: sendBatch,
+  cleanTokens: cleanTokens,
+  deleteToken: deleteToken,
+}
+module.exports = Module;
+
+// HELPERS //
+let path_processing = 'notifications/processing/all/{notificationId}';
+let path_subscriptions = 'notifications/subscriptions/all';
+let badTokenReasons = ['messaging/invalid-registration-token', 'messaging/registration-token-not-registered']
+let batchPromises = [];
+
+function sendBatch(batch, id) {
+  let self = this;
+  // self.assistant.log(`Sending batch ID: ${id}`, batch);
+  self.assistant.log(`Sending batch ID: ${id}`);
+
+  // self.assistant.log('payload', payload);
+  return new Promise(async function(resolve, reject) {
+    let payload = {};
+    payload.notification = {};
+    payload.notification.title = self.assistant.request.data.payload.title;
+    payload.notification.click_action = self.assistant.request.data.payload.click_action;
+    payload.notification.body = self.assistant.request.data.payload.body;
+    payload.notification.icon = self.assistant.request.data.payload.icon;
+
+    await self.libraries.admin.messaging().sendToDevice(batch, payload)
+      .then(async function (response) {
+        // self.result.batches.list.push('#' + id + ' | ' + '✅  ' + response.successCount + ' | ' + '❌  ' + response.failureCount);
+        self.assistant.log('Sent batch #' + id);
+        // self.result.successes += response.successCount;
+        // self.result.failures += response.failureCount;
+        // console.log('RESP', response);
+        if (response.failureCount > 0) {
+          await self.cleanTokens(batch, response.results, id);
+        }
+        resolve();
+      })
+      .catch(function (e) {
+        self.assistant.error('Error sending batch #' + id, e);
+        // self.result.status = 'fail';
+        reject(e);
+      })
+  });
+}
+
+function getTokens(options) {
+  let self = this;
+  options = options || {};
+  options.tags = options.tags || false;
+  return new Promise(async function(resolve, reject) {
+    let subs = self.libraries.admin.firestore().collection(path_subscriptions);
+    if (options.tags) {
+      subs.where('tags', 'array-contains-any', options.tags)
+    }
+    await subs
+      .get()
+      .then(function(querySnapshot) {
+        self.assistant.log(`Queried ${querySnapshot.size} tokens.`);
+        // self.result.subscriptionsStart = querySnapshot.size;
+        let batchCurrentSize = 0;
+        let batchSizeMax = 1000;
+
+        let batchCurrent = [];
+        let batchLoops = 1;
+        batchPromises = [];
+
+        querySnapshot.forEach(function(doc) {
+          // log(self, 'loading... ', batchLoops+'/'+querySnapshot.size);
+          if ((batchCurrentSize < batchSizeMax - 1) && (batchLoops < querySnapshot.size)) {
+            batchCurrent.push(doc.data().token);
+            batchCurrentSize++;
+          } else {
+            let batchId = batchPromises.length + 1;
+            batchCurrent.push(doc.data().token);
+            batchCurrentSize++;
+            console.log(`Got batch ID: ${batchId} with ${batchCurrentSize} tokens.`);
+            batchPromises.push(self.sendBatch(batchCurrent, batchId));
+            batchCurrent = [];
+            batchCurrentSize = 0;
+          }
+          batchLoops++;
+        });
+      })
+      .catch(function(e) {
+        self.assistant.error('Error querying tokens: ', e)
+        reject(error);
+      });
+
+    await Promise.all(batchPromises)
+      .then(function(values) {
+        self.assistant.log('Finished all batches.');
+      })
+      .catch(function(e) {
+        self.assistant.error('Error sending batches: ', e)
+      });
+    resolve();
+
+  });
+}
+
+function cleanTokens(batch, results, id) {
+  let self = this;
+  let cleanPromises = [];
+  // self.assistant.log(`Cleaning tokens of batch ID: ${id}`, results);
+  self.assistant.log(`Cleaning tokens of batch ID: ${id}`);
+  return new Promise(async function(resolve, reject) {
+    results.forEach(function (item, index) {
+      if (!item.error) { return false; }
+      let curCode = item.error.code;
+      let token = batch[index];
+      self.assistant.log(`Found bad token: ${index} = ${curCode}`);
+      if (badTokenReasons.includes(curCode)) {
+        cleanPromises.push(self.deleteToken(token, curCode));
+      }
+    })
+    await Promise.all(cleanPromises)
+      .catch(function(e) {
+        self.assistant.log('error', "Error cleaning failed tokens: ", e);
+      });
+    resolve();
+  });
+}
+
+function deleteToken(token, errorCode) {
+  let self = this;
+  return new Promise(function(resolve, reject) {
+    self.libraries.admin.firestore().doc(`${path_subscriptions}/${token}`)
+      .delete()
+      .then(function() {
+        self.assistant.log(`Deleting bad token: ${token} for reason ${errorCode}`);
+        resolve();
+      })
+      .catch(function(error) {
+        self.assistant.log('error', `Error deleting bad token: ${token} for reason ${errorCode} because of error ${error}`);
+        resolve();
+      })
+  });
+}