backend-manager 3.2.169 → 3.2.171

package/dist/manager/functions/core/events/firestore/on-subscription.js

@@ -0,0 +1,107 @@
+function Module() {
+  const self = this;
+}
+
+Module.prototype.init = function (Manager, payload) {
+  const self = this;
+  self.Manager = Manager;
+  self.libraries = Manager.libraries;
+  self.assistant = Manager.Assistant();
+  self.change = payload.change
+  self.context = payload.context
+
+  return self;
+};
+
+Module.prototype.main = function () {
+  const self = this;
+  const libraries = self.libraries;
+  const assistant = self.assistant;
+  const change = self.change;
+  const context = self.context;
+
+  return new Promise(async function(resolve, reject) {
+    const _ = self.Manager.require('lodash');
+
+    const dataBefore = change.before.data();
+    const dataAfter = change.after.data();
+
+    let analytics;
+    let eventType;
+
+    if (dataAfter == undefined) {
+      eventType = 'delete';
+    } else if (dataBefore && dataAfter) {
+      eventType = 'update';
+    } else if (!dataBefore && dataAfter) {
+      eventType = 'create';
+    }
+
+    assistant.log('Notification subscription write:', {
+      after: dataAfter,
+      before: dataBefore,
+      eventType: eventType,
+      resource: context.resource,
+      params: context.params,
+    });
+
+    // Delete event
+    if (eventType === 'delete') {
+      await libraries.admin.firestore().doc(`meta/stats`)
+        .update({
+          'subscriptions.total': libraries.admin.firestore.FieldValue.increment(-1),
+        })
+        .then(r => {
+          analytics = self.Manager.Analytics({
+            assistant: assistant,
+            uuid: _.get(dataBefore, 'link.user.data.uid', undefined),
+          })
+          .event({
+            name: 'notification-unsubscribe',
+            params: {},
+          });
+
+          assistant.log('Notification subscription deleted:', dataBefore);
+
+          return resolve(dataBefore);
+        })
+        .catch(e => {
+          assistant.error(e);
+          return reject(e);
+        })
+
+    // Update event
+  } else if (eventType === 'update') {
+    return resolve();
+
+    // Create event
+  } else if (eventType === 'create') {
+      await libraries.admin.firestore().doc(`meta/stats`)
+        .update({
+          'subscriptions.total': libraries.admin.firestore.FieldValue.increment(1),
+        })
+        .then(r => {
+          analytics = self.Manager.Analytics({
+            assistant: assistant,
+            uuid: _.get(dataAfter, 'link.user.data.uid', undefined),
+          })
+          .event({
+            name: 'notification-subscribe',
+            params: {},
+          });
+
+          assistant.log('Notification subscription created:', dataAfter);
+
+          return resolve(dataAfter);
+        })
+        .catch(e => {
+          assistant.error(e);
+          return reject(e);
+        })
+    }
+
+  });
+};
+
+
+module.exports = Module;

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

