@omega.js/backend 0.1.0

package/dist/manager/functions/_legacy/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.ctx = Manager.RouteContext({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 ctx = self.ctx;
+    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 ctx.authenticate();
+
+      // Analytics
+      let analytics = self.Manager.Analytics({
+        ctx: ctx,
+        uuid: user.auth.uid,
+      })
+      .event({
+        category: 'admin',
+        action: 'query',
+        // label: '',
+      });
+
+      if (!user.roles.admin) {
+        response.status = 401;
+        response.error = new Error('Unauthenticated, admin required.');
+        ctx.error(response.error)
+      } else {
+        self.docs = [];
+        // ctx.log('Queries', ctx.request.data.queries);
+        let queries = powertools.arrayify(ctx.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;
+            // ctx.log('Query result:', );
+          })
+          .catch((e) => {
+            response.error = e;
+            response.status = 400;
+            ctx.error(response.error)
+          })
+      }
+
+      ctx.log('Query', ctx.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.ctx.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.ctx.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/_legacy/admin/send-notification.js

@@ -0,0 +1,206 @@
+let Module = {
+  init: async function (Manager, data) {
+    this.Manager = Manager;
+    this.libraries = Manager.libraries;
+    this.ctx = Manager.RouteContext({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 ctx = self.ctx;
+    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 ctx.authenticate();
+
+      // Analytics
+      let analytics = self.Manager.Analytics({
+        ctx: ctx,
+        uuid: user.auth.uid,
+      })
+      .event({
+        category: 'admin',
+        action: 'send-notification',
+        // label: '',
+      });
+
+      let payload = self.ctx.request.data.payload || {};
+
+      if (!payload.title || !payload.body) {
+        response.status = 400;
+        response.error = new Error('Not enough notification parameters supplied.');
+        ctx.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.');
+        ctx.error(response.error)
+        return res.status(response.status).send(response.error.message);
+      } else {
+        await self.getTokens({tags: false});
+      }
+
+      ctx.log('Notification', ctx.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.ctx.log(`Sending batch ID: ${id}`, batch);
+  self.ctx.log(`Sending batch ID: ${id}`);
+
+  // self.ctx.log('payload', payload);
+  return new Promise(async function(resolve, reject) {
+    let payload = {};
+    payload.notification = {};
+    payload.notification.title = self.ctx.request.data.payload.title;
+    payload.notification.click_action = self.ctx.request.data.payload.click_action;
+    payload.notification.body = self.ctx.request.data.payload.body;
+    payload.notification.icon = self.ctx.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.ctx.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.ctx.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.ctx.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.ctx.error('Error querying tokens: ', e)
+        reject(error);
+      });
+
+    await Promise.all(batchPromises)
+      .then(function(values) {
+        self.ctx.log('Finished all batches.');
+      })
+      .catch(function(e) {
+        self.ctx.error('Error sending batches: ', e)
+      });
+    resolve();
+
+  });
+}
+
+function cleanTokens(batch, results, id) {
+  let self = this;
+  let cleanPromises = [];
+  // self.ctx.log(`Cleaning tokens of batch ID: ${id}`, results);
+  self.ctx.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.ctx.log(`Found bad token: ${index} = ${curCode}`);
+      if (badTokenReasons.includes(curCode)) {
+        cleanPromises.push(self.deleteToken(token, curCode));
+      }
+    })
+    await Promise.all(cleanPromises)
+      .catch(function(e) {
+        self.ctx.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.ctx.log(`Deleting bad token: ${token} for reason ${errorCode}`);
+        resolve();
+      })
+      .catch(function(error) {
+        self.ctx.log('error', `Error deleting bad token: ${token} for reason ${errorCode} because of error ${error}`);
+        resolve();
+      })
+  });
+}

package/dist/manager/functions/_legacy/template.js

@@ -0,0 +1,33 @@
+function Module() {
+
+}
+
+Module.prototype.main = function () {
+  const self = this;
+  const Manager = self.Manager;
+  const Api = self.Api;
+  const ctx = self.ctx;
+  const payload = self.payload;
+
+  return new Promise(async function(resolve, reject) {
+
+    if (!payload.user.roles.admin) {
+      return reject(ctx.report(`Admin required.`, {code: 401}));
+    }
+
+    // self.Api.resolveUser({adminRequired: false})
+    // .then(async (user) => {
+    //
+    // })
+    // .catch(e => {
+    //   return reject(e);
+    // })
+
+    return resolve({data: {success: true}});
+
+  });
+
+};
+
+
+module.exports = Module;

package/dist/manager/functions/_legacy/test/authenticate.js

@@ -0,0 +1,40 @@
+const { projectUserForLog } = require('../../../helpers/middleware.js');
+
+let Module = {
+  init: async function (Manager, data) {
+    this.Manager = Manager;
+    this.libraries = Manager.libraries;
+    this.req = data.req;
+    this.res = data.res
+    this.ctx = Manager.RouteContext({req: data.req, res: data.res}, {accept: 'json'});
+
+    return this;
+  },
+  main: async function() {
+    let self = this;
+    let req = self.req;
+    let res = self.res;
+    let libraries = self.libraries;
+    let ctx = self.ctx;
+
+    return libraries.cors(req, res, async () => {
+      let user = await ctx.authenticate();
+
+      // Analytics
+      let analytics = self.Manager.Analytics({
+        ctx: ctx,
+        uuid: user.auth.uid,
+      })
+      .event({
+        name: 'authenticate-test',
+        params: {},
+      });
+
+      ctx.log('Request:', ctx.request.data);
+      ctx.log('Result user:', projectUserForLog(user));
+      return res.status(200).json({status: 200, user: user });
+    });
+  }
+}
+
+module.exports = Module;

package/dist/manager/functions/_legacy/test/webhook.js

@@ -0,0 +1,37 @@
+let Module = {
+  init: async function (Manager, data) {
+    this.Manager = Manager;
+    this.libraries = Manager.libraries;
+    this.req = data.req;
+    this.res = data.res
+    this.ctx = Manager.RouteContext({req: data.req, res: data.res});
+
+    return this;
+  },
+  main: async function() {
+    let self = this;
+    let req = self.req;
+    let res = self.res;
+    let libraries = self.libraries;
+    let ctx = self.ctx;
+
+    return libraries.cors(req, res, async () => {
+      let user = await ctx.authenticate();
+
+      // Analytics
+      let analytics = self.Manager.Analytics({
+        ctx: ctx,
+        uuid: user.auth.uid,
+      })
+      .event({
+        name: 'webhook-test',
+        params: {},
+      });
+
+      ctx.log(ctx.request);
+      return res.status(200).json({status: 200, request: ctx.request.data});
+    });
+  }
+}
+
+module.exports = Module;

package/dist/manager/functions/wrappers/mailchimp/addToList.js

@@ -0,0 +1,25 @@
+let Module = {
+  main: async function () {
+
+  },
+  addToList: async function () {
+    return new Promise(function(resolve, reject) {
+      // let Mailchimp = require('mailchimp-api-v3');
+      // let mailchimp = new Mailchimp(this.ref.functions.config().mailchimp.key);
+      // mailchimp.request({
+      //   method : 'get|post|put|patch|delete',
+      //   path : 'path for the call, see mailchimp documentation for possible calls',
+      //   path_params : {
+      //     //path parameters, see mailchimp documentation for each call
+      //   },
+      //   body : {
+      //     //body parameters, see mailchimp documentation for each call
+      //   },
+      //   query : {
+      //     //query string parameters, see mailchimp documentation for each call
+      //   }
+      // }, callback)
+    });
+
+  }
+}