backend-manager 3.2.169 → 3.2.171

package/dist/manager/functions/core/actions/api/admin/firestore-query.js

@@ -0,0 +1,165 @@
+const _ = require('lodash');
+const powertools = require('node-powertools');
+
+function Module() {
+
+}
+
+Module.prototype.main = function () {
+  const self = this;
+  const Manager = self.Manager;
+  const Api = self.Api;
+  const assistant = self.assistant;
+  const payload = self.payload;
+
+  return new Promise(async function(resolve, reject) {
+    // Perform checks
+    if (!payload.user.roles.admin) {
+      return reject(assistant.errorify(`Admin required.`, {code: 401}));
+    }
+
+    // Run queries
+    self.docs = [];
+    assistant.log('Queries', payload.data.payload.queries);
+    let queries = powertools.arrayify(payload.data.payload.queries || []);
+
+    let promises = [];
+    for (var i = 0; i < queries.length; i++) {
+      queries[i]
+      promises.push(self.runQuery(queries[i]))
+    }
+
+    // Get the results
+    await Promise.all(promises)
+      .then((r) => {
+        return resolve({data: self.docs});
+      })
+      .catch((e) => {
+        return reject(assistant.errorify(e, {code: 500}));
+      })
+
+  });
+
+};
+
+Module.prototype.runQuery = function (query) {
+  const self = this;
+  const Manager = self.Manager;
+  const assistant = self.assistant;
+
+  query = query || {};
+  query.where = powertools.arrayify(query.where || []);
+  query.filter = powertools.arrayify(query.filter || []);
+  query.orderBy = powertools.arrayify(query.orderBy || []);
+
+  // self.assistant.log('Query', query);
+
+  return new Promise(function(resolve, reject) {
+    let collection;
+
+    if (!query.collection) {
+      return resolve([]);
+      // return reject(new Error('No collection specified.'));
+    }
+
+    collection = self.libraries.admin.firestore().collection(query.collection);
+
+    for (var i = 0; i < query.where.length; i++) {
+      let cur = query.where[i];
+      collection = collection.where(cur.field, cur.operator, cur.value);
+    }
+    for (var i = 0; i < query.orderBy.length; i++) {
+      let cur = query.orderBy[i];
+      collection = collection.orderBy(cur.field, cur.order)
+    }
+    if (query.limit) {
+      collection = collection.limit(query.limit)
+    }
+    if (query.startAt) {
+      collection = collection.startAt(query.startAt)
+    }
+    if (query.startAfter) {
+      collection = collection.startAfter(query.startAfter)
+    }
+    if (query.endAt) {
+      collection = collection.endAt(query.endAt)
+    }
+    if (query.endBefore) {
+      collection = collection.endBefore(query.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(), query.filter)) {
+          self.docs.push({
+            path: doc.ref.path,
+            data: doc.data(),
+          });
+        }
+
+      });
+
+      if (query.filterIndex) {
+        let iS = query.filterIndex[0];
+        let iF = query.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;
+}
+
+module.exports = Module;

package/dist/manager/functions/core/actions/api/admin/firestore-read.js

@@ -0,0 +1,38 @@
+function Module() {
+
+}
+
+Module.prototype.main = function () {
+  const self = this;
+  const Manager = self.Manager;
+  const Api = self.Api;
+  const assistant = self.assistant;
+  const payload = self.payload;
+
+  return new Promise(async function(resolve, reject) {
+    // Set defaults
+    payload.data.payload.path = `${payload.data.payload.path || ''}`;
+    payload.data.payload.options = payload.data.payload.options || {};
+
+    // Perform checks
+    if (!payload.user.roles.admin) {
+      return reject(assistant.errorify(`Admin required.`, {code: 401}));
+    } else if (!payload.data.payload.path) {
+      return reject(assistant.errorify(`<path> parameter required`, {code: 400}));
+    }
+
+    // Read from Firestore
+    await self.libraries.admin.firestore().doc(payload.data.payload.path)
+    .get()
+    .then(doc => {
+      return resolve({data: doc.data()});
+    })
+    .catch(e => {
+      return reject(assistant.errorify(e, {code: 500}));
+    })
+  });
+
+};
+
+
+module.exports = Module;

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

@@ -0,0 +1,54 @@
+function Module() {
+
+}
+
+Module.prototype.main = function () {
+  const self = this;
+  const Manager = self.Manager;
+  const Api = self.Api;
+  const assistant = self.assistant;
+  const payload = self.payload;
+
+  return new Promise(async function(resolve, reject) {
+    // Set defaults
+    payload.data.payload.path = `${payload.data.payload.path || ''}`;
+    payload.data.payload.document = payload.data.payload.document || {};
+    payload.data.payload.options = payload.data.payload.options || {};
+    payload.data.payload.options.merge = typeof payload.data.payload.options.merge === 'undefined' ? true : payload.data.payload.options.merge;
+    payload.data.payload.options.metadataTag = typeof payload.data.payload.options.metadataTag === 'undefined' ? 'admin:firestore-write' : payload.data.payload.options.metadataTag;
+
+    // Perform checks
+    if (!payload.user.roles.admin) {
+      return reject(assistant.errorify(`Admin required.`, {code: 401}));
+    } else if (!payload.data.payload.path) {
+      return reject(assistant.errorify(`Path parameter required.`, {code: 400}));
+    }
+
+    // Fix path
+    if (payload.data.payload.path.match(/\{pushId\}/)) {
+      payload.data.payload.path = payload.data.payload.path.replace(/\{pushId\}/ig, require('pushid')());
+    } else if (payload.data.payload.path.match(/\{nanoId\}/)) {
+      payload.data.payload.path = payload.data.payload.path.replace(/\{nanoId\}/ig, Manager.Utilities().randomId());
+    }
+
+    // Set metadata
+    payload.data.payload.document.metadata = Manager.Metadata().set({tag: payload.data.payload.options.metadataTag})
+
+    // Delete metadataTag
+    delete payload.data.payload.options.metadataTag;
+
+    // Write to Firestore
+    await self.libraries.admin.firestore().doc(payload.data.payload.path)
+    .set(payload.data.payload.document, payload.data.payload.options)
+    .then(r => {
+      return resolve({data: {path: payload.data.payload.path}});
+    })
+    .catch(e => {
+      return reject(assistant.errorify(e, {code: 500}));
+    })
+  });
+
+};
+
+
+module.exports = Module;

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

@@ -0,0 +1,269 @@
+let _;
+
+function Module() {
+
+}
+
+Module.prototype.main = function () {
+  const self = this;
+  const Manager = self.Manager;
+  const Api = self.Api;
+  const assistant = self.assistant;
+  const payload = self.payload;
+
+  return new Promise(async function(resolve, reject) {
+    // Load libraries
+    _ = Manager.require('lodash')
+
+    // Perform checks
+    if (!payload.user.roles.admin) {
+      return reject(assistant.errorify(`Admin required.`, {code: 401}));
+    }
+
+    // Get stats
+    const stats = self.libraries.admin.firestore().doc(`meta/stats`)
+    await stats
+      .get()
+      .then(async (doc) => {
+        let data = doc.data() || {};
+
+        // Only update if requested
+        if (payload.data.payload.update) {
+          await self.updateStats(data)
+            .catch(e => data = e)
+        }
+
+        if (data instanceof Error) {
+          return reject(assistant.errorify(data, {code: 500}));
+        }
+
+        // Retrieve the stats again after updating
+        await stats
+          .get()
+          .then(doc => {
+            data = doc.data() || {};
+          })
+          .catch(e => data = e)
+
+
+        if (data instanceof Error) {
+          return reject(assistant.errorify(data, {code: 500}));
+        }
+
+        return resolve({data: data})
+      })
+      .catch(function (e) {
+        return reject(assistant.errorify(`Failed to get: ${e}`, {code: 500}));
+      })
+  });
+
+};
+
+Module.prototype.fixStats = function (data) {
+  const self = this;
+
+  return new Promise(async function(resolve, reject) {
+    const stats = self.libraries.admin.firestore().doc(`meta/stats`);
+
+
+
+    return resolve();
+  });
+}
+
+// TODO: ADD https://firebase.google.com/docs/firestore/query-data/aggregation-queries#pricing
+Module.prototype.updateStats = function (existingData) {
+  const self = this;
+
+  return new Promise(async function(resolve, reject) {
+    const stats = self.libraries.admin.firestore().doc(`meta/stats`);
+    const gatheringOnline = self.libraries.admin.database().ref(`gatherings/online`);
+    const sessionsApp = self.libraries.admin.database().ref(`sessions/app`);
+    const sessionsOnline = self.libraries.admin.database().ref(`sessions/online`);
+
+    let error = null;
+    let update = {
+      app: _.get(self.Manager.config, 'app.id', null),
+    };
+
+    // Fix broken stats
+    if (!_.get(existingData, 'users.total', null)) {
+      await self.getAllUsers()
+        .then(r => {
+          _.set(update, 'users.total', r.length)
+        })
+        .catch(e => {
+          error = new Error(`Failed fixing stats: ${e}`);
+        })
+    }
+
+    if (error) {
+      return reject(error);
+    }
+
+    // Fetch new notification stats
+    await self.getAllNotifications()
+      .then(r => {
+        _.set(update, 'notifications.total', r)
+      })
+      .catch(e => {
+        error = new Error(`Failed getting notifications: ${e}`);
+      })
+
+    // Fetch new subscription stats
+    await self.getAllSubscriptions()
+      .then(r => {
+        _.set(update, 'subscriptions', r)
+      })
+      .catch(e => {
+        error = new Error(`Failed getting subscriptions: ${e}`);
+      })
+
+    if (error) {
+      return reject(error);
+    }
+
+    const _countUsersOnline = async (app) => {
+      await app
+        .once('value')
+        .then((snap) => {
+          const data = snap.val() || {};
+          const keys = Object.keys(data);
+          const existing = _.get(update, 'users.online', 0)
+          _.set(update, 'users.online', existing + keys.length)
+        })
+        .catch(e => {
+          error = new Error(`Failed getting online users: ${e}`);
+        })
+    }
+
+    // Count users online (in old gathering)
+    await _countUsersOnline(gatheringOnline);
+
+    // Count users online (in new session)
+    await _countUsersOnline(sessionsApp);
+
+    // Count users online (in new session)
+    await _countUsersOnline(sessionsOnline);
+
+    if (error) {
+      return reject(error);
+    }
+
+    // Set metadata
+    update.metadata = self.Manager.Metadata().set({tag: 'admin:get-stats'})
+
+    // Update stats
+    await stats
+      .set(update, { merge: true })
+      .catch(function (e) {
+        return reject(new Error(`Failed getting stats: ${e}`));
+      })
+
+    return resolve();
+  });
+}
+
+Module.prototype.getAllUsers = function () {
+  const self = this;
+  return new Promise(async function(resolve, reject) {
+    self.users = [];
+    await getUsersBatch(self)
+    .catch(e => {
+      return reject(e);
+    })
+    return resolve(self.users);
+  });
+}
+
+Module.prototype.getAllNotifications = function () {
+  const 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.prototype.getAllSubscriptions = function () {
+  const self = this;
+  return new Promise(async function(resolve, reject) {
+    await self.libraries.admin.firestore().collection('users')
+    .where('plan.expires.timestampUNIX', '>=', new Date().getTime() / 1000)
+    .get()
+    .then(function(snapshot) {
+      const stats = {
+        totals: {
+          total: 0,
+          exempt: 0,
+        },
+        plans: {}
+      };
+
+      snapshot
+      .forEach((doc, i) => {
+        const data = doc.data();
+        const planId = _.get(data, 'plan.id', 'basic');
+        const frequency = _.get(data, 'plan.payment.frequency', 'unknown');
+        const isAdmin = _.get(data, 'roles.admin', false);
+        const isVip = _.get(data, 'roles.vip', false);
+
+        if (!stats.plans[planId]) {
+          stats.plans[planId] = {
+            total: 0,
+            monthly: 0,
+            annually: 0,
+            exempt: 0,
+          }
+        }
+
+        if (isAdmin || isVip) {
+          stats.totals.exempt++;
+          stats.plans[planId].exempt++;
+          return
+        }
+
+        stats.totals.total++;
+        stats.plans[planId].total++;
+        stats.plans[planId][frequency] = (stats.plans[planId][frequency] || 0) + 1
+      });
+
+      return resolve(stats);
+    })
+    .catch(function(e) {
+      return reject(e)
+    });
+
+  });
+}
+
+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);
+      });
+  });
+}
+
+module.exports = Module;