@@ -0,0 +1,38 @@
+let Module = {
+  init: async function (Manager, data) {
+    this.Manager = Manager;
+    this.libraries = Manager.libraries;
+    this.req = data.req;
+    this.res = data.res
+    this.assistant = Manager.Assistant({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 assistant = self.assistant;
+
+    return libraries.cors(req, res, async () => {
+      let user = await assistant.authenticate();
+
+      // Analytics
+      let analytics = self.Manager.Analytics({
+        assistant: assistant,
+        uuid: user.auth.uid,
+      })
+      .event({
+        name: 'authenticate-test',
+        params: {},
+      });
+
+      assistant.log('Request:', assistant.request.data);
+      assistant.log('Result user:', user);
+      return res.status(200).json({status: 200, user: user });
+    });
+  }
+}
+
+module.exports = Module;

package/dist/manager/functions/test/create-test-accounts.js

@@ -0,0 +1,144 @@
+let Module = {
+  init: async function (Manager, data) {
+    this.Manager = Manager;
+    this.libraries = Manager.libraries;
+    this.req = data.req;
+    this.res = data.res
+    this.assistant = Manager.Assistant({req: data.req, res: data.res});
+
+    return this;
+  },
+  main: async function() {
+    let self = this;
+    let uuid4;
+    let req = self.req;
+    let res = self.res;
+    let libraries = self.libraries;
+    let assistant = self.assistant;
+
+    return libraries.cors(req, res, async () => {
+      let user = await assistant.authenticate();
+
+      // Analytics
+      let analytics = self.Manager.Analytics({
+        assistant: assistant,
+        uuid: user.auth.uid,
+      })
+      .event({
+        name: 'create-test-accounts',
+        params: {},
+      });
+
+      let assistant = self.assistant;
+
+      let response = {
+        status: 200,
+        data: {}
+      }
+
+      // await createUser('_test.admin@test.com', '_test.admin', {roles: {admin: true}})
+      try {
+        response.data = {
+          regular: await createUser('_test.admin@test.com', '_test.admin', {roles: {admin: true}}),
+          admin: await createUser('_test.regular@test.com', '_test.regular', {roles: {}, password: '123123'}),
+        }
+      } catch (e) {
+        response.status = 500;
+        response.error = e;
+        assistant.log(e);
+        return res.status(response.status).json(response);
+      }
+
+
+      if (assistant.isDevelopment()) {
+        assistant.log(response);
+        return res.status(response.status).json(response);
+      } else {
+        response.data = {};
+        return res.status(response.status).json(response);
+      }
+
+      async function deleteUser(uid) {
+        let currentUid;
+        return new Promise(async function(resolve, reject) {
+          // await libraries.admin.auth().getUserByEmail(email)
+          // .then(function(userRecord) {
+          //   // See the UserRecord reference doc for the contents of userRecord.
+          //   currentUid = userRecord.toJSON().uid;
+          //   // assistant.log('Successfully fetched user data:', userRecord.toJSON());
+          // })
+          // .catch(function(error) {
+          //   // assistant.log('Error fetching user data:', error);
+          // });
+
+          await libraries.admin.auth().deleteUser(uid)
+          .then(function() {
+            // assistant.log('Successfully deleted user', currentUid);
+            resolve();
+          })
+          .catch(function(error) {
+            // assistant.log('Error deleting user:', currentUid, error);
+            resolve();
+          });
+        });
+      }
+
+      async function createUser(email, uid, options) {
+        uuid4 = uuid4 || require('uuid/v4');
+        options = options || {};
+        options.password = options.password || uuid4();
+        options.roles = options.roles || {};
+
+        let result = {};
+        return new Promise(async function(resolve, reject) {
+          await deleteUser(uid);
+          libraries.admin.auth().createUser({
+            uid: uid,
+            email: email,
+            password: options.password,
+          })
+          .then(async function(updatedUser) {
+            // See the UserRecord reference doc for the contents of userRecord.
+            result = {
+              uid: uid,
+              email: email,
+              password: options.password
+            };
+
+            let SignUpHandler = require('../core/actions/sign-up-handler.js');
+            SignUpHandler.init(Manager, {
+              req: req,
+              res: res,
+            })
+
+            SignUpHandler.signUp({
+              auth: {
+                uid: uid,
+                email: email,
+              },
+              roles: options.roles,
+            })
+            .then(function(data) {
+              assistant.log('Successfully created new user:', uid);
+              resolve(result);
+            })
+            .catch(function(error) {
+              assistant.log('Error adding to db:', error);
+              reject(error);
+            });
+          })
+          .catch(function(error) {
+            assistant.log('Error creating new user:', error);
+            reject(error);
+          });
+        });
+      }
+
+    });
+
+  },
+  other: async function () {
+
+  }
+}
+module.exports = Module;

package/dist/manager/functions/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.assistant = Manager.Assistant({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 assistant = self.assistant;
+
+    return libraries.cors(req, res, async () => {
+      let user = await assistant.authenticate();
+
+      // Analytics
+      let analytics = self.Manager.Analytics({
+        assistant: assistant,
+        uuid: user.auth.uid,
+      })
+      .event({
+        name: 'webhook-test',
+        params: {},
+      });
+
+      assistant.log(assistant.request);
+      return res.status(200).json({status: 200, request: assistant.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)
+    });
+
+  }
+}

package/dist/manager/helpers/analytics copy.js

@@ -0,0 +1,217 @@
+// const ua = require('universal-analytics');
+const get = require('lodash/get');
+const fetch = require('wonderful-fetch');
+
+const uuidRegex = /[0-9a-fA-F]{8}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{12}/;
+let uuidv5;
+
+const BLACKLISTED_USER_AGENTS = new RegExp([
+  /(node-fetch)/,
+].map(r => r.source).join(''));
+
+function Analytics(Manager, options) {
+  let self = this;
+  self.Manager = Manager;
+  // self._request = self.Manager._inner || {};
+
+  // Set id and secret
+  // const analyticsId = get(self.Manager, 'config.google_analytics.id', undefined);
+  self.analyticsId = self?.Manager?.config?.google_analytics?.id;
+  self.analyticsSecret = self?.Manager?.config?.google_analytics?.secret;
+
+  // Fix options
+  options = options || {};
+
+  // Set properties
+  self._assistant = options.assistant || Manager.Assistant();
+  self._request = {
+    ip: get(self._assistant, 'request.geolocation.ip', '127.0.0.1'),
+    country: get(self._assistant, 'request.geolocation.country', ''),
+    referrer: get(self._assistant, 'request.referrer', ''),
+    userAgent: get(self._assistant, 'request.client.userAgent', ''),
+    name: get(self._assistant, 'meta.name', ''),
+  }
+
+  self._request.userAgent = self._request.userAgent.match(BLACKLISTED_USER_AGENTS) ? '' : self._request.userAgent;
+
+  self._ds = 'app';
+  self._uuid = options.uuid || self._request.ip || self.Manager.SERVER_UUID;
+  self._uuid = self._uuid.match(uuidRegex) ? self._uuid : self.generateId(self._uuid);
+  self._debug = typeof options.debug === 'undefined' ? (self.Manager.assistant.isDevelopment()) : options.debug;
+  self._pageview = typeof options.pageview === 'undefined' ? true : options.pageview;
+  self._version = self.Manager.package.version;
+  self._initialized = false;
+
+  if (!self.analyticsId) {
+    console.log('Not initializing because missing analyticsId', self.analyticsId);
+    return self;
+  } else if (!self.analyticsSecret) {
+    console.log('Not initializing because missing analyticsSecret', self.analyticsSecret);
+    return self;
+  }
+
+  // self.user = ua(self.analyticsId, self._uuid, {
+  //   strictCidFormat: false, // https://analytics.google.com/analytics/web/#/report-home/a104885300w228822596p215709578
+  // });
+  // self.user.set('ds', 'app');
+
+  // // https://developers.google.com/analytics/devguides/collection/protocol/v1/parameters#sc
+  // if (self._uuid) {
+  //   self.user.set('uid', self._uuid);
+  // }
+  // if (self._request.ip) {
+  //   self.user.set('uip', encodeURIComponent(self._request.ip));
+  // }
+  // if (self._request.userAgent) {
+  //   self.user.set('ua', encodeURIComponent(self._request.userAgent));
+  // }
+  // if (self._request.referrer) {
+  //   self.user.set('dr', encodeURIComponent(self._request.referrer));
+  // }
+
+  self._initialized = true;
+
+  if (self._pageview) {
+    self.pageview({
+      path: self._request.name,
+      location: self._request.name,
+      host: self._request.name,
+      title: self._request.name,
+    })
+  }
+
+  return self;
+}
+
+Analytics.prototype.generateId = function (id) {
+  let self = this;
+  uuidv5 = uuidv5 || require('uuid').v5;
+  let namespace = get(self.Manager, 'config.backend_manager.namespace', undefined);
+
+  return id && namespace ? uuidv5(id, namespace) : undefined;
+};
+
+Analytics.prototype.pageview = function (options) {
+  let self = this;
+  options = options || {};
+  options.path = options.path || self._request.name;
+  options.location = options.location || self._request.name;
+  options.host = options.host || self._request.name;
+  options.title = options.title || self._request.name;
+
+  if (!self._initialized) {
+    return self;
+  } else if (self._debug) {
+    console.log('Skipping Analytics.pageview() because in development', self._uuid, options);
+    return self;
+  }
+
+  // self.user.pageview({
+  //   dp: options.path,
+  //   dl: options.location,
+  //   dh: options.host,
+  //   dt: options.title,
+  // }).send();
+
+  self.send();
+
+  return self;
+};
+
+Analytics.prototype.event = function (options) {
+  let self = this;
+  options = options || {};
+  options.category = options.category;
+  options.action = options.action;
+  options.label = options.label;
+  options.value = options.value;
+  options.path = options.path || self._request.name;
+
+  if (!self._initialized) {
+    return self;
+  } else if (self._debug) {
+    console.log('Skipping Analytics.event() because in development', self._uuid, options);
+    return self;
+  }
+
+  // self.user.event({
+  //   ec: options.category,
+  //   ea: options.action,
+  //   el: options.label,
+  //   ev: options.value,
+  //   // dp: options.path || window.location.href,
+  // }).send();
+
+  self.send({
+    name: 'tutorial_begin',
+    params: {
+      campaign_id: 'google_1234',
+      campaign: 'Summer_fun',
+      source: 'google',
+      medium: 'cpc',
+      term: 'summer+travel',
+      content: 'logolink',
+      session_id: '123',
+      engagement_time_msec: '100',
+    }
+  });
+
+  return self;
+};
+
+Analytics.prototype.send = function (event) {
+  let self = this;
+
+  if (!self._initialized) {
+    return self;
+  } else if (self._debug) {
+    console.log('Skipping Analytics.event() because in development', self._uuid, options);
+    return self;
+  }
+
+  // self.user = ua(self.analyticsId, self._uuid, {
+  //   strictCidFormat: false, // https://analytics.google.com/analytics/web/#/report-home/a104885300w228822596p215709578
+  // });
+  // self.user.set('ds', 'app');
+
+  // // https://developers.google.com/analytics/devguides/collection/protocol/v1/parameters#sc
+  // if (self._uuid) {
+  //   self.user.set('uid', self._uuid);
+  // }
+  // if (self._request.ip) {
+  //   self.user.set('uip', encodeURIComponent(self._request.ip));
+  // }
+  // if (self._request.userAgent) {
+  //   self.user.set('ua', encodeURIComponent(self._request.userAgent));
+  // }
+  // if (self._request.referrer) {
+  //   self.user.set('dr', encodeURIComponent(self._request.referrer));
+  // }
+
+  /*
+    https://stackoverflow.com/questions/68773179/what-should-the-client-id-be-when-sending-events-to-google-analytics-4-using-the
+    https://developers.google.com/analytics/devguides/collection/protocol/ga4/sending-events?client_type=gtag
+
+
+  */
+
+  // Send event
+  fetch(`https://www.google-analytics.com/mp/collect?measurement_id=${self.analyticsId}&api_secret=${self.analyticsSecret}`, {
+    method: 'post',
+    body: {
+      client_id: self._uuid,
+      user_id: self._uuid,
+      events: [event],
+    },
+  })
+  .then((r) => {
+    console.log('Analytics.send(): Sent', r);
+  })
+  .catch((e) => {
+    console.error('Analytics.send(): Error sending', e);
+  });
+
+  return self;
+};
+
+module.exports = Analytics;