@omega.js/backend 0.1.0

package/dist/manager/functions/_legacy/actions/sign-up-handler.js

@@ -0,0 +1,205 @@
+let fetch;
+const { merge } = require('lodash');
+
+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: {},
+    };
+
+
+    return libraries.cors(req, res, async () => {
+      let user = await ctx.authenticate();
+
+      if (!user.authenticated) {
+        response.status = 401;
+        response.error = new Error('Account does not exist in Auth.');
+      } else {
+        await self.signUp({
+          auth: {
+            uid: user.auth.uid,
+            email: user.auth.email,
+          },
+          affiliate: {
+            referredBy: ctx.request.data.affiliateCode
+          },
+        })
+        .then(async function (result) {
+          response.data = result;
+          if (ctx.request.data.newsletterSignUp) {
+            await addToMCList(
+              self.Manager.config?.mailchimp?.key,
+              self.Manager.config?.mailchimp?.list_id,
+              user.auth.email,
+            )
+            .then(function (res) {
+              ctx.log('Sucessfully added user to MC list.')
+            })
+            .catch(function (error) {
+              ctx.log('Failed to add user to MC list.', error)
+            })
+          }
+        })
+        .catch(function (e) {
+          response.status = 400;
+          response.error = e;
+          ctx.error('Failed to signup:', response.error);
+        })
+      }
+
+      ctx.log('Signup handler:', ctx.request.data, response);
+
+      if (response.status === 200) {
+        return res.status(response.status).json(response.data);
+      } else {
+        ctx.error('Failed to signup:', ctx.request.data, user);
+        return res.status(response.status).send(response.error.message);
+      }
+    });
+  },
+  signUp: async function (payload) {
+    let self = this;
+    let response = {};
+    let error;
+    payload = payload || {};
+
+    return new Promise(async function(resolve, reject) {
+      let existingUser = {};
+      let finalPayload = {};
+      let user = self.Manager.User(payload);
+
+      if (!payload?.auth?.uid || !payload?.auth?.email) {
+        return reject(new Error('Cannot create user without UID and email.'))
+      }
+
+      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);
+      }
+
+      // Merge the payload and the default user object
+      finalPayload = merge({}, existingUser, user.properties)
+
+      self.updateReferral({
+        affiliateCode: payload?.affiliate?.referredBy ?? null,
+        uid: payload.auth.uid,
+      })
+      .catch(function (e) {
+        ctx.log('Failed to update affiliate code')
+      })
+
+      self.libraries.admin.firestore().doc(`users/${payload.auth.uid}`)
+      .set(finalPayload, { merge: true })
+      .then(function(data) {
+        response.status = 200;
+        response.data = {created: true};
+        return resolve(response);
+      })
+      .catch(function(error) {
+        return reject(error);
+      })
+
+    });
+  },
+  updateReferral: async function (payload) {
+    let self = this;
+    payload = payload || {};
+
+    let response = {};
+
+    return new Promise(function(resolve, reject) {
+      self.libraries.admin.firestore().collection('users')
+      .where('affiliate.code', '==', payload.affiliateCode)
+      .get()
+      .then(snapshot => {
+        if (snapshot.empty) {
+          response.status = 200;
+          response.referrals = 0;
+          return resolve()
+        }
+        let count = 0;
+        snapshot.forEach(doc => {
+          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.ctx.meta.startTime.timestamp,
+          })
+
+          self.libraries.admin.firestore().doc(`users/${doc.id}`)
+          .set({
+            affiliate: {
+              referrals: referrals
+            }
+          }, {merge: true})
+        });
+        response.status = 200;
+        response.referrals = count;
+        return resolve()
+      })
+      .catch(err => {
+        response.status = 500;
+        response.error = err;
+        return reject(response);
+      });
+    });
+  }
+}
+module.exports = Module;
+
+// HELPERS //
+function addToMCList(key, listId, email) {
+  return new Promise((resolve, reject) => {
+    let datacenter = key.split('-')[1];
+    // Native fetch (Node 22+)
+    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);
+      })
+
+  });
+}

package/dist/manager/functions/_legacy/admin/create-post.js

