npm - backend-manager - Versions diffs - 3.2.170 → 3.2.172 - Mend

backend-manager 3.2.170 → 3.2.172

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (88) hide show

package/dist/manager/functions/core/actions/api/admin/send-notification.js ADDED Viewed

@@ -0,0 +1,197 @@
+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.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 up response obj
+    payload.response.data = {
+      subscribers: 0,
+      batches: 0,
+      sent: 0,
+      deleted: 0,
+    }
+    // Fix notification payload
+    self._notificationPayload = {
+      notification: self.payload.data.payload.notification || {},
+    };
+    self._notificationPayload.notification.title = self.payload.data.payload.title || self.payload.data.payload.notification.title || 'Notification';
+    self._notificationPayload.notification.click_action = self.payload.data.payload.click_action || self.payload.data.payload.notification.click_action || 'https://itwcreativeworks.com';
+    self._notificationPayload.notification.body = self.payload.data.payload.body || self.payload.data.payload.notification.body || 'Check this out';
+    self._notificationPayload.notification.icon = self.payload.data.payload.icon || self.payload.data.payload.notification.icon || self.Manager.config.brand.brandmark || 'https://cdn.itwcreativeworks.com/assets/itw-creative-works/images/socials/itw-creative-works-brandmark-square-black-1024x1024.png';
+    try {
+      self._notificationPayload.notification.click_action = new URL(self._notificationPayload.notification.click_action);
+      self._notificationPayload.notification.click_action.searchParams.set('cb', new Date().getTime())
+      self._notificationPayload.notification.click_action = self._notificationPayload.notification.click_action.toString()
+    } catch (e) {
+      assistant.errorify(`Failed to add cb to URL: ${e}`, {code: 500, log: true});
+    }
+    assistant.log('Resolved notification payload', self._notificationPayload)
+    if (!payload.user.roles.admin) {
+      return reject(assistant.errorify(`Admin required.`, {code: 401}));
+    }
+    if (!payload.data.payload.title || !payload.data.payload.body) {
+      return reject(assistant.errorify(`Parameters <title> and <body> required`, {code: 400, sentry: true}));
+    }
+    await self.getTokens({tags: false})
+    .then(r => {
+      return resolve({data: payload.response.data})
+    })
+    .catch(e => {
+      return reject(assistant.errorify(`Failed to send notification: ${e}`, {code: 400, sentry: true}));
+    })
+  });
+};
+// 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.payload.response.data.subscribers = querySnapshot.size;
+        // 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;
+            self.payload.response.data.batches++;
+          }
+          batchLoops++;
+        });
+      })
+      .catch(function(e) {
+        self.assistant.error('Error querying tokens: ', e)
+        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)
+      });
+    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);
+    await self.libraries.admin.messaging().sendToDevice(batch, self._notificationPayload)
+      .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);
+        }
+        self.payload.response.data.sent += (batch.length - response.failureCount);
+        resolve();
+      })
+      .catch(function (e) {
+        self.assistant.error('Error sending batch #' + id, e);
+        // 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}`);
+        self.payload.response.data.deleted++;
+        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/dist/manager/functions/core/actions/api/admin/sync-users.js ADDED Viewed

@@ -0,0 +1,125 @@
+const {get, merge} = require('lodash');
+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) {
+    // If the user is not an admin, reject
+    if (!payload.user.roles.admin && assistant.isProduction()) {
+      return reject(assistant.errorify(`Admin required.`, {code: 401}));
+    }
+    // Get lastPageToken from meta/stats
+    self.libraries.admin.firestore().doc(`meta/stats`)
+      .get()
+      .then(async (doc) => {
+        const data = doc.data() || {};
+        const lastPageToken = get(data, 'syncUsers.lastPageToken', undefined);
+        let processedUsers = 0;
+        // Initial pageToken
+        assistant.log(`Running syn-users based on lastPageToken: ${lastPageToken}`);
+        // List firebase auth users
+        await Manager.Utilities().iterateUsers(function (batch, index) {
+          return new Promise(async function(resolve, reject) {
+            // Process user function
+            async function _process(user, i) {
+              const account = user.toJSON();
+              const uid = account.uid;
+              const email = account.email;
+              const created = new Date(account.metadata.creationTime);
+              const activity = new Date(account.metadata.lastSignInTime);
+              const isAnonymous = account.providerData.length === 0;
+              // Skip anonymous users
+              if (isAnonymous) {
+                return
+              }
+              // Add the user to the database only if it doesn't exist
+              await self.libraries.admin.firestore().doc(`users/${account.uid}`)
+                .get()
+                .then(async (doc) => {
+                  const data = doc.data() || {};
+                  const newUser = Manager.User({
+                    auth: {
+                      uid: uid,
+                      email: email,
+                    },
+                    activity: {
+                      created: {
+                        timestamp: created.toISOString(),
+                        timestampUNIX: Math.floor(created.getTime() / 1000),
+                      },
+                      lastActivity: {
+                        timestamp: activity.toISOString(),
+                        timestampUNIX: Math.floor(activity.getTime() / 1000),
+                      },
+                    }
+                  });
+                  const finalData = merge(newUser.properties, data);
+                  // Set metadata
+                  finalData.metadata = Manager.Metadata().set({tag: 'admin:sync-users'});
+                  // Save to database
+                  await self.libraries.admin.firestore().doc(`users/${account.uid}`)
+                    .set(finalData, {merge: true})
+                    .then(r => {
+                      assistant.log(`Synched user: ${account.uid}`);
+                      processedUsers++;
+                    })
+                })
+            }
+            // Process each user
+            for (var i = 0; i < batch.users.length; i++) {
+              await _process(batch.users[i], i);
+            }
+            // Save to database only if there is a page token
+            if (batch.pageToken) {
+              await self.libraries.admin.firestore().doc(`meta/stats`)
+                .update({
+                  syncUsers: {
+                    lastPageToken: batch.pageToken,
+                  }
+                })
+                .then(r => {
+                  assistant.log(`Saved lastPageToken: ${batch.pageToken}`);
+                })
+                .catch(e => {
+                  assistant.error('Failed to update lastPageToken', e);
+                })
+            }
+            return resolve();
+          })
+        }, {batchSize: 10, log: true, pageToken: lastPageToken})
+        assistant.log(`Processed ${processedUsers} users.`);
+        // Complete
+        return resolve();
+      })
+      .catch(e => {
+        return reject(assistant.errorify(e, {code: 500}));
+      })
+  });
+};
+module.exports = Module;

