@xuda.io/notification_module 1.1.127 → 1.1.128

package/index.mjs

@@ -4,11 +4,7 @@ import admin from 'firebase-admin';
 
 console.log('Notifications Module loaded...');
 
-global._conf = (
-  await import(path.join(process.env.XUDA_HOME, process.env.XUDA_CONFIG), {
-    with: { type: 'json' },
-  })
-).default;
+global._conf = (await import(path.join(process.env.XUDA_HOME, "common", "load_conf.mjs"))).loadConf();
 
 const _common = await import(path.join(process.env.XUDA_HOME, 'common', 'xuda_node_common.mjs'));
 const module_path = path.join(process.env.XUDA_HOME, 'cpi') + (!_conf.is_debug ? '/node_modules/@xuda.io' : '');

package/index.mjs.premerge.bak

@@ -0,0 +1,668 @@
+import path from 'path';
+import _ from 'lodash';
+import admin from 'firebase-admin';
+
+console.log('Notifications Module loaded...');
+
+global._conf = (
+  await import(path.join(process.env.XUDA_HOME, process.env.XUDA_CONFIG), {
+    with: { type: 'json' },
+  })
+).default;
+
+const _common = await import(path.join(process.env.XUDA_HOME, 'common', 'xuda_node_common.mjs'));
+const module_path = path.join(process.env.XUDA_HOME, 'cpi') + (!_conf.is_debug ? '/node_modules/@xuda.io' : '');
+const db_module = await import(`${module_path}/db_module/index.mjs`);
+
+const email_msa = await import(`${module_path}/email_module/index_msa.mjs`);
+
+const ws_dashboard_msa = await import(`${module_path}/ws_dashboard_module/index_msa.mjs`);
+
+//////////////////// FCM /////////////////////
+const serviceAccount = _conf.firebase_serviceAccount;
+admin.initializeApp({
+  credential: admin.credential.cert(serviceAccount),
+  databaseURL: 'https://your-project-id.firebaseio.com',
+});
+const messaging = admin.messaging();
+//////////////////////////////////////////////
+
+export const get_new_notification_count = async (req) => {
+  return await db_module.get_couch_view('xuda_notification', 'new_notifications_count', {
+    key: [req.uid],
+    reduce: true,
+    group_level: 1,
+  });
+};
+
+export const set_notification_read = async (req, job_id, header) => {
+  const ret = await db_module.get_couch_doc('xuda_notification', req.notification_id);
+  let notification_doc = ret.data;
+
+  if (notification_doc.system) {
+    return { code: -1, data: 'system notification not allow read' };
+  }
+
+  notification_doc.read_date = Date.now();
+  notification_doc.read = true;
+  notification_doc.read_header = header;
+  return await db_module.save_couch_doc('xuda_notification', notification_doc);
+};
+
+export const update_notification_status = async (req) => {
+  const { notification_id, stat, uid } = req;
+  const ret = await db_module.get_couch_doc('xuda_notification', notification_id);
+  let notification_doc = ret.data;
+  notification_doc.stat_ts = Date.now();
+  notification_doc.stat = stat;
+
+  ws_dashboard_msa.notification({
+    to: notification_doc.system ? uid : notification_doc.uid,
+    data: notification_doc,
+  });
+  return await db_module.save_couch_doc('xuda_notification', notification_doc);
+};
+//, _ch= global[`_notification_module_ch`]
+export const submit_notification = async (req) => {
+  try {
+    let { type, app_id, to_app_id, uid_arr, subject = '', body = '', delivery_method = [], display_type = 'info', ref, email, sender_uid, system, topic, params } = req;
+    let obj = {};
+    const { notification_categories } = await import(path.join(process.env.XUDA_HOME, 'notification_templates.mjs'));
+
+    let icon = 'https://dev.xuda.ai/dist/images/xuda_ico.png';
+    if (app_id) {
+      const app_id_reference = await _common.get_project_app_id(app_id, true);
+      const app_ret = await db_module.get_couch_doc('xuda_master', app_id_reference);
+      if (app_ret.code > -1) {
+        icon = app_ret.data.app_pic;
+      }
+    }
+
+    if (!type) {
+      return { code: -1, data: 'error: type is mandatory field' };
+    }
+
+    if (topic) {
+      const _topic = notification_categories?.[type]?.topics?.[topic];
+      if (_topic) {
+        if (!subject) {
+          subject = _.template(_topic.subject)(params);
+        }
+        delivery_method = _topic.delivery_method;
+        display_type = _topic.display_type;
+        if (!body) {
+          body = _.template(_topic.body)(params);
+        }
+      } else {
+        return {
+          code: -1,
+          data: `${topic} topic for ${type} not exist in notification_categories`,
+        };
+      }
+    }
+
+    let send_result = {};
+
+    for await (let uid of uid_arr) {
+      obj = {};
+      for await (let delivery_method_item of delivery_method) {
+        let account_ret;
+        if (!system) {
+          account_ret = await db_module.get_couch_doc('xuda_accounts', uid);
+          if (account_ret.code < 0) {
+            throw new Error(`user ${uid} not found`);
+          }
+        }
+        send_result[uid] = true;
+        const uuid = await _common.xuda_get_uuid('notification');
+        obj = {
+          _id: uuid,
+          docType: 'notification',
+          type,
+          app_id: to_app_id,
+          uid,
+          subject,
+          body,
+          delivery_method: delivery_method_item,
+          display_type,
+          read: false,
+          ref: ref || uuid,
+          date_created_ts: Date.now(),
+          date_created: Date.now(),
+          sender_uid,
+          stat: 3,
+          stat_ts: Date.now(),
+          system,
+          topic,
+          params,
+        };
+
+        switch (delivery_method_item) {
+          case 'email': {
+            // Honor an explicit email, else fall back to the recipient's account.
+            // System notifications skip the lookup above, so resolve it here
+            // (superuser alert recipients have real accounts with emails).
+            let resolved_email = email;
+            if (!resolved_email) {
+              if (!account_ret) {
+                account_ret = await db_module.get_couch_doc('xuda_accounts', uid).catch(() => null);
+              }
+              resolved_email = account_ret?.data?.account_info?.email || '';
+            }
+            obj.email = resolved_email;
+            if (!obj.email) {
+              send_result[uid] = false;
+              return;
+            }
+
+            email_msa.send_email({
+              email: obj.email,
+              subject,
+              body,
+              ref: obj._id,
+              app_id: obj.app_id,
+            });
+            break;
+          }
+
+          case 'banner':
+          case 'consent':
+          case 'alert':
+            ws_dashboard_msa.notification({
+              to: uid,
+              data: obj,
+            });
+
+            break;
+          case 'push':
+            try {
+              const ret = await db_module.find_couch_query('xuda_sessions', {
+                selector: {
+                  docType: 'gtp_session',
+                  stat: { $lt: 3 },
+                  uid,
+                  fcm_token: { $gt: '' },
+                },
+              });
+              let fcm_token_arr = [];
+              for await (let session of ret.docs) {
+                if (session.fcm_token) {
+                  if (!fcm_token_arr.includes(session.fcm_token)) {
+                    fcm_token_arr.push(session.fcm_token);
+                  }
+                }
+              }
+              for await (let fcm_token of fcm_token_arr) {
+                if (fcm_token) {
+                  const message = {
+                    notification: {
+                      title: subject,
+                      body,
+                      image: icon,
+                    },
+                    token: fcm_token,
+                    android: {
+                      notification: {
+                        imageUrl: icon,
+                      },
+                    },
+                    apns: {
+                      payload: {
+                        aps: {
+                          'mutable-content': 1,
+                        },
+                      },
+                      fcm_options: {
+                        image: icon,
+                      },
+                    },
+                    webpush: {
+                      headers: {
+                        image: icon,
+                      },
+                    },
+                  };
+                  try {
+                    messaging
+                      .send(message)
+                      .then((response) => {
+                        // console.log("Successfully sent message:", response);
+                      })
+                      .catch((error) => {
+                        console.error('Error sending message:', error);
+                      });
+                  } catch (err) {
+                    console.error(err);
+                  }
+                }
+              }
+            } catch (err) {
+              console.error(err);
+            }
+            break;
+
+          default:
+            send_result[uid] = false;
+            break;
+        }
+        obj.sent = send_result[uid];
+        const ret = await db_module.save_couch_doc('xuda_notification', obj);
+      }
+    }
+    return { code: 111, data: obj };
+  } catch (err) {
+    console.error(err);
+    return { code: -111, data: err.message };
+  }
+};
+
+export const get_notifications = async (req) => {
+  if (req.date_to < req.date_from) {
+    return {
+      code: -2,
+      data: 'error - invalid range date_from and date_to',
+    };
+  }
+
+  let selector = {
+    stat: 3,
+  };
+
+  if (req.outbox) {
+    selector.stat = { $lt: 4 };
+    selector.sender_uid = req.uid;
+  } else {
+    if (req.system) {
+      // Drop empty/undefined uid clauses (e.g. an unauthenticated/public call where
+      // req.uid is undefined, or to_app_id is ''), which otherwise build a malformed
+      // Mango $or and make find_couch_query throw -> 400.
+      selector.$or = [{ uid: req.uid }, { uid: 'system' }, { uid: req.to_app_id }].filter(
+        (clause) => typeof clause.uid === 'string' && clause.uid.length > 0,
+      );
+    } else {
+      if (!req.to_app_id) {
+        selector.uid = req.uid;
+      }
+    }
+  }
+
+  if (req.date_to) {
+    selector.$and = [
+      {
+        date_created_ts: {
+          $lte: req.date_to,
+          $gte: req.date_from,
+        },
+      },
+    ];
+  }
+
+  if (req.search) {
+    selector = {
+      ...selector,
+      $or: [
+        {
+          body: {
+            $regex: `(?i)${req.search}`,
+          },
+        },
+        {
+          client_headers: {
+            $regex: `(?i)${req.search}`,
+          },
+        },
+
+        {
+          subject: {
+            $eq: req.search,
+          },
+        },
+      ],
+    };
+  }
+
+  if (req.type) {
+    selector.type = req.type;
+  }
+  if (req.ref) {
+    selector.ref = req.ref;
+  }
+  if (typeof req.to_app_id !== 'undefined') {
+    selector.app_id = req.to_app_id;
+  }
+
+  if (req.delivery_method) {
+    selector.delivery_method = req.delivery_method;
+  }
+  if (req.display_type) {
+    selector.display_type = req.display_type;
+  }
+
+  if ((_.isBoolean(req.read) && req.read) || req.read == 'true') {
+    selector.read = true;
+  } else {
+    selector.read = false;
+  }
+
+  if (typeof req.read === 'undefined') {
+    delete selector.read;
+  }
+
+  const opt = {
+    selector,
+
+    sort: [
+      {
+        date_created_ts: 'desc',
+      },
+    ],
+    limit: req.limit ? req.limit : 99999,
+  };
+
+  if (req.skip) {
+    opt.skip = req.skip;
+  }
+
+  if (req?.bookmark !== 'nil') {
+    opt.bookmark = req.bookmark;
+  }
+
+  try {
+    let ret = await db_module.find_couch_query('xuda_notification', opt);
+    let data = { docs: [] };
+    if (ret.docs) {
+      for await (let doc of ret.docs) {
+        if (await notifications_validation_fx(doc._id)) {
+          data.docs.push(doc);
+        }
+      }
+    }
+
+    return {
+      code: 1,
+      data,
+    };
+  } catch (e) {
+    return {
+      code: -400,
+      data: e,
+    };
+  }
+};
+
+export const submit_superuser_notification = async (req) => {
+  const { uid, type, subject, delivery_method, body, display_type, to_uid = [], to_app_id, app_id, system } = req;
+  try {
+    if (!_conf.superuser_account_ids.includes(uid)) {
+      throw new Error('user is not authorized for this method');
+    }
+
+    if (!_.isArray(to_uid)) {
+      throw new Error('to_uid must be in the form of an array');
+    }
+
+    if (_.isEmpty(to_uid)) {
+      if (!system) {
+        const all_users = await db_module.find_couch_query('xuda_accounts', {
+          selector: {
+            docType: 'account',
+            stat: { $lt: 4 },
+          },
+        });
+        for await (let user of all_users.docs) {
+          to_uid.push(user._id);
+        }
+      } else {
+        to_uid.push('system');
+      }
+    }
+
+    let msg_obj = {
+      type,
+      uid_arr: to_uid,
+      app_id,
+      to_app_id: '',
+      subject,
+      body,
+      delivery_method: [delivery_method],
+      display_type,
+      sender_uid: uid,
+      ref: '',
+      system,
+    };
+
+    return submit_notification(msg_obj);
+  } catch (err) {
+    return { code: -1, data: err.message };
+  }
+};
+
+// Ops/admin alert for the AI error resolver. Renders the `error_resolver`
+// template (notification_templates.mjs -> system category) and delivers to the
+// superuser accounts (which have real emails) via the standard notification path.
+export const submit_error_resolver_alert = async (req) => {
+  const { params = {} } = req || {};
+  try {
+    const recipients = _conf.superuser_account_ids || [];
+    if (!recipients.length) return { code: -1, data: 'no superuser recipients configured' };
+    return await submit_notification({
+      type: 'system',
+      topic: 'error_resolver',
+      uid_arr: recipients,
+      system: true,
+      params,
+    });
+  } catch (err) {
+    return { code: -1, data: err.message };
+  }
+};
+
+export const submit_app_notification = async (req) => {
+  const { uid, subject, delivery_method, body, display_type, to_uid = [], to_app_id, app_id, system, type } = req;
+  try {
+    if (!_.isArray(to_uid)) {
+      throw new Error('to_uid must be in the form of an array');
+    }
+
+    if (_.isEmpty(to_uid)) {
+      if (!system) {
+        throw new Error('to_uid is empty');
+      } else {
+        to_uid.push(app_id);
+      }
+    }
+
+    const app_module = await import(`${module_path}/app_module/index.mjs`);
+    const users_arr = (
+      await app_module.get_app_users({
+        app_id_query: to_app_id,
+      })
+    ).data;
+    const exists = _.some(to_uid, (val) => _.includes(users_arr, val));
+    if (!exists) {
+      throw new Error("some of the uid's are not authorized for the selected app");
+    }
+
+    let msg_obj = {
+      type: _conf.superuser_account_ids.includes(uid) && type ? type : 'user',
+      uid_arr: to_uid,
+      app_id,
+      to_app_id: to_app_id,
+      subject,
+      body,
+      delivery_method: [delivery_method],
+      display_type,
+      sender_uid: uid,
+      ref: '',
+      system,
+    };
+
+    return submit_notification(msg_obj);
+  } catch (err) {
+    return { code: -1, data: err.message };
+  }
+};
+
+export const update_system_notification = async (req) => {
+  const { display_type, subject, body, delivery_method, uid, type } = req;
+  const ret = await db_module.get_couch_doc('xuda_notification', req._id);
+  let notification_doc = ret.data;
+
+  if (!notification_doc.system) {
+    return { code: -1, data: 'only system notification allow update' };
+  }
+  const allowed_delivery_methods = ['banner', 'alert'];
+  if (!allowed_delivery_methods.includes(delivery_method)) {
+    return {
+      code: -1,
+      data: `only ${allowed_delivery_methods.toString()} delivery method allow update`,
+    };
+  }
+
+  notification_doc.ts = Date.now();
+  notification_doc.delivery_method = delivery_method;
+  notification_doc.display_type = display_type;
+  notification_doc.subject = subject;
+  notification_doc.body = body;
+  if (_conf.superuser_account_ids.includes(uid)) {
+    notification_doc.type = type;
+  }
+
+  ws_dashboard_msa.notification({
+    to: notification_doc.system ? uid : notification_doc.uid,
+    data: notification_doc,
+  });
+
+  return await db_module.save_couch_doc('xuda_notification', notification_doc);
+};
+
+export const submit_topic_app_notification = async (req) => {
+  //, _ch
+  const { uid, topic, to_uid = [], to_app_id, app_id, system, type, params } = req;
+  try {
+    if (!_.isArray(to_uid)) {
+      throw new Error('to_uid must be in the form of an array');
+    }
+
+    if (_.isEmpty(to_uid)) {
+      if (!system) {
+        const app_module = await import(`${module_path}/app_module/index.mjs`);
+        const users_arr = (
+          await app_module.get_app_users({
+            app_id_query: to_app_id,
+          })
+        ).data;
+        for await (let user_id of users_arr) {
+          if (uid !== user_id) {
+            to_uid.push(user_id);
+          }
+        }
+      } else {
+        to_uid.push(app_id);
+      }
+    }
+
+    let msg_obj = {
+      type: type || 'user',
+      uid_arr: to_uid,
+      app_id,
+      to_app_id: to_app_id,
+      topic,
+      sender_uid: uid,
+      ref: '',
+      system,
+      params,
+    };
+
+    return submit_notification(msg_obj); //, _ch
+  } catch (err) {
+    return { code: -1, data: err.message };
+  }
+};
+
+export const get_system_notifications = async (req) => {
+  req.system = true;
+  req.to_app_id = '';
+  req.read = false;
+  // System notifications are non-critical app-init data fetched on every page load
+  // (including unauthenticated ones). A DB/query failure must never surface as a 400
+  // to the client (it stalls the loader) -> degrade to an empty list.
+  const ret = await get_notifications(req);
+  if (!ret || ret.code < 0) {
+    return { code: 1, data: { docs: [] } };
+  }
+  return ret;
+};
+
+
+export const notifications_validation_fx = async (notification_id) => {
+  let { code, data: doc } = await db_module.get_couch_doc('xuda_notification', notification_id);
+  const delete_notification = async () => {
+    doc.stat = 4;
+    await db_module.save_couch_doc('xuda_notification', doc);
+  };
+  const read_notification = async () => {
+    doc.read = true;
+    doc.read_ts = Date.now();
+    doc.read_note = 'read by notifications_validation_fx';
+    await db_module.save_couch_doc('xuda_notification', doc);
+  };
+
+  if (code < 0) return false;
+
+  if (!doc.topic) {
+    await delete_notification();
+    return false;
+  }
+  const fx = {
+    new_version_available: async () => {
+      const { code, data: app_doc } = await db_module.get_app_obj(doc.app_id);
+      if (app_doc.app_build_id >= doc.params.build) {
+        await read_notification();
+        return false;
+      }
+
+      return true;
+    },
+  };
+
+  if (!fx[doc.topic]) {
+    return true;
+  }
+
+  return await fx[doc.topic]();
+};
+
+// setTimeout(async () => {
+//   // const app_id = "vps4d6ec68e01d97ef65a8bd86088b26ca2",
+//   //   uid = "341cf2d32991a68e4d8aaba6c16e15cc",
+//   //   ip = "192.11.22.333",
+//   //   name = "Boaz Avrahami";
+//   // const aa = await module.exports.submit_notification({
+//   //   type: "deploy",
+//   //   app_id: app_id,
+//   //   uid_arr: [uid],
+//   //   topic: "welcome_aboard_vps",
+//   //   params: {
+//   //     name: name,
+//   //     ip: ip,
+//   //     dashboard_url: `https://xuda.ai/dashboard/project/${app_id}/admin/overview`,
+//   //     dashboard_ssh_url: `https://xuda.ai/dashboard/project/${app_id}/admin/overview`,
+//   //     dashboard_ssh_assign_url: `https://xuda.ai/dashboard/settings/ssh_keys`,
+//   //     support_url: `https://xuda.ai/schedule/sales?topic=Sales&subtopic=General+Inquiries`,
+//   //   },
+//   //   ref: null,
+//   //   email: null,
+//   // });
+//   // console.log(aa);
+// }, 2000);
+
+// class notifications_validation_class {
+//   constructor(name) {
+//     this.name = name;
+//   }
+
+//   new_version_available(params) {
+//     console.log(`Hello, my name is ${this.name}`);
+//   }
+// }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xuda.io/notification_module",
-  "version": "1.1.127",
+  "version": "1.1.128",
   "description": "Xuda Notification Server Module",
   "main": "index.mjs",
   "dependencies": {