backend-manager 1.1.103 → 2.0.0

package/src/manager/functions/core/actions/api/test/create-test-accounts.js

@@ -0,0 +1,36 @@
+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)
+    }
+
+    assistant.log('User:', payload.user);
+
+    return resolve({data: {user: user}});
+
+  });
+
+};
+
+
+module.exports = Module;

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

@@ -0,0 +1,35 @@
+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.data.payload.status >= 200 && payload.data.payload.status <= 299) {
+      return resolve({data: payload.data.payload.response, status: payload.data.payload.status});
+    } else if (payload.data.payload.status >= 400 && payload.data.payload.status <= 599) {
+      return reject(assistant.errorManager(payload.data.payload.response || 'Unknown error message provided', {code: payload.data.payload.status, sentry: false, send: false, log: false}).error)
+    }
+
+  });
+
+};
+
+
+module.exports = Module;

package/src/manager/functions/core/actions/api/user/create-custom-token.js

@@ -0,0 +1,63 @@
+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) {
+    let user = null;
+    if (payload.user.roles.admin && payload.data.payload.uid) {
+      await self.libraries.admin.firestore().doc(`users/${payload.data.payload.uid}`)
+      .get()
+      .then(async function (doc) {
+        const data = doc.data();
+        if (data) {
+          user = data;
+        } else {
+          throw new Error('User does not exist')
+        }
+      })
+      .catch(function (e) {
+        user = e;
+      })
+    } else if (payload.user.authenticated) {
+      user = payload.user;
+    }
+
+    if (user instanceof Error) {
+      return reject(assistant.errorManager(user, {code: 400, sentry: false, send: false, log: false}).error)
+    } else if (!user) {
+      return reject(assistant.errorManager(`Admin or authenticated user required.`, {code: 401, sentry: false, send: false, log: false}).error)
+    } else {
+
+      await self.libraries.admin.auth().createCustomToken(_.get(user, 'auth.uid', null))
+      .then(token => {
+        return resolve({data: {token: token}});
+      })
+      .catch(e => {
+        return reject(assistant.errorManager(`Failed to create custom token: ${e}`, {code: 400, sentry: false, send: false, log: false}).error)
+      })
+    }
+
+  });
+
+};
+
+
+module.exports = Module;

package/src/manager/functions/core/actions/api/user/delete.js

@@ -0,0 +1,73 @@
+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) {
+    let user = null;
+    if (payload.user.roles.admin && payload.data.payload.uid) {
+      await self.libraries.admin.firestore().doc(`users/${payload.data.payload.uid}`)
+      .get()
+      .then(async function (doc) {
+        const data = doc.data();
+        if (data) {
+          user = data;
+        } else {
+          throw new Error('User does not exist')
+        }
+      })
+      .catch(function (e) {
+        user = e;
+      })
+    } else if (payload.user.authenticated) {
+      user = payload.user;
+    }
+
+    if (user instanceof Error) {
+      return reject(assistant.errorManager(user, {code: 400, sentry: false, send: false, log: false}).error)
+    } else if (!user) {
+      return reject(assistant.errorManager(`Admin or authenticated user required.`, {code: 401, sentry: false, send: false, log: false}).error)
+    } else {
+      // const planExpireDate = new Date(_.get(payload.user, 'plan.expires.timestamp', 0));
+      // if (planExpireDate >= new Date()) {
+      //   payload.response.status = 401;
+      //   payload.response.error = new Error(`Failed to delete user: There is an active paid subscription on this account. Please cancel it first and then try deleting the account again.`);
+      //   return reject(payload.response.error);
+      // }
+      const isPlanActive = _.get(user, 'plan.payment.active', null);
+      if (isPlanActive === true) {
+        return reject(assistant.errorManager(`Failed to delete user: There is an active paid subscription on this account. Please cancel it first and then try deleting the account again.`, {code: 400, sentry: false, send: false, log: false}).error)
+      }
+
+      await self.libraries.admin.auth().deleteUser(_.get(user, 'auth.uid', null))
+      .then(() => {
+        return resolve({data: {success: true}});
+      })
+      .catch(e => {
+        return reject(assistant.errorManager(`Failed to delete user: ${e}`, {code: 400, sentry: false, send: false, log: false}).error)
+      })
+    }
+
+  });
+
+};
+
+
+module.exports = Module;

package/src/manager/functions/core/actions/api/user/get-subscription-info.js