package/dist/manager/functions/core/actions/api/admin/templates/post.html ADDED Viewed

@@ -0,0 +1,16 @@
+---
+### ALL PAGES ###
+layout: {layout}
+### POST ONLY ###
+post:
+  title: "{title}"
+  excerpt: "{excerpt}"
+  author: {author}
+  id: {id}
+  tags: {tags}
+  categories: {categories}
+  affiliate-search-term: {affiliate}
+---
+{body}

package/dist/manager/functions/core/actions/api/firebase/get-providers.js ADDED Viewed

@@ -0,0 +1,102 @@
+const fetch = require('wonderful-fetch');
+const { merge } = require('lodash');
+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) {
+    const defaultProviders = {
+      ['password']: {
+        enabled: true,
+      },
+      ['google.com']: {
+        enabled: true,
+      },
+      ['facebook.com']: {
+        enabled: false,
+      },
+      ['twitter.com']: {
+        enabled: false,
+      },
+      ['github.com']: {
+        enabled: false,
+      },
+      ['microsoft.com']: {
+        enabled: false,
+      },
+      ['yahoo.com']: {
+        enabled: false,
+      },
+      ['apple.com']: {
+        enabled: false,
+      },
+    }
+    // Get app
+    const appObject = await self.getAppObject();
+    if (appObject instanceof Error) {
+      return reject(assistant.errorify(`Failed to get app object: ${appObject}`, {code: 500}));
+    }
+    // Merge the default providers with the app providers
+    const providers = merge(defaultProviders, appObject.authentication);
+    // Reformat the object so it's just provider=true/false
+    const finalProviders = {};
+    Object.keys(providers).forEach(key => {
+      finalProviders[key] = providers[key].enabled;
+    });
+    // Log
+    assistant.log('Providers', finalProviders);
+    // Resolve
+    return resolve({data: finalProviders});
+  });
+};
+// Get app object
+Module.prototype.getAppObject = 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) {
+    const id = Manager.config.app.id;
+    // Get the app settings
+    fetch(`https://us-central1-itw-creative-works.cloudfunctions.net/getApp`, {
+      method: 'post',
+      response: 'json',
+      body: {
+        id: id,
+      }
+    })
+    .then((r) => {
+      assistant.log('getAppObject(): Response', r);
+      // If data is missing, return an error
+      if (!r) {
+        throw new Error(`App with id ${id} not found`);
+      }
+      // Return the app object
+      return resolve(r);
+    })
+    .catch(e => reject(e));
+  });
+};
+module.exports = Module;