@@ -0,0 +1,207 @@
+const { brandRepoOwner, brandRepoName } = require('../../../../vendor/config/index.js');
+const env = require('../../../libraries/env.js');
+let fetch;
+let Poster;
+let pathApi;
+let os;
+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,
+    };
+
+    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: 'create-post',
+        // label: '',
+      });
+
+      let repoInfo = { user: brandRepoOwner(self.Manager.config), name: brandRepoName(self.Manager.config) };
+
+      if (!user.roles.admin) {
+        response.status = 401;
+        response.error = new Error('Unauthenticated, admin required.');
+        ctx.error(response.error)
+      } else {
+        // Poster = Poster || require('/Users/ianwiedenman/Documents/GitHub/ITW-Creative-Works/ultimate-jekyll-poster');
+        Poster = Poster || require('ultimate-jekyll-poster');
+
+        let poster = new Poster();
+
+        // Save to disk OR commit
+        poster.onDownload = async function (meta) {
+          return new Promise(async function(resolve, reject) {
+            let finalPath = poster.removeDirDot(meta.finalPath);
+            let tempPath = (meta.tempPath);
+            await createFile(self.Manager.config?.github?.user, repoInfo.user, repoInfo.name, env.get('GH_TOKEN'), finalPath, await poster.readImage(tempPath))
+            .catch((e) => {
+              // console.log('---CAUGHT 1', e);
+            })
+            resolve();
+          });
+        }
+
+        let finalPost = await poster.create(ctx.request.data);
+
+        // Save post OR commit
+        await createFile(self.Manager.config?.github?.user, repoInfo.user, repoInfo.name, env.get('GH_TOKEN'), poster.removeDirDot(finalPost.path), finalPost.content)
+        .catch((e) => {
+          response.status = 400;
+          response.error = new Error('Failed to post: ' + e);
+          ctx.error(response.error)
+        })
+      }
+
+      ctx.log('Post', 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);
+      }
+    });
+  }
+}
+module.exports = Module;
+
+// HELPERS //
+async function createFile(user, repoUser, repoName, key, path, contents) {
+  pathApi = pathApi || require('path');
+  let fileParsed = pathApi.parse(path);
+
+  let base64Data = Buffer.from(contents).toString('base64');
+  // base64Data = contents;
+  // console.log('--------base64Data', base64Data);
+  return new Promise(async (resolve, reject) => {
+    let sha;
+    try {
+
+      let branch = (repoName === 'ultimate-jekyll') ? 'template' : 'master';
+
+      let pathGet = `https://api.github.com/repos/${repoUser}/${repoName}/git/trees/${branch}:${encodeURIComponent(pathApi.dirname(path))}`;
+      await makeRequest({
+        method: 'GET',
+        url: pathGet,
+        body: {
+        },
+        timeout: 30000,
+        response: 'json',
+        headers: {
+          'User-Agent': user,
+          // 'Authorization': `Basic ${user}:${key}`,
+          'Authorization': `Basic ${Buffer.from(user + ':' + key).toString('base64')}`,
+        }
+      })
+      .then(function (resp) {
+        // sha = resp.sha;
+        sha = resp.tree.find(function (element) {
+          // console.log('checiing', element.path, fileParsed.base);
+          return element.path === fileParsed.base;
+        });
+        sha = sha.sha;
+      });
+  } catch (e) {
+    sha = null;
+  }
+
+  let pathPut = `https://api.github.com/repos/${repoUser}/${repoName}/contents/${path}`;
+  let writeRequest =
+  {
+    // url: `https://api.github.com/repos/:owner/:repo/contents/:path`,
+    method: 'PUT',
+    url: pathPut,
+    body: {
+      message: `BackendManager Post: ${new Date().toISOString()}`,
+      content: base64Data,
+    },
+    timeout: 30000,
+    response: 'json',
+    headers: {
+      'User-Agent': user,
+      // 'Authorization': `Basic ${user}:${key}`,
+      'Authorization': `Basic ${Buffer.from(user + ':' + key).toString('base64')}`,
+    }
+  }
+  if (sha) {
+    writeRequest.body.sha = sha;
+  }
+  // console.log('--------PUT', pathPut);
+  await makeRequest(writeRequest)
+  .then((json) => {
+    if (!json || (json.message && (json.message === 'Not Found' || json.message.includes('Invalid request'))) ) {
+      return reject(new Error(json.message));
+    }
+  })
+  .catch((e) => {
+    return reject(e);
+  })
+  return resolve(true)
+  });
+}
+
+function makeRequest(options) {
+  return new Promise(function(resolve, reject) {
+    // Native fetch (Node 22+)
+    options.headers = options.headers || {};
+    options.headers['Content-Type'] = 'application/json';
+    let hasBody = Object.keys(options.body || {}).length > 0
+    fetch(options.url, {
+        method: options.method,
+        body: hasBody ? JSON.stringify(options.body) : undefined,
+        timeout: 30000,
+        headers: options.headers,
+        auth: options.auth,
+      })
+      .then(res => res.json())
+      .then(json => {
+        return resolve(json);
+      })
+      .catch(e => {
+        // console.error('e', e);
+        return reject(e);
+      })
+
+  });
+}
+
+
+// function makeRequest(options) {
+//   return new Promise(function(resolve, reject) {
+//     request = request || require('request');
+//     request(options,
+//       function (err, httpResponse, body) {
+//         if (err) {
+//           // console.log('ERROR', err);
+//           reject(err);
+//         } else {
+//           // console.log('SUCCESS', body);
+//           resolve(body);
+//         }
+//       }
+//     );
+//   });
+// }

package/dist/manager/functions/_legacy/admin/firestore-write.js