@@ -0,0 +1,63 @@
+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) {
+    let user = null;
+    if (payload.user.roles.admin && payload.data.payload.uid) {
+      await self.libraries.admin.firestore().doc(`users/${payload.data.payload.uid}`)
+      .get()
+      .then(async function (doc) {
+        const data = doc.data();
+        if (data) {
+          user = data;
+        } else {
+          throw new Error('User does not exist')
+        }
+      })
+      .catch(function (e) {
+        user = e;
+      })
+    } else if (payload.user.authenticated) {
+      user = payload.user;
+    }
+
+    if (user instanceof Error) {
+      return reject(assistant.errorManager(user, {code: 400, sentry: false, send: false, log: false}).error)
+    } else if (!user) {
+      return reject(assistant.errorManager(`Admin or authenticated user required.`, {code: 401, sentry: false, send: false, log: false}).error)
+    } else {
+      const result = {
+        plan: {
+          id: _.get(user, 'plan.id', 'unknown'),
+          payment: {
+            active: _.get(user, 'plan.payment.active', false),
+          },
+        }
+      }
+      return resolve({data: result});
+    }
+  });
+
+};
+
+
+module.exports = Module;

package/src/manager/functions/core/actions/api/user/sign-out-all-sessions.js

@@ -0,0 +1,86 @@
+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) {
+    let user = null;
+    if (payload.user.roles.admin && payload.data.payload.uid) {
+      await self.libraries.admin.firestore().doc(`users/${payload.data.payload.uid}`)
+      .get()
+      .then(async function (doc) {
+        const data = doc.data();
+        if (data) {
+          user = data;
+        } else {
+          throw new Error('User does not exist')
+        }
+      })
+      .catch(function (e) {
+        user = e;
+      })
+    } else if (payload.user.authenticated) {
+      user = payload.user;
+    }
+
+    if (user instanceof Error) {
+      return reject(assistant.errorManager(user, {code: 400, sentry: false, send: false, log: false}).error)
+    } else if (!user) {
+      return reject(assistant.errorManager(`Admin or authenticated user required.`, {code: 401, sentry: false, send: false, log: false}).error)
+    } else {
+      const uid = _.get(user, 'auth.uid', null);
+
+      await self.libraries.admin.database().ref(`gatherings/online`)
+      .orderByChild('uid')
+      .equalTo(uid)
+      .once('value')
+      .then(async snap => {
+        const data = snap.val();
+        const keys = Object.keys(data || {});
+        for (var i = 0; i < keys.length; i++) {
+          const key = keys[i];
+          self.assistant.log(`Signing out: ${key}`, {environment: 'production'});
+          await self.libraries.admin.database().ref(`gatherings/online/${key}/command`).set('signout').catch(e => self.assistant.error(`Failed to signout ${key}`, e))
+          await powertools.wait(3000);
+          await self.libraries.admin.database().ref(`gatherings/online/${key}`).remove().catch(e => self.assistant.error(`Failed to delete ${key}`, e))
+        }
+      })
+      .catch(e => {
+        console.error('Gathering query error', e);
+      })
+
+      await self.libraries.admin
+        .auth()
+        .revokeRefreshTokens(uid)
+        .then(() => {
+          return resolve({data: {message: `Successfully signed ${uid} out of all sessions`}});
+        })
+        .catch(e => {
+          return reject(assistant.errorManager(`Failed to sign out of all sessions: ${e}`, {code: 500, sentry: false, send: false, log: false}).error)
+        })
+
+    }
+
+  });
+
+};
+
+
+module.exports = Module;

package/src/manager/functions/core/actions/api/user/sign-up.js