package/dist/manager/functions/core/actions/api/general/emails/general:download-app-link.js ADDED Viewed

@@ -0,0 +1,21 @@
+module.exports = function (payload, config) {
+  return {
+    // spamFilter: {
+    //   ip: 3,
+    //   email: 3,
+    // },
+    // delay: 30000,
+    payload: {
+      to: {
+        email: payload.email,
+        name: payload.name,
+      },
+      categories: ['download'],
+      subject: `Free ${config.brand.name} download link for ${payload.name || 'you'}!`,
+      template: 'd-1d730ac8cc544b7cbccc8fa4a4b3f9ce',
+      group: 25927,
+      copy: false,
+      data: {},
+    }
+  }
+}

package/dist/manager/functions/core/actions/api/general/fetch-post.js ADDED Viewed

@@ -0,0 +1,99 @@
+const { Octokit } = require('@octokit/rest');
+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) {
+    // Setup Octokit
+    const octokit = new Octokit({
+      auth: Manager?.config?.github?.key,
+    });
+    // Setup options
+    payload.data.payload.url = payload.data.payload.url || '';
+    // Check for required parameters
+    if (!payload.data.payload.url) {
+      return reject(assistant.errorify(`Missing required parameter: url`, {code: 400}));
+    }
+    let url;
+    try {
+      url = new URL(payload.data.payload.url);
+    } catch (e) {
+      return reject(assistant.errorify(`Invalid URL`, {code: 400}));
+    }
+    // Get the post
+    const filename = url.pathname.replace(/blog|\//ig, '')
+    const repoInfo = assistant.parseRepo(self?.Manager?.config?.github?.repo_website);
+    const query = `title+repo:${repoInfo.user}/${repoInfo.name}+filename:${filename}`;
+    assistant.log('Running search', query, repoInfo);
+    // Using octokit, search the repo for the file matching the url
+    // https://stackoverflow.com/questions/25564760/how-can-i-search-file-name-in-specific-github-repository
+    // https://docs.github.com/en/search-github/searching-on-github/searching-code#search-by-filename
+    const results = await octokit.rest.search.code({
+      q: query,
+    }).catch(e => e);
+    // Log
+    assistant.log('Results', results);
+    // Check for errors
+    if (results instanceof Error) {
+      return reject(assistant.errorify(`Error searching for post: ${results}`, {code: 500}));
+    } else if (results?.data?.total_count === 0) {
+      return reject(assistant.errorify(`Post not found`, {code: 404}));
+    }
+    // Get the first results
+    const firstResult = results.data.items[0];
+    // Fetch the content of the post
+    const post = await octokit.rest.repos.getContent({
+      owner: repoInfo.user,
+      repo: repoInfo.name,
+      path: firstResult.path,
+    }).catch(e => e);
+    // Log
+    assistant.log('Post', post);
+    // Check for errors
+    if (post instanceof Error) {
+      return reject(assistant.errorify(`Error fetching post: ${post}`, {code: 500}));
+    }
+    // Decode the content
+    const fullContent = Buffer.from(post.data.content, 'base64').toString();
+    const splitContent = fullContent.split('---');
+    const frontmatter = splitContent[1].trim();
+    const body = splitContent.slice(2).join('---').trim();
+    // Return
+    return resolve({
+      data: {
+        name: post.data.name,
+        path: post.data.path,
+        size: post.data.size,
+        sha: post.data.sha,
+        frontmatter: frontmatter,
+        body: body,
+      }
+    });
+  });
+};
+module.exports = Module;

package/dist/manager/functions/core/actions/api/general/generate-uuid.js ADDED Viewed

@@ -0,0 +1,41 @@
+const uuid = require('uuid');
+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) {
+    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.errorify(`You must provide a name to hash for uuid v5.`, {code: 400}));
+      } else {
+        result = uuid.v5(payload.data.payload.name, payload.data.payload.namespace);
+      }
+    } else if (payload.data.payload.version === '4') {
+      result = uuid.v4();
+    } else {
+      return reject(assistant.errorify(`v${payload.data.payload.version} is not a valid version.`, {code: 400}));
+    }
+    assistant.log('UUID Generated', payload.data.payload, result);
+    return resolve({data: {uuid: result}});
+  });
+};
+module.exports = Module;