@@ -0,0 +1,72 @@
+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() {
+    const self = this;
+    let libraries = self.libraries;
+    let ctx = self.ctx;
+    let req = self.req;
+    let res = self.res;
+    let options = self.ctx.request.data;
+    let admin = self.Manager.libraries.admin;
+
+    let response = {
+      status: 200,
+      data: {},
+    };
+
+    return libraries.cors(req, res, async () => {
+      let user = await ctx.authenticate();
+
+      // Analytics
+      let analytics = self.Manager.Analytics({
+        ctx: ctx,
+        uuid: user.auth.uid,
+      })
+      .event({
+        category: 'admin',
+        action: 'firestore-write',
+        // label: '',
+      });
+
+      // Options
+      options.path = `${options.path || ''}`
+      options.document = options.document || {};
+      options.options = options.options || {};
+      options.options.merge = typeof options.options.merge === 'undefined' ? true : options.options.merge;
+
+      if (!user.roles.admin) {
+        response.status = 401;
+        response.error = new Error('Unauthenticated, admin required.');
+      } else if (!options.path) {
+        response.status = 401;
+        response.error = new Error('Path parameter required');
+      } else {
+        await admin.firestore().doc(options.path)
+        .set(options.document, options.options)
+        .then(r => {
+          ctx.log(`Wrote to ${options.path}:`, options.document, options.options)
+        })
+        .catch(e => {
+          response.status = 500;
+          response.error = e;
+        })
+      }
+
+      if (response.status === 200) {
+        return res.status(response.status).json(response.data);
+      } else {
+        ctx.error(response.error)
+        return res.status(response.status).send(response.error.message);
+      }
+    });
+  },
+}
+module.exports = Module;

package/dist/manager/functions/_legacy/admin/get-stats.js

@@ -0,0 +1,218 @@
+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: 'get-stats',
+        // label: '',
+      });
+
+      if (!user.roles.admin) {
+        response.status = 401;
+        response.error = new Error('Unauthenticated, admin required.');
+        ctx.error(response.error)
+      } else {
+        let stats = libraries.admin.firestore().doc(`meta/stats`)
+
+        await stats
+          .get()
+          .then(async function (doc) {
+            response.data = doc.data() || {};
+            await self.fixStats(response.data)
+              .catch(e => {
+                response.status = 500;
+                response.error = new Error(`Failed fixing stats: ${e.message}`);
+                ctx.error(response.error)
+              })
+
+            await self.updateStats()
+              .catch(e => {
+                response.status = 500;
+                response.error = new Error(`Failed updating stats: ${e.message}`);
+                ctx.error(response.error)
+              })
+
+            await stats
+              .get()
+              .then(r => {
+                response.data = r.data() || {};
+              })
+              .catch(function (e) {
+                response.status = 500;
+                response.error = e;
+                ctx.error(response.error)
+              })
+          })
+          .catch(function (e) {
+            response.status = 500;
+            response.error = e;
+            ctx.error(response.error)
+          })
+      }
+
+      // response.data = data;
+
+      ctx.log('Stats', 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);
+      }
+    });
+  },
+  fixStats: function (data) {
+    let self = this;
+    return new Promise(async function(resolve, reject) {
+      let 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;
+        await self.getAllUsers()
+          .then(r => {
+            usersTotal = r.length
+          })
+          .catch(e => {
+            response.status = 500;
+            response.error = new Error(`Failed fixing stats: ${e.message}`);
+            self.ctx.error(response.error);
+          })
+        await self.getAllSubscriptions()
+          .then(r => {
+            subscriptionsTotal = r
+          })
+          .catch(e => {
+            response.status = 500;
+            response.error = new Error(`Failed fixing stats: ${e.message}`);
+            self.ctx.error(response.error);
+          })
+        await stats
+          .set({
+            users: {
+              total: usersTotal,
+            },
+            subscriptions: {
+              total: subscriptionsTotal,
+            },
+          }, { merge: true })
+          .catch(function (e) {
+            return reject(e);
+          })
+      }
+
+
+      return resolve(data);
+    });
+  },
+  updateStats: function () {
+    let self = this;
+    return new Promise(async function(resolve, reject) {
+      let stats = self.libraries.admin.firestore().doc(`meta/stats`);
+      let online = self.libraries.admin.database().ref(`gatherings/online`);
+      let onlineCount = 0;
+
+      await online
+        .once('value')
+        .then((snap) => {
+          let data = snap.val() || {};
+          let keys = Object.keys(data);
+          onlineCount = keys.length;
+        })
+        .catch(e => {
+          return reject(e);
+        })
+
+      await stats
+        .set({
+          users: {
+            online: onlineCount
+          }
+        }, { merge: true })
+        .catch(function (e) {
+          return reject(e);
+        })
+
+      return resolve();
+    });
+  },
+  getAllUsers: function () {
+    let self = this;
+    return new Promise(async function(resolve, reject) {
+      self.users = [];
+      await getUsersBatch(self)
+      .catch(e => {
+        return reject(e);
+      })
+      return resolve(self.users);
+    });
+  },
+  getAllSubscriptions: function () {
+    let self = this;
+    return new Promise(async function(resolve, reject) {
+      await self.libraries.admin.firestore().collection('notifications')
+      .get()
+      .then(function(querySnapshot) {
+        return resolve(querySnapshot.size)
+      })
+      .catch(function(e) {
+        return reject(e)
+      });
+    });
+  }
+}
+
+module.exports = Module;
+
+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);
+      });
+  });
+}