package/dist/manager/functions/core/actions/api/admin/payment-processor.js

@@ -0,0 +1,57 @@
+const _ = require('lodash');
+const jetpack = require('fs-jetpack');
+
+function Module() {
+
+}
+
+Module.prototype.main = function () {
+  const self = this;
+
+  // Set shortcuts
+  const Manager = self.Manager;
+  const Api = self.Api;
+  const assistant = self.assistant;
+  const payload = self.payload;
+
+  return new Promise(async function(resolve, reject) {
+    // Check for admin
+    if (!payload.user.roles.admin) {
+      return reject(assistant.errorify(`Admin required.`, {code: 401}));
+    }
+
+    const productId = _.get(payload, 'data.payload.payload.details.productIdGlobal');
+    if (!productId) {
+      return reject(assistant.errorify(`No productId`, {code: 400}));
+    }
+    const processorPath = `${Manager.cwd}/payment-processors/${productId}.js`
+    let processor;
+    // console.log('---processorPath', processorPath);
+
+    try {
+      if (!jetpack.exists(processorPath)) {
+        self.assistant.warn('Subprocessor does not exist:', processorPath)
+
+        return resolve({data: {}})
+      }
+      processor = new (require(processorPath));
+      processor.Manager = self.Manager;
+    } catch (e) {
+      self.assistant.error('Subprocessor failed to load:', processorPath, e)
+
+      return resolve({data: {}})
+    }
+
+    await processor.process(payload.data.payload)
+    .then(result => {
+      return resolve({data: result});
+    })
+    .catch(e => {
+      return reject(assistant.errorify(`Payment processor @ "${processorPath}" failed: ${e}`, {code: 400, sentry: true}));
+    })
+  });
+
+};
+
+
+module.exports = Module;

