backend-manager 1.1.105 → 2.0.2

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

@@ -0,0 +1,206 @@
+function Module() {
+
+}
+
+Module.prototype.init = async function (s, payload) {
+  const self = this;
+  self.Manager = s.Manager;
+  self.libraries = s.Manager.libraries;
+  self.assistant = s.Manager.assistant;
+  self.payload = payload;
+
+  return self;
+};
+
+Module.prototype.main = function () {
+  const self = this;
+  const Manager = self.Manager;
+  const assistant = self.assistant;
+  const payload = self.payload;
+
+  return new Promise(async function(resolve, reject) {
+
+    if (!payload.user.roles.admin) {
+      return reject(assistant.errorManager(`Admin required.`, {code: 401, sentry: false, send: false, log: false}).error)
+    } else {
+      const stats = self.libraries.admin.firestore().doc(`meta/stats`)
+      await stats
+        .get()
+        .then(async (doc) => {
+          let data = doc.data() || {};
+          let error = null;
+
+          await self.fixStats(data)
+            .catch(e => {
+              error = e;
+            })
+
+          await self.updateStats()
+            .catch(e => {
+              error = e;
+            })
+
+          if (error) {
+            return reject(assistant.errorManager(error, {code: 500, sentry: false, send: false, log: false}).error)
+          }
+
+          await stats
+            .get()
+            .then(doc => {
+              data = doc.data() || {};
+            })
+            .catch((e) => {
+              error = e;
+            })
+
+          if (error) {
+            return reject(assistant.errorManager(error, {code: 500, sentry: false, send: false, log: false}).error)
+          }
+
+          return resolve({data: data})
+        })
+        .catch(function (e) {
+          return reject(assistant.errorManager(`Failed to get: ${e}`, {code: 500, sentry: false, send: false, log: false}).error)
+        })
+    }
+  });
+
+};
+
+Module.prototype.fixStats = function (data) {
+  const self = this;
+
+  return new Promise(async function(resolve, reject) {
+    const 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;
+      let error = null;
+      await self.getAllUsers()
+        .then(r => {
+          usersTotal = r.length
+        })
+        .catch(e => {
+          error = new Error(`Failed fixing stats: ${e}`);
+          self.assistant.error(error, {environment: 'production'});
+        })
+      await self.getAllSubscriptions()
+        .then(r => {
+          subscriptionsTotal = r
+        })
+        .catch(e => {
+          error = new Error(`Failed getting subscriptions: ${e}`);
+          self.assistant.error(error, {environment: 'production'});
+        })
+
+      if (error) {
+        return reject(error);
+      }
+      await stats
+        .set({
+          users: {
+            total: usersTotal,
+          },
+          subscriptions: {
+            total: subscriptionsTotal,
+          },
+        }, { merge: true })
+        .catch(function (e) {
+          return reject(e);
+        })
+    }
+
+    return resolve(data);
+  });
+}
+
+Module.prototype.updateStats = function () {
+  const self = this;
+
+  return new Promise(async function(resolve, reject) {
+    const stats = self.libraries.admin.firestore().doc(`meta/stats`);
+    let online = self.libraries.admin.database().ref(`gatherings/online`);
+    let onlineCount = 0;
+    let error = null;
+
+    await online
+      .once('value')
+      .then((snap) => {
+        let data = snap.val() || {};
+        let keys = Object.keys(data);
+        onlineCount = keys.length;
+      })
+      .catch(e => {
+        error = new Error(`Failed getting online users: ${e}`);
+      })
+
+    if (error) {
+      return reject(error);
+    }
+
+    await stats
+      .set({
+        users: {
+          online: onlineCount
+        }
+      }, { merge: true })
+      .catch(function (e) {
+        return reject(`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.getAllSubscriptions = 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)
+    });
+  });
+}
+
+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/src/manager/functions/core/actions/api/admin/payment-processor.js

@@ -0,0 +1,56 @@
+const _ = require('lodash');
+
+function Module() {
+
+}
+
+Module.prototype.init = async function (s, payload) {
+  const self = this;
+  self.Manager = s.Manager;
+  self.libraries = s.Manager.libraries;
+  self.assistant = s.Manager.assistant;
+  self.payload = payload;
+
+  return self;
+};
+
+Module.prototype.main = function () {
+  const self = this;
+  const Manager = self.Manager;
+  const assistant = self.assistant;
+  const payload = self.payload;
+
+  return new Promise(async function(resolve, reject) {
+
+    if (!payload.user.roles.admin) {
+      return reject(assistant.errorManager(`Admin required.`, {code: 401, sentry: false, send: false, log: false}).error)
+    }
+
+    const productId = _.get(payload, 'data.payload.payload.details.productIdGlobal');
+    if (!productId) {
+      return reject(assistant.errorManager(`No productId`, {code: 400, sentry: false, send: false, log: false}).error)
+    }
+    const processorPath = `${process.cwd()}/payment-processors/${productId}.js`
+    let processor;
+    // console.log('---processorPath', processorPath);
+    try {
+      processor = new (require(processorPath));
+      processor.Manager = self.Manager;
+    } catch (e) {
+      self.assistant.error('Error loading processor', processorPath, e, {environment: 'production'})
+      return resolve({data: {}})
+    }
+
+    await processor.process(payload.data.payload)
+    .then(result => {
+      return resolve({data: result});
+    })
+    .catch(e => {
+      return reject(assistant.errorManager(`Payment processor @ "${processorPath}" failed: ${e}`, {code: 400, sentry: true, send: false, log: false}).error)
+    })
+  });
+
+};
+
+
+module.exports = Module;

package/src/manager/functions/core/actions/api/admin/send-notification.js

@@ -0,0 +1,189 @@
+const path_processing = 'notifications/processing/all/{notificationId}';
+const path_subscriptions = 'notifications/subscriptions/all';
+const badTokenReasons = ['messaging/invalid-registration-token', 'messaging/registration-token-not-registered']
+
+function Module() {
+
+}
+
+Module.prototype.init = async function (s, payload) {
+  const self = this;
+  self.Manager = s.Manager;
+  self.libraries = s.Manager.libraries;
+  self.assistant = s.assistant;
+  self.payload = payload;
+
+  return self;
+};
+
+Module.prototype.main = function () {
+  const self = this;
+  const Manager = self.Manager;
+  const assistant = self.assistant;
+  const payload = self.payload;
+
+  return new Promise(async function(resolve, reject) {
+
+    // console.log('----self.Manager.libraries', self.Manager.libraries);
+    // console.log('----self.Manager.libraries.sentry 1', self.Manager.libraries.sentry);
+
+    if (!payload.user.roles.admin) {
+      return reject(assistant.errorManager(`Admin required.`, {code: 401, sentry: false, send: false, log: false}).error)
+    }
+
+    if (!payload.data.payload.title || !payload.data.payload.body) {
+      return reject(assistant.errorManager(`Parameters <title> and <body> required`, {code: 400, sentry: true, send: false, log: false}).error)
+    }
+
+    await self.getTokens({tags: false})
+    .then(r => {
+      return resolve({data: r})
+    })
+    .catch(e => {
+      return reject(assistant.errorManager(`Failed to send notification: ${e}`, {code: 400, sentry: true, send: false, log: false}).error)
+    })
+  });
+
+};
+
+// HELPERS //
+Module.prototype.getTokens = function (options) {
+  const 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);
+    let batchPromises = [];
+
+    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;
+
+        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, {environment: 'production'})
+        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, {environment: 'production'})
+      });
+    resolve();
+
+  });
+}
+
+Module.prototype.sendBatch = function (batch, id) {
+  const self = this;
+  return new Promise(async function(resolve, reject) {
+    // self.assistant.log(`Sending batch ID: ${id}`, batch);
+    self.assistant.log(`Sending batch ID: ${id}`);
+
+    // self.assistant.log('payload', payload);
+
+    let payload = {};
+    payload.notification = {};
+    payload.notification.title = self.payload.data.payload.title;
+    payload.notification.clickAction = self.payload.data.payload.click_action || self.payload.data.payload.clickAction;
+    payload.notification.click_action = self.payload.data.payload.click_action || self.payload.data.payload.clickAction;
+    payload.notification.body = self.payload.data.payload.body;
+    payload.notification.icon = self.payload.data.payload.icon || self.Manager.config.brand.brandmark;
+
+    // payload.data = {};
+    // payload.data.clickAction = self.payload.data.payload.click_action || self.payload.data.payload.clickAction;
+    // payload.data.click_action = self.payload.data.payload.click_action || self.payload.data.payload.clickAction;
+
+
+    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, {environment: 'production'});
+        // self.result.status = 'fail';
+        reject(e);
+      })
+  });
+}
+
+Module.prototype.cleanTokens = function (batch, results, id) {
+  const self = this;
+
+  return new Promise(async function(resolve, reject) {
+    let cleanPromises = [];
+    // self.assistant.log(`Cleaning tokens of batch ID: ${id}`, results);
+    self.assistant.log(`Cleaning tokens of batch ID: ${id}`);
+
+    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();
+  });
+}
+
+Module.prototype.deleteToken = function (token, errorCode) {
+  const 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();
+      })
+  });
+}
+
+module.exports = Module;

package/src/manager/functions/core/actions/api/general/generate-uuid.js

@@ -0,0 +1,49 @@
+const uuid = require('uuid');
+
+function Module() {
+
+}
+
+Module.prototype.init = async function (s, payload) {
+  const self = this;
+  self.Manager = s.Manager;
+  self.libraries = s.Manager.libraries;
+  self.assistant = s.Manager.assistant;
+  self.payload = payload;
+
+  return self;
+};
+
+Module.prototype.main = function () {
+  const self = this;
+  const Manager = self.Manager;
+  const assistant = self.assistant;
+  const payload = self.payload;
+
+  return new Promise(async function(resolve, reject) {
+
+    let result = '';
+    payload.data.payload.namespace = payload.data.payload.namespace || Manager.config.backend_manager.namespace;
+    payload.data.payload.version = `${payload.data.payload.version || '5'}`.replace('v', '');
+    payload.data.payload.name = payload.data.payload.name || payload.data.payload.input;
+
+    if (payload.data.payload.version === '5') {
+      if (!payload.data.payload.name) {
+        return reject(assistant.errorManager(`You must provide a name to hash for uuid v5.`, {code: 400, sentry: false, send: false, log: false}).error)
+      } else {
+        result = uuid.v5(payload.data.payload.name, payload.data.payload.namespace);
+      }
+    } else if (payload.data.payload.version === '4') {
+      result = uuid.v4();
+    }
+
+    assistant.log('UUID Generated', payload.data.payload, result, {environment: 'production'});
+
+    return resolve({data: {uuid: result}});
+
+  });
+
+};
+
+
+module.exports = Module;

package/src/manager/functions/core/actions/api/handler/create-post.js

@@ -0,0 +1,118 @@
+const fetch = require('node-fetch');
+const _ = require('lodash')
+
+function Module() {
+
+}
+
+Module.prototype.init = async function (s, payload) {
+  const self = this;
+  self.Manager = s.Manager;
+  self.libraries = s.Manager.libraries;
+  self.assistant = s.Manager.assistant;
+  self.payload = payload;
+
+  return self;
+};
+
+Module.prototype.main = function () {
+  const self = this;
+  const Manager = self.Manager;
+  const assistant = self.assistant;
+  const payload = self.payload;
+
+  return new Promise(async function(resolve, reject) {
+
+    if (!payload.user.roles.admin) {
+      return reject(assistant.errorManager(`Admin required.`, {code: 401, sentry: false, send: false, log: false}).error)
+    }
+
+    const createdInvoice = await fetch('https://us-central1-itw-creative-works.cloudfunctions.net/wrapper', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        authenticationToken: Manager.config.backend_manager.key,
+        method: 'post',
+        service: 'paypal',
+        command: 'v2/invoicing/invoices',
+        body: {
+          detail: {
+            currency_code: 'USD',
+            note: `Post to ${Manager.config.brand.name}`,
+          },
+          primary_recipients: [
+            {
+              billing_info: {
+                email_address: payload.data.payload.invoiceEmail,
+              },
+            }
+          ],
+          items: [
+            {
+              name: `Guest post`,
+              description: `blog/${payload.data.payload.url}`,
+              quantity: '1',
+              unit_amount: {
+                currency_code: 'USD',
+                value: `${payload.data.payload.invoicePrice}`
+              },
+              // discount: {
+              //   percent: '5'
+              // },
+              unit_of_measure: 'QUANTITY'
+            },
+          ],
+        }
+      }),
+    })
+    .then(function (res) {
+      return res.text()
+        .then(function (data) {
+          if (res.ok) {
+            return JSON.parse(data)
+          } else {
+            throw new Error(data || res.statusText || 'Unknown error.')
+          }
+        })
+    })
+    .catch(function (e) {
+      return e;
+    });
+
+    if (createdInvoice instanceof Error) {
+      return reject(assistant.errorManager(createdInvoice, {code: 400, sentry: false, send: false, log: false}).error)
+    }
+
+    const createdInvoiceId = _.get(createdInvoice, 'href', '').split('/').pop();
+    const sentInvoice = await fetch('https://us-central1-itw-creative-works.cloudfunctions.net/wrapper', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        authenticationToken: Manager.config.backend_manager.key,
+        service: 'paypal',
+        command: `v2/invoicing/invoices/${createdInvoiceId}/send`,
+        method: 'post',
+        body: {
+        }
+      }),
+    })
+    .then(function (res) {
+      return res.text()
+        .then(function (data) {
+          if (res.ok) {
+            return resolve({data: JSON.parse(data)})
+          } else {
+            throw new Error(data || res.statusText || 'Unknown error.')
+          }
+        })
+    })
+    .catch(function (e) {
+      return reject(assistant.errorManager(e, {code: 500, sentry: false, send: false, log: false}).error)
+    });
+
+  });
+
+};
+
+
+module.exports = Module;

package/src/manager/functions/core/actions/api/template.js

@@ -0,0 +1,34 @@
+function Module() {
+
+}
+
+Module.prototype.init = async function (s, payload) {
+  const self = this;
+  self.Manager = s.Manager;
+  self.libraries = s.Manager.libraries;
+  self.assistant = s.Manager.assistant;
+  self.payload = payload;
+
+  return self;
+};
+
+Module.prototype.main = function () {
+  const self = this;
+  const Manager = self.Manager;
+  const assistant = self.assistant;
+  const payload = self.payload;
+
+  return new Promise(async function(resolve, reject) {
+
+    if (!payload.user.roles.admin) {
+      return reject(assistant.errorManager(`Admin required.`, {code: 401, sentry: false, send: false, log: false}).error)
+    }
+
+    return resolve({data: {success: true}});
+
+  });
+
+};
+
+
+module.exports = Module;

package/src/manager/functions/core/actions/api/test/authenticate.js

@@ -0,0 +1,31 @@
+function Module() {
+
+}
+
+Module.prototype.init = async function (s, payload) {
+  const self = this;
+  self.Manager = s.Manager;
+  self.libraries = s.Manager.libraries;
+  self.assistant = s.Manager.assistant;
+  self.payload = payload;
+
+  return self;
+};
+
+Module.prototype.main = function () {
+  const self = this;
+  const Manager = self.Manager;
+  const assistant = self.assistant;
+  const payload = self.payload;
+
+  return new Promise(async function(resolve, reject) {
+
+    assistant.log('User:', payload.user);
+
+    return resolve({data: {user: payload.user}});
+  });
+
+};
+
+
+module.exports = Module;