@xuda.io/account_module 1.2.1026 → 1.2.1028

package/index.mjs

@@ -2406,18 +2406,18 @@ export const ts_contact = async function (contact_id) {
 };
 
 export const get_account_ai_usage = async function (req, job_id, headers) {
-  const { uid } = req;
+  const { uid, year, month, day } = req;
   try {
     const app_id = await get_account_default_project_id(uid);
     const { data: acc_obj } = await db_module.get_couch_doc('xuda_accounts', uid);
 
     const d = new Date();
-    const month = Number(String(d.getMonth() + 1).padStart(2, '0')); // months are 0-based
-    const year = d.getFullYear();
+    const curr_month = Number(String(d.getMonth() + 1).padStart(2, '0')); // months are 0-based
+    const curr_year = d.getFullYear();
 
     const ai_usage = await db_module.get_app_couch_view(app_id, 'ai_chat_usage', {
-      startkey: [year, month, 0],
-      endkey: [year, month, 99],
+      startkey: [year || curr_year, month || curr_month, day || 0],
+      endkey: [year || curr_year, month || curr_month, day || 99],
       reduce: true,
       group_level: 999,
     });
@@ -2486,3 +2486,245 @@ setTimeout(async () => {
 
   console.log(ret);
 }, 1000);
+
+export const get_profiles = async function (req) {
+  const { _id, uid, name, limit, skip, bookmark, search, filter_type = 'all', contact_id } = req;
+
+  if (_id) {
+    let data = await db_module.get_couch_doc('xuda_contacts', _id);
+    return data;
+  }
+
+  let { with_requests } = req;
+  var opt = {
+    selector: {
+      docType: 'contact',
+      uid,
+      stat: { $lt: 4 },
+    },
+    limit: limit || 9999,
+    skip: skip || 0,
+    sort: [{ ts: 'desc' }],
+  };
+
+  switch (filter_type) {
+    case 'archived': {
+      opt.selector.stat = 5;
+      break;
+    }
+    case 'shared': {
+      opt.selector.shared_from_uid = { $gt: null };
+      break;
+    }
+
+    case 'pinned': {
+      opt.selector.pinned = true;
+      break;
+    }
+
+    case 'online': {
+      opt.limit = 9999;
+      break;
+    }
+
+    default:
+      with_requests = true;
+      break;
+  }
+
+  if (_id) {
+    opt.selector._id = _id;
+  }
+
+  if (contact_id) {
+    opt.selector._id = contact_id;
+  }
+
+  if (typeof name !== 'undefined') {
+    opt.selector.name = { $regex: `(?i)${name}` };
+  }
+
+  if (typeof search !== 'undefined') {
+    opt.selector['$or'] = [
+      {
+        name: {
+          $regex: `(?i)${search}`,
+        },
+      },
+      {
+        email: {
+          $regex: `(?i)${search}`,
+        },
+      },
+    ];
+  }
+
+  if (bookmark && bookmark !== 'nil') {
+    opt.bookmark = bookmark;
+  }
+
+  let contacts = { docs: [], total_docs: 0 };
+
+  if (filter_type !== 'pending') {
+    contacts = await db_module.find_couch_query('xuda_contacts', opt);
+    if (!limit || contact_id) {
+      contacts.total_docs = contacts.docs.length;
+    } else {
+      delete opt.sort;
+      delete opt.skip;
+      opt.limit = 9999;
+      opt.fields = ['_id'];
+
+      const counter = await db_module.find_couch_query('xuda_contacts', opt);
+      contacts.total_docs = counter.docs.length;
+    }
+  }
+
+  let requests_to = { docs: [], total_docs: 0 };
+  let requests_from = { docs: [], total_docs: 0 };
+  let shared_from = { docs: [], total_docs: 0 };
+  let my_contact = { docs: [], total_docs: 0 };
+  let contact_docs = { docs: [], total_docs: contacts.total_docs };
+  for await (let doc of contacts.docs) {
+    const ret_to = requests_to.docs.find((e) => {
+      return e.contact_uid === doc.contact_uid;
+    });
+    if (ret_to) continue;
+
+    const ret_from = requests_from.docs.find((e) => {
+      return e.contact_uid === doc.contact_uid;
+    });
+    if (ret_from) continue;
+
+    doc = await get_contact_info(uid, doc);
+
+    if (filter_type === 'online') {
+      if (!doc.online) continue;
+    }
+
+    contact_docs.docs.push(doc);
+  }
+
+  if (!contact_id && with_requests) {
+    if (filter_type === 'pending') {
+      ////// TO - OUT
+      requests_to.docs = await get_pending_contact_out(uid);
+      requests_to.total_docs = requests_to.docs.length;
+
+      ////// FROM - IN
+      requests_from.docs = await get_pending_contact_in(uid);
+      requests_from.total_docs = requests_from.docs.length;
+      shared_from.docs = await get_pending_share_contact_in(uid);
+      shared_from.total_docs = shared_from.docs.length;
+    }
+    // my contact
+    if (filter_type === 'all' && !search && contact_docs.docs.length) {
+      const my_contact_doc = await get_user_contact(uid, uid);
+      my_contact.docs = [my_contact_doc];
+      my_contact.total_docs = 1;
+    }
+  }
+
+  return {
+    code: 1,
+    data: {
+      docs: [...my_contact.docs, ...shared_from.docs, ...requests_from.docs, ...requests_to.docs, ...contact_docs.docs],
+      total_docs: my_contact.total_docs + shared_from.total_docs + requests_from.total_docs + requests_to.total_docs + contact_docs.total_docs,
+    },
+  };
+};
+
+export const archive_profile = async function (req) {
+  const { contact_id } = req;
+  try {
+    var contact_doc = await db_module.get_couch_doc_native('xuda_contacts', contact_id);
+    contact_doc.stat = 5;
+    contact_doc.stat_ts = Date.now();
+    contact_doc.stat_reason = 'archived by the user';
+
+    const contact_save_ret = await db_module.save_couch_doc('xuda_contacts', contact_doc);
+
+    return contact_save_ret;
+  } catch (err) {
+    return {
+      code: -22,
+      data: err.message,
+    };
+  }
+};
+
+export const delete_profile = async function (req, job_id, headers) {
+  const { contact_id } = req;
+  try {
+    var contact_doc = await db_module.get_couch_doc_native('xuda_contacts', contact_id);
+
+    contact_doc.stat = 4;
+    contact_doc.stat_ts = Date.now();
+    contact_doc.stat_reason = 'deleted by the user';
+
+    const contact_save_ret = await db_module.save_couch_doc('xuda_contacts', contact_doc);
+
+    ai_module.delete_depended_chats(uid, contact_id);
+    return contact_save_ret;
+  } catch (err) {
+    return {
+      code: -22,
+      data: err.message,
+    };
+  }
+};
+
+export const unarchive_profile = async function (req) {
+  const { contact_id } = req;
+  try {
+    var contact_doc = await db_module.get_couch_doc_native('xuda_contacts', contact_id);
+
+    if (contact_doc.stat !== 5) {
+      throw new Error('contact is not archived');
+    }
+
+    contact_doc.stat = 3;
+    contact_doc.stat_ts = Date.now();
+    contact_doc.stat_reason = 'archived by the user';
+
+    const contact_save_ret = await db_module.save_couch_doc('xuda_contacts', contact_doc);
+
+    return contact_save_ret;
+  } catch (err) {
+    return {
+      code: -22,
+      data: err.message,
+    };
+  }
+};
+
+export const unfriend_profile = async function (req) {
+  const { contact_id } = req;
+  try {
+    const contact_ret = await db_module.get_couch_doc('xuda_contacts', contact_id);
+    if (contact_ret.code < 0) {
+      throw new Error(contact_ret.data);
+    }
+    var contact_doc = contact_ret.data;
+
+    if (!contact_doc.team_req_id) {
+      throw new Error('no friend relationship found');
+    }
+    let req_doc = await db_module.get_couch_doc_native('xuda_team', contact_doc.team_req_id);
+    req_doc.team_req_stat = 4;
+    req_doc.team_req_stat_desc = 'unfriend by the user';
+    await db_module.get_couch_doc_native('xuda_team', contact_doc.team_req_id);
+
+    contact_doc.team_req_id = null;
+    const contact_save_ret = await db_module.save_couch_doc('xuda_contacts', contact_doc);
+
+    const req_save_ret = await db_module.save_couch_doc('xuda_team', req_doc);
+
+    return req_save_ret;
+  } catch (err) {
+    return {
+      code: -21,
+      data: err.message,
+    };
+  }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xuda.io/account_module",
-  "version": "1.2.1026",
+  "version": "1.2.1028",
   "description": "Xuda Account Server Module",
   "main": "index.mjs",
   "dependencies": {