package/dist/manager/functions/core/actions/api/admin/run-hook.js

@@ -0,0 +1,95 @@
+// Load libraries
+// const path = require('path');
+
+function Module() {
+
+}
+
+Module.prototype.main = function () {
+  const self = this;
+
+  // Set shortcuts
+  const Manager = self.Manager;
+  const Api = self.Api;
+  const assistant = self.assistant;
+  const payload = self.payload;
+
+  return new Promise(async function(resolve, reject) {
+    // Perform checks
+    if (!payload.user.roles.admin && assistant.isProduction()) {
+      return reject(assistant.errorify(`Admin required.`, {code: 401}));
+    }
+
+    // Check for required options
+    if (!payload.data.payload.path) {
+      return reject(assistant.errorify(`Missing required parameter: path`, {code: 400}));
+    }
+
+    // Load the hook
+    const hook = self.loadHook(payload);
+
+    // Run the hook
+    try {
+      // Set variables
+      hook.Manager = assistant.Manager;
+      hook.assistant = assistant;
+      hook.context = null;
+      hook.libraries = Manager.libraries;
+
+      // Get hook name
+      const hookName = payload.data.payload.path.split('/').pop();
+
+      // Set log prefix
+      assistant.setLogPrefix(`cron/daily/${hookName}()`);
+
+      // Run the hook
+      const result = await hook.main(assistant);
+
+      return resolve({data: result, status: 200});
+    } catch (e) {
+      return reject(assistant.errorify(e.message, {code: 500}));
+    }
+  });
+};
+
+Module.prototype.loadHook = function () {
+  const self = this;
+
+  // Set shortcuts
+  const Manager = self.Manager;
+  const assistant = self.assistant;
+  const payload = self.payload;
+
+  // Set paths
+  const paths = [
+    `${Manager.rootDirectory}/functions/core/${payload.data.payload.path}`,
+    `${Manager.cwd}/${payload.data.payload.path}`,
+    `${Manager.cwd}/hooks/${payload.data.payload.path}`,
+  ];
+
+  // Loop through paths and try to load the hook
+  for (let i = 0; i < paths.length; i++) {
+    const current = pathify(paths[i]);
+
+    // Log
+    assistant.log('Trying path:', current);
+
+    // Try to load the hook
+    try {
+      // If the hook is successfully loaded, break the loop
+      return (new (require(current))());
+    } catch (e) {
+      // if the hook fails to load, continue to the next path
+    }
+  }
+}
+
+function pathify(path) {
+  const fixed = path
+    .replace('.js', '')
+
+  // Return
+  return `${fixed}.js`;
+}
+
+module.exports = Module;