@@ -0,0 +1,241 @@
+const _ = require('lodash')
+const fetch = require('node-fetch');
+
+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 user = null;
+    if (payload.user.roles.admin && payload.data.payload.uid) {
+      await self.libraries.admin.firestore().doc(`users/${payload.data.payload.uid}`)
+      .get()
+      .then(async function (doc) {
+        const data = doc.data();
+        if (data) {
+          user = data;
+        } else {
+          throw new Error('User does not exist')
+        }
+      })
+      .catch(function (e) {
+        user = e;
+      })
+    } else if (payload.user.authenticated) {
+      user = payload.user;
+    }
+
+    if (user instanceof Error) {
+      return reject(assistant.errorManager(user, {code: 400, sentry: false, send: false, log: false}).error)
+    } else if (!user) {
+      return reject(assistant.errorManager(`Admin or authenticated user required.`, {code: 401, sentry: false, send: false, log: false}).error)
+    } else {
+
+      await self.signUp({
+        auth: {
+          uid: _.get(user, 'auth.uid', null),
+          email: _.get(user, 'auth.email', null),
+        },
+        affiliate: {
+          referrer: _.get(payload.data.payload, 'affiliateCode', null),
+        },
+      })
+      .then(async function (result) {
+        if (_.get(payload.data.payload, 'newsletterSignUp', false)) {
+          await addToMCList(
+            _.get(Manager.config, 'mailchimp.key'),
+            _.get(Manager.config, 'mailchimp.list_id'),
+            _.get(user, 'auth.email', null),
+          )
+          .then(function (res) {
+            assistant.log('Sucessfully added user to MC list.')
+          })
+          .catch(function (e) {
+            assistant.log('Failed to add user to MC list.', e)
+          })
+        }
+        return resolve({data: result});
+      })
+      .catch(function (e) {
+        return reject(assistant.errorManager(`Failed to sign up: ${e}`, {code: 500, sentry: false, send: false, log: false}).error)
+      })
+
+    }
+
+  });
+
+};
+
+Module.prototype.signUp = function (payload) {
+  const self = this;
+  const result = {
+    signedUp: false,
+    referrerUid: undefined,
+    // updatedReferral: true,
+  };
+  let error;
+  payload = payload || {};
+
+  return new Promise(async function(resolve, reject) {
+    let existingUser = {};
+    let finalPayload = {};
+
+    if (!_.get(payload, 'auth.uid', null) || !_.get(payload, 'auth.email', null)) {
+      return reject(new Error('Cannot create user without UID and email.'))
+    }
+
+    await self.updateReferral({
+      affiliateCode: _.get(payload, 'affiliate.referrer', null),
+      uid: payload.auth.uid,
+    })
+    .then(r => {
+      payload.affiliate.referrer = r.referrerUid;
+      result.referrerUid = payload.affiliate.referrer;
+    })
+    .catch(function (e) {
+      payload.affiliate.referrer = undefined;
+      console.error('Failed to update affiliate code', e)
+    })
+
+    // payload.affiliate.referrer = undefined;
+
+    await self.libraries.admin.firestore().doc(`users/${payload.auth.uid}`)
+    .get()
+    .then(async function (doc) {
+      existingUser = doc.data() || {};
+    })
+    .catch(function (e) {
+      error = e;
+    })
+
+    if (error) {
+      return reject(error);
+    }
+
+    const user = self.Manager.User(payload);
+
+    // Merge the payload and the default user object
+    finalPayload = _.merge({}, existingUser, user.properties)
+
+    self.libraries.admin.firestore().doc(`users/${payload.auth.uid}`)
+    .set(finalPayload, { merge: true })
+    .then(function(data) {
+      result.signedUp = true;
+      return resolve(result);
+    })
+    .catch(function(e) {
+      return reject(e);
+    })
+
+  });
+},
+
+Module.prototype.updateReferral = function (payload) {
+  const self = this;
+  const result = {
+    count: 0,
+    updatedReferral: false,
+    referrerUid: undefined,
+  }
+  payload = payload || {};
+
+  return new Promise(function(resolve, reject) {
+    self.libraries.admin.firestore().collection('users')
+    .where('affiliate.code', '==', payload.affiliateCode)
+    .get()
+    .then(async (snapshot) => {
+      if (snapshot.empty) {
+        return resolve(result)
+      }
+      let count = 0;
+      let found = false;
+      let error = null;
+
+      for (var i = 0; i < snapshot.size; i++) {
+        const doc = snapshot.docs[i];
+        if (!found) {
+          let data = doc.data() || {};
+
+          let referrals = data.affiliate && data.affiliate.referrals ? data.affiliate.referrals : [];
+          referrals = Array.isArray(referrals) ? referrals : [];
+          count = referrals.length;
+          referrals = referrals.concat({
+            uid: payload.uid,
+            timestamp: self.assistant.meta.startTime.timestamp,
+          })
+
+          await self.libraries.admin.firestore().doc(`users/${doc.id}`)
+          .set({
+            affiliate: {
+              referrals: referrals
+            }
+          }, {merge: true})
+          .catch(e => {
+            console.error('Error updating referral', e);
+            error = e;
+          })
+
+          result.count = count;
+          result.updatedReferral = true;
+          result.referrerUid = doc.id
+          found = true
+        }
+      }
+      if (error) {
+        return reject(error);
+      }
+      return resolve(result)
+    })
+    .catch(e => {
+      return reject(e);
+    });
+  });
+}
+
+function addToMCList(key, listId, email) {
+  return new Promise((resolve, reject) => {
+    let datacenter = key.split('-')[1];
+    fetch(`https://${datacenter}.api.mailchimp.com/3.0/lists/${listId}/members`, {
+        method: 'post',
+        body: JSON.stringify({
+          email_address: email,
+          status: 'subscribed',
+        }),
+        timeout: 10000,
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Basic ${key}`,
+        },
+      })
+      .then(res => res.json())
+      .then(json => {
+        if (json.status !== 'subscribed') {
+          return reject(new Error(json.status));
+        }
+        return resolve(json);
+      })
+      .catch(e => {
+        return reject(e);
+      })
+
+  });
+}
+
+
+module.exports = Module;