@xuda.io/account_module 1.2.522 → 1.2.749

package/index.mjs

@@ -6,9 +6,9 @@ import { parsePhoneNumber } from 'libphonenumber-js';
 import { countryCodeEmoji } from 'country-code-emoji';
 
 // Convert exec to a promise for cleaner async/await usage
-const execAsync = util.promisify(exec);
+// const execAsync = util.promisify(exec);
 
-const account_info_properties = ['account_type', 'company_name', 'bio', 'tel', 'address', 'city', 'state', 'zip', 'country', 'email', 'first_name', 'last_name', 'mainCategory', 'subCategory', 'profile_picture', 'username', 'website'];
+const account_info_properties = ['account_type', 'business_name', 'bio', 'tel', 'address', 'city', 'state', 'zip', 'country', 'email', 'first_name', 'last_name', 'mainCategory', 'subCategory', 'profile_picture', 'username', 'website', 'auto_respond', 'auto_respond_mode', 'auto_respond_agents'];
 
 global._conf = (
   await import(path.join(process.env.XUDA_HOME, process.env.XUDA_CONFIG), {
@@ -31,10 +31,6 @@ export const update_account_info = async function (req, job_id, headers) {
   const { uid } = req;
   const data = req;
 
-  // delete data.gtp_token;
-  // delete data.uid;
-  // delete data.token_ret;
-  // delete data.job_id;
   delete data.profile_avatar;
 
   function validate_input(string, max_length, is_mandatory, is_pass) {
@@ -60,9 +56,9 @@ export const update_account_info = async function (req, job_id, headers) {
 
   await marketplace_module.marketplace_save_user({ uid });
 
-  _.forEach(account_info_properties, function (key) {
+  for (const key of account_info_properties) {
     let val = data[key];
-
+    if (typeof val === 'undefined') continue;
     if (account_obj.account_info[key] !== val) {
       change += ' from ' + account_obj.account_info[key] + ' to ' + val;
       account_info_changes_arr.push(key);
@@ -87,7 +83,7 @@ export const update_account_info = async function (req, job_id, headers) {
       account_obj.account_info[key] = val;
 
       if (account_obj.account_info.account_type === 'business') {
-        if (key === 'company_name' && validate_input(val, 150, true, false) < 0) {
+        if (key === 'business_name' && validate_input(val, 150, true, false) < 0) {
           error[key] = 'Invalid company';
         }
       }
@@ -102,10 +98,10 @@ export const update_account_info = async function (req, job_id, headers) {
       if (key === 'email' && (!validator.isEmail(val) || !val || val.length < 2)) {
         error[key] = 'Invalid email';
       }
-      if (key === 'tel' && (!/^[0-9]{3}-[0-9]{4}-[0-9]{4}$/.test(val) || !val || val.length < 2)) {
-        // if (key === "tel" && (!preg_match("/^[0-9]{3}-[0-9]{4}-[0-9]{4}$/", $val) || !$val || count($val) < 2)) {
-        error[key] = 'Invalid phone number';
-      }
+      // if (key === 'tel' && (!/^[0-9]{3}-[0-9]{4}-[0-9]{4}$/.test(val) || !val || val.length < 2)) {
+      //   // if (key === "tel" && (!preg_match("/^[0-9]{3}-[0-9]{4}-[0-9]{4}$/", $val) || !$val || count($val) < 2)) {
+      //   error[key] = 'Invalid phone number';
+      // }
       if (key === 'address' && !/^[a-z0-9- ]+$/i.test(val)) {
         // if (key === "address" && !preg_match('/^[a-z0-9- ]+$/i', $val)) {
         error[key] = 'Invalid address';
@@ -123,7 +119,7 @@ export const update_account_info = async function (req, job_id, headers) {
         error[key] = 'Invalid country';
       }
     }
-  });
+  }
 
   if (!_.isEmpty(error)) {
     return { code: -1310, data: error };
@@ -144,19 +140,19 @@ export const update_account_info = async function (req, job_id, headers) {
   delete account_obj.account_info.job_id;
   delete account_obj.account_info.app_id;
 
-  if (!account_obj.account_project_id) {
-    const app_module = await import(`${module_path}/app_module/index.mjs`);
+  // if (!account_obj.account_project_id) {
+  //   const app_module = await import(`${module_path}/app_module/index.mjs`);
 
-    const ret = await app_module.create_project({ token_ret: req.token_ret, uid, data: { app_name: `Account ${uid} main project`, is_account_project: true, app_plugins_purchased: ['	@xuda.io/xuda-dbs-plugin-xuda', '@xuda.io/xuda-framework-plugin-tailwind'] } }, job_id, headers);
-    if (ret.code > -1) {
-      account_obj.account_project_id = ret.data;
+  //   const ret = await app_module.create_project({ token_ret: req.token_ret, uid, data: { app_name: `Account ${uid} main project`, is_account_project: true, app_plugins_purchased: ['	@xuda.io/xuda-dbs-plugin-xuda', '@xuda.io/xuda-framework-plugin-tailwind'] } }, job_id, headers);
+  //   if (ret.code > -1) {
+  //     account_obj.account_project_id = ret.data;
 
-      let drive_req = { app_id: account_obj.account_project_id, uid, path: '/' };
-      await drive_module.create_drive_folder_user({ ...drive_req, ...{ folder_name: 'Profile Images', is_system: true } }, job_id, headers);
-      await drive_module.create_drive_folder_user({ ...drive_req, ...{ folder_name: 'Chat Thumbnails', is_system: true } }, job_id, headers);
-      await drive_module.create_drive_folder_user({ ...drive_req, ...{ folder_name: 'Chat Attachments', is_system: true } }, job_id, headers);
-    }
-  }
+  //     let drive_req = { app_id: account_obj.account_project_id, uid, path: '/' };
+  //     await drive_module.create_drive_folder_user({ ...drive_req, ...{ folder_name: 'Profile Images', is_system: true } }, job_id, headers);
+  //     await drive_module.create_drive_folder_user({ ...drive_req, ...{ folder_name: 'Chat Thumbnails', is_system: true } }, job_id, headers);
+  //     await drive_module.create_drive_folder_user({ ...drive_req, ...{ folder_name: 'Chat Attachments', is_system: true } }, job_id, headers);
+  //   }
+  // }
 
   const ai_module = await import(`${module_path}/ai_module/index.mjs`);
   if (account_obj.account_info?.profile_picture) {
@@ -169,13 +165,13 @@ export const update_account_info = async function (req, job_id, headers) {
 
   // temp remove later on
 
-  let drive_req = { app_id: account_obj.account_project_id, uid, path: '/' };
-  await drive_module.create_drive_folder_workspace({ ...drive_req, ...{ folder_name: 'Chat Images' } }, job_id, headers);
-  await drive_module.create_drive_folder_studio({ ...drive_req, ...{ folder_name: 'Progs Thumbnails', is_system: true } }, job_id, headers);
-  await drive_module.create_drive_folder_studio({ ...drive_req, ...{ folder_name: 'Screenshots', is_system: true } }, job_id, headers);
-  await drive_module.create_drive_folder_user({ ...drive_req, ...{ folder_name: 'Profile Images', is_system: true } }, job_id, headers);
-  await drive_module.create_drive_folder_user({ ...drive_req, ...{ folder_name: 'Chat Thumbnails', is_system: true } }, job_id, headers);
-  await drive_module.create_drive_folder_user({ ...drive_req, ...{ folder_name: 'Chat Attachments', is_system: true } }, job_id, headers);
+  // let drive_req = { app_id: account_obj.account_project_id, uid, path: '/' };
+  // await drive_module.create_drive_folder_workspace({ ...drive_req, ...{ folder_name: 'Chat Images' } }, job_id, headers);
+  // await drive_module.create_drive_folder_studio({ ...drive_req, ...{ folder_name: 'Progs Thumbnails', is_system: true } }, job_id, headers);
+  // await drive_module.create_drive_folder_studio({ ...drive_req, ...{ folder_name: 'Screenshots', is_system: true } }, job_id, headers);
+  // await drive_module.create_drive_folder_user({ ...drive_req, ...{ folder_name: 'Profile Images', is_system: true } }, job_id, headers);
+  // await drive_module.create_drive_folder_user({ ...drive_req, ...{ folder_name: 'Chat Thumbnails', is_system: true } }, job_id, headers);
+  // await drive_module.create_drive_folder_user({ ...drive_req, ...{ folder_name: 'Chat Attachments', is_system: true } }, job_id, headers);
 
   const ret2 = await db_module.save_couch_doc('xuda_accounts', account_obj);
 
@@ -567,9 +563,10 @@ export const get_account_name = async function (req) {
     date_created_ts,
   };
   if (data.data.account_info) {
-    const { first_name, last_name, email, tel: phone, profile_picture, profile_avatar, username, website, country, bio, industry } = data.data.account_info;
+    const { first_name, last_name, email, tel: phone, profile_picture, profile_avatar, username, website, country, bio, industry, account_type, address, city, state, zip, business_name, auto_respond, auto_respond_mode, auto_respond_agents } = data.data.account_info;
 
     obj = {
+      _id: data.data._id,
       first_name,
       last_name,
       email,
@@ -585,9 +582,20 @@ export const get_account_name = async function (req) {
       support_plan,
       storage_plan,
       date_created_ts,
+      account_type,
+      address,
+      city,
+      state,
+      zip,
+      business_name,
+      online: data?.data?.socket_id ? true : false,
+      auto_respond,
+      auto_respond_mode,
+      auto_respond_agents,
+      primary_email: email?.[0] || '',
     };
   }
-  return { code: 1, data: obj };
+  return { code: 1, data: obj }; //is_online: data?.data?.socket_id ? true : false
 };
 
 export const account_validate_username = async function (req) {
@@ -825,57 +833,63 @@ export const get_ssh_keys = async function (req) {
 };
 
 export const search_users = async function (req) {
+  const { _id, search, limit, skip, bookmark, uid } = req;
+
   // search
   // skip
   // limit
   // bookmark
   try {
-    if (!_conf.superuser_account_ids.includes(req.uid)) {
-      throw new Error('user is not authorized for this method');
-    }
+    // if (!_conf.superuser_account_ids.includes(req.uid)) {
+    //   throw new Error('user is not authorized for this method');
+    // }
 
     let selector = {
       docType: 'account',
       stat: 3,
     };
 
-    if (req.search) {
+    if (_id) {
+      selector._id = _id;
+    }
+
+    if (search) {
       selector = {
         ...selector,
         $or: [
           {
             'account_info.first_name': {
-              $regex: `(?i)${req.search}`,
+              $regex: `(?i)${search}`,
             },
           },
           {
             'account_info.last_name': {
-              $regex: `(?i)${req.search}`,
+              $regex: `(?i)${search}`,
             },
           },
           {
-            'account_info.company_name': {
-              $regex: `(?i)${req.search}`,
+            'account_info.business_name': {
+              $regex: `(?i)${search}`,
             },
           },
           {
             'account_info.tel': {
-              $regex: `(?i)${req.search}`,
+              $regex: `(?i)${search}`,
             },
           },
           {
             'account_info.email': {
-              $regex: `(?i)${req.search}`,
+              $regex: `(?i)${search}`,
             },
           },
           {
             'account_info.address': {
-              $regex: `(?i)${req.search}`,
+              $regex: `(?i)${search}`,
             },
           },
           {
             _id: {
-              $regex: `(?i)${req.search}`,
+              $regex: `(?i)${search}`,
             },
           },
         ],
@@ -884,24 +898,36 @@ export const search_users = async function (req) {
 
     const opt = {
       selector,
-
-      limit: req.limit ? req.limit : 99999,
+      fields: ['_id', 'account_info.first_name', 'account_info.last_name', 'account_info.username', 'account_info.profile_avatar', 'account_info.profile_picture', 'socket_id', 'account_info.country', 'account_info.bio', 'account_info.company'],
+      limit: limit ? limit : 99999,
     };
 
-    if (req.skip) {
-      opt.skip = req.skip;
+    if (skip) {
+      opt.skip = skip;
     }
 
     if (req?.bookmark !== 'nil') {
-      opt.bookmark = req.bookmark;
+      opt.bookmark = bookmark;
     }
 
     try {
       var ret = await db_module.find_couch_query('xuda_accounts', opt);
 
+      let docs = [];
+      for await (let e of ret.docs) {
+        let doc = await get_user_card(uid, e._id); //await get_contact_info(uid, e);
+        docs.push(doc);
+      }
+
+      // debugger
       return {
         code: 1,
-        data: ret,
+        data: docs,
+        // data: ret.docs.map((e) => {
+        //   const { socket_id, ...rest } = e;
+
+        //   return { _id: e._id, ...rest.account_info, online: e.socket_id ? true : false };
+        // }),
       };
     } catch (e) {
       return {
@@ -1169,22 +1195,24 @@ const get_contact_background = function (doc) {
 
   if (doc.pending) {
     ret = `linear-gradient(145deg, #009ec2 0%, #002c74 100%)`;
+  } else if (doc.my_contact) {
+    ret = `linear-gradient(145deg, #242480 0%, #060619 100%)`;
   } else {
-    switch (doc.contact_mood) {
+    switch (doc.contact_mood_level) {
       case -2: {
-        ret = `linear-gradient(145deg, #f60404d8 0%, #7f98e344 100%)`;
+        ret = `linear-gradient(145deg, #f6040494 0%, #f6040476 100%)`;
         break;
       }
       case -1: {
-        ret = `linear-gradient(145deg, #f6040452 0%, #7f98e344 100%)`;
+        ret = `linear-gradient(145deg, #f604048b 0%, #7f98e344 100%)`;
         break;
       }
       case 1: {
-        ret = `linear-gradient(145deg, #04f61452 0%, #7f98e344 100%)`;
+        ret = `linear-gradient(145deg, #04f61447 0%, #7f98e344 100%)`;
         break;
       }
       case 2: {
-        ret = `linear-gradient(145deg, #30f604c9 0%, #7f98e344 100%)`;
+        ret = `linear-gradient(145deg, #30f60468 0%, #04f61447 100%)`;
         break;
       }
       default:
@@ -1194,10 +1222,15 @@ const get_contact_background = function (doc) {
   return ret;
 };
 
-const get_contact_pattern = function (doc) {
+const get_contact_pattern = async function (doc) {
   let ret = `default-pattern.png`;
 
-  if (doc.contact_uid) {
+  if (doc.my_contact) {
+    ret = `my-pattern.png`;
+  } else if (doc.shared_from_uid) {
+    const shared_from_uid_ret = await get_account_name({ uid_query: doc.shared_from_uid });
+    ret = shared_from_uid_ret.data.profile_avatar;
+  } else if (doc.contact_uid) {
     ret = `xu-pattern.png`;
   } else {
     switch (doc.source) {
@@ -1218,14 +1251,17 @@ const get_contact_pattern = function (doc) {
 };
 
 const get_contact_border = function (doc) {
-  let ret = `transparent`;
+  const disable_color = `#1a3557`;
+  let ret;
 
   if (doc.pending) {
-    ret = `#6f6c67`;
+    ret = `#6f6c67`; // gray
+  } else if (doc.my_contact) {
+    ret = `transparent`; // gray
   } else {
     switch (doc.connection_stat) {
       case 0: {
-        ret = `transparent`;
+        ret = disable_color;
         break;
       }
       case 1: {
@@ -1239,7 +1275,7 @@ const get_contact_border = function (doc) {
       }
 
       case 3: {
-        ret = `#0070ff`;
+        ret = `#164a28`; //`#0070ff`;
         break;
       }
 
@@ -1249,12 +1285,27 @@ const get_contact_border = function (doc) {
       }
 
       default:
+        ret = disable_color;
         break;
     }
   }
   return ret;
 };
 
+function formatPhoneWithFlag(phoneString, country = 'US') {
+  // try {
+
+  const phoneNumber = parsePhoneNumber(phoneString, country);
+  if (phoneNumber && phoneNumber.country) {
+    const flag = countryCodeEmoji(phoneNumber.country);
+    const formatted = phoneNumber.formatInternational(); // e.g., +1 213 373 4253
+    return `${flag} ${formatted}`;
+  }
+  // } catch (error) {
+  //   return 'Invalid phone number';
+  // }
+}
+
 export const get_contact_info = async function (uid, contact_doc, _id) {
   const ai_module = await import(`${module_path}/ai_module/index.mjs`);
   let doc = contact_doc;
@@ -1269,39 +1320,155 @@ export const get_contact_info = async function (uid, contact_doc, _id) {
     }
 
     doc.profile_avatar = account_info_ret.data.profile_avatar;
-    doc.card_background = get_contact_background(doc);
 
     //membership_plan
     doc.name = `${account_info_ret.data.first_name} ${account_info_ret.data.last_name}`;
 
-    doc.telephone = account_info_ret.data.phone;
+    if (account_info_ret.data.phone) {
+      try {
+        doc.telephone = formatPhoneWithFlag(account_info_ret.data.phone, account_info_ret.data.country);
+      } catch (err) {
+        console.error(err);
+        doc.telephone = account_info_ret.data.phone;
+      }
+    }
 
-    // doc.online = true;
     if (doc.team_req_id) {
       try {
         const req_doc = await db_module.get_couch_doc_native('xuda_team', doc.team_req_id);
         doc.connection_stat = req_doc.team_req_stat;
+        doc.friend_since = req_doc.team_req_date;
       } catch (error) {
         doc.connection_stat = 0;
       }
     }
 
-    doc.icon_pattern = get_contact_pattern(doc);
+    doc.icon_pattern = await get_contact_pattern(doc);
+    doc.username = account_info_ret.data.username;
+    doc.company = account_info_ret.data.business_name;
+    doc.address = account_info_ret.data.address;
+    doc.city = account_info_ret.data.city;
+    doc.state = account_info_ret.data.state;
+    doc.zip = account_info_ret.data.zip;
+  } else {
+    doc.email = doc.email?.[0];
   }
 
+  doc.interactions = 0;
+  doc.chats = 0;
+
   const chats_ret = await ai_module.get_ai_chats({ uid, reference_id: doc._id });
   for (let chat_doc of chats_ret.data.docs) {
     doc.notifications += chat_doc.notifications;
+
+    doc.chats++;
+    if (chat_doc.interactions) {
+      doc.interactions += chat_doc.interactions;
+    }
+    doc.contact_mood_level = chat_doc.mood_level || 0;
   }
 
+  doc.card_background = get_contact_background(doc);
+
   doc.border = get_contact_border(doc);
-  if (!doc.name) {
-    doc.name = doc.email;
+
+  return doc;
+};
+
+export const get_pending_contact_out = async function (uid, _id) {
+  let docs = [];
+  const to_opt = {
+    selector: { docType: 'team_request', access_type: 'contact_connection', team_req_stat: 2, team_req_from_uid: uid },
+    fields: ['_id', 'team_req_date', 'team_req_to_uid', 'team_req_to_email', 'sender_account_info.email', 'sender_account_info.first_name', 'sender_account_info.last_name', 'sender_account_info.profile_avatar', 'team_req_from_uid'],
+  };
+
+  if (_id) {
+    to_opt.selector._id = _id;
   }
+  const requests_to_res = await db_module.find_couch_query('xuda_team', to_opt);
 
-  doc.email = '';
+  for await (let e of requests_to_res.docs) {
+    let doc = { docType: 'contact', date_created: e.team_req_date, email: [e.team_req_to_email], name: '', pending: true, contact_uid: e.team_req_to_uid, team_req_id: e._id, team_req_from_uid: uid };
 
-  return doc;
+    if (e.team_req_to_uid) {
+      const account_info_ret = await get_account_name({ uid_query: e.team_req_to_uid });
+      if (account_info_ret.code < 0) {
+        continue; // throw new Error(`account ${contact_uid} not found`);
+      }
+      doc.profile_avatar = account_info_ret.data.profile_avatar;
+      doc.name = `${account_info_ret.data.first_name} ${account_info_ret.data.last_name}`;
+    }
+    doc.icon_pattern = await get_contact_pattern(doc);
+    doc.card_background = get_contact_background({ pending: true });
+    docs.push(doc);
+  }
+
+  return docs;
+};
+
+export const get_pending_contact_in = async function (uid, _id) {
+  let docs = [];
+  const from_opt = { selector: { docType: 'team_request', access_type: 'contact_connection', team_req_stat: 2, team_req_to_uid: uid }, fields: ['_id', 'team_req_date', 'sender_account_info.email', 'team_req_from_uid'] };
+
+  if (_id) {
+    to_opt.selector._id = _id;
+  }
+
+  const requests_from_res = await db_module.find_couch_query('xuda_team', from_opt);
+
+  for await (let e of requests_from_res.docs) {
+    let doc = { docType: 'contact', date_created: e.team_req_date, email: [e.sender_account_info.email], name: '', pending: true, contact_uid: e.team_req_from_uid, team_req_id: e._id };
+
+    if (e.team_req_from_uid) {
+      const account_info_ret = await get_account_name({ uid_query: e.team_req_from_uid });
+      if (account_info_ret.code < 0) {
+        continue; // throw new Error(`account ${contact_uid} not found`);
+      }
+      doc.profile_avatar = account_info_ret.data.profile_avatar;
+      doc.name = `${account_info_ret.data.first_name} ${account_info_ret.data.last_name}`;
+    }
+    doc.card_background = get_contact_background({ pending: true });
+    doc.icon_pattern = await get_contact_pattern(doc);
+    docs.push(doc);
+  }
+  return docs;
+};
+export const get_pending_share_contact_in = async function (uid, _id) {
+  let docs = [];
+  const from_opt = { selector: { docType: 'team_request', access_type: 'contact', team_req_stat: 2, team_req_to_uid: uid }, fields: ['_id', 'team_req_date', 'sender_account_info.email', 'team_req_from_uid', 'share_item_id'] };
+
+  if (_id) {
+    to_opt.selector._id = _id;
+  }
+
+  const requests_from_res = await db_module.find_couch_query('xuda_team', from_opt);
+
+  for await (let e of requests_from_res.docs) {
+    // let doc = { docType: 'contact', date_created: e.team_req_date, email: [e.sender_account_info.email], name: '', pending: true, contact_uid: e.team_req_from_uid, team_req_id: e._id };
+    let doc = await db_module.get_couch_doc_native('xuda_contacts', e.share_item_id);
+    delete doc.contact_mood_level;
+    doc.shared_from_uid = e.team_req_from_uid;
+    doc.pending = true;
+    doc = await get_contact_info(uid, doc);
+    doc.team_req_id = e._id;
+
+    docs.push(doc);
+  }
+  return docs;
+};
+
+const get_user_contact = async function (uid, uid_query) {
+  const my_contact_ret = await get_account_name({ uid_query });
+  const my_account_info = my_contact_ret.data;
+  let my_contact_doc = { docType: 'contact', date_created: Date.now(), email: [my_account_info.email], name: `${my_account_info.first_name} ${my_account_info.last_name}`, my_contact: uid === uid_query, contact_uid: uid_query };
+  my_contact_doc.profile_avatar = my_account_info.profile_avatar;
+  my_contact_doc.card_background = get_contact_background(my_contact_doc);
+  my_contact_doc.icon_pattern = await get_contact_pattern(my_contact_doc);
+  my_contact_doc.border = get_contact_border(my_contact_doc);
+  my_contact_doc.auto_respond = my_account_info.auto_respond;
+  my_contact_doc.auto_respond_mode = my_account_info.auto_respond_mode;
+  my_contact_doc.auto_respond_agents = my_account_info.auto_respond_agents;
+  return my_contact_doc;
 };
 
 export const get_contacts = async function (req) {
@@ -1360,80 +1527,151 @@ export const get_contacts = async function (req) {
 
   const contacts = await db_module.find_couch_query('xuda_contacts', opt);
 
-  for await (let doc of contacts.docs) {
-    doc = await get_contact_info(uid, doc);
-  }
-
   let requests_to = { docs: [] };
   let requests_from = { docs: [] };
-
+  let shared_from = { docs: [] };
+  let my_contact = { docs: [] };
   if (with_requests) {
-    ////// TO
-    const requests_to_res = await db_module.find_couch_query('xuda_team', {
-      selector: { docType: 'team_request', access_type: 'contact', team_req_stat: 2, team_req_from_uid: uid },
-      fields: ['_id', 'team_req_date', 'team_req_to_uid', 'team_req_to_email', 'sender_account_info.email', 'sender_account_info.first_name', 'sender_account_info.last_name', 'sender_account_info.profile_avatar', 'team_req_from_uid'],
+    ////// TO - OUT
+    requests_to.docs = await get_pending_contact_out(uid);
+
+    ////// FROM - IN
+    requests_from.docs = await get_pending_contact_in(uid);
+    shared_from.docs = await get_pending_share_contact_in(uid);
+    // my contact
+    // const my_contact_ret = await get_account_name({ uid_query: uid }); //await db_module.get_couch_doc_native('xuda_contacts', sender_contact_id);
+    // const my_account_info = my_contact_ret.data;
+    // let my_contact_doc = { docType: 'contact', date_created: Date.now(), email: [my_account_info.email], name: `${my_account_info.first_name} ${my_account_info.last_name}`, my_contact: true, contact_uid: uid };
+    // my_contact_doc.profile_avatar = my_account_info.profile_avatar;
+    // my_contact_doc.card_background = get_contact_background(my_contact_doc);
+    // my_contact_doc.icon_pattern = await get_contact_pattern(my_contact_doc);
+    // my_contact_doc.border = get_contact_border(my_contact_doc);
+    // my_contact_doc.auto_respond = my_account_info.auto_respond;
+    // my_contact_doc.auto_respond_mode = my_account_info.auto_respond_mode;
+    // my_contact_doc.auto_respond_agents = my_account_info.auto_respond_agents;
+    const my_contact_doc = await get_user_contact(uid, uid);
+    my_contact.docs = [my_contact_doc];
+  }
+  let contact_docs = { 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;
 
-    for await (let e of requests_to_res.docs) {
-      let doc = { docType: 'contact', date_created: e.team_req_date, email: [e.team_req_to_email], name: '', pending: true, contact_uid: e.team_req_to_uid, team_req_id: e._id, team_req_from_uid: uid };
-
-      if (e.team_req_to_uid) {
-        const account_info_ret = await get_account_name({ uid_query: e.team_req_to_uid });
-        if (account_info_ret.code < 0) {
-          continue; // throw new Error(`account ${contact_uid} not found`);
-        }
-        doc.profile_avatar = account_info_ret.data.profile_avatar;
-        doc.name = `${account_info_ret.data.first_name} ${account_info_ret.data.last_name}`;
-      }
-      doc.icon_pattern = get_contact_pattern(doc);
-      doc.card_background = get_contact_background({ pending: true });
-      requests_to.docs.push(doc);
-    }
-
-    ////// FROM
-    const requests_from_res = await db_module.find_couch_query('xuda_team', { selector: { docType: 'team_request', access_type: 'contact', team_req_stat: 2, team_req_to_uid: uid }, fields: ['_id', 'team_req_date', 'sender_account_info.email', 'team_req_from_uid'] });
-
-    for await (let e of requests_from_res.docs) {
-      let doc = { docType: 'contact', date_created: e.team_req_date, email: [e.sender_account_info.email], name: '', pending: true, contact_uid: e.team_req_from_uid, team_req_id: e._id };
+    const ret_from = requests_from.docs.find((e) => {
+      return e.contact_uid === doc.contact_uid;
+    });
+    if (ret_from) continue;
 
-      if (e.team_req_from_uid) {
-        const account_info_ret = await get_account_name({ uid_query: e.team_req_from_uid });
-        if (account_info_ret.code < 0) {
-          continue; // throw new Error(`account ${contact_uid} not found`);
-        }
-        doc.profile_avatar = account_info_ret.data.profile_avatar;
-        doc.name = `${account_info_ret.data.first_name} ${account_info_ret.data.last_name}`;
-      }
-      doc.card_background = get_contact_background({ pending: true });
-      doc.icon_pattern = get_contact_pattern(doc);
-      requests_from.docs.push(doc);
-    }
+    doc = await get_contact_info(uid, doc);
+    contact_docs.docs.push(doc);
   }
 
   return {
     code: 1,
     data: {
-      docs: [...requests_to.docs, ...requests_from.docs, ...contacts.docs],
+      docs: [...my_contact.docs, ...shared_from.docs, ...requests_from.docs, ...requests_to.docs, ...contact_docs.docs],
     },
   };
 };
 
 export const archive_contact = async function (req) {
-  const { _id } = req;
+  const { contact_id } = req;
+  try {
+    const contact_ret = await db_module.get_couch_doc('xuda_contacts', contact_id);
+    if (contact_ret.code < 0) {
+      return contact_ret;
+    }
+    var contact_doc = contact_ret.data;
+    contact_doc.stat = 2;
+    contact_doc.stat_ts = Date.now();
+    contact_doc.stat_reason = 'archived by the user';
 
-  const contact_ret = await db_module.get_couch_doc('xuda_contacts', _id);
-  if (contact_ret.code < 0) {
-    return contact_ret;
+    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,
+    };
   }
-  var contact_doc = contact_ret.data;
-  contact_doc.stat = 4;
-  contact_doc.stat_ts = Date.now();
-  contact_doc.stat_reason = 'deleted';
+};
+
+export const unfriend_contact = 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,
+    };
+  }
+};
+
+export const pin_contact = 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) {
+      return contact_ret;
+    }
+    var contact_doc = contact_ret.data;
+    contact_doc.pin = true;
+
+    const contact_save_ret = await db_module.save_couch_doc('xuda_contacts', contact_doc);
+
+    return contact_save_ret;
+  } catch (err) {
+    return {
+      code: -24,
+      data: err.message,
+    };
+  }
+};
+
+export const unpin_contact = 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) {
+      return contact_ret;
+    }
+    var contact_doc = contact_ret.data;
+    contact_doc.pin = false;
 
-  const contact_save_ret = await db_module.save_couch_doc('xuda_contacts', contact_doc);
+    const contact_save_ret = await db_module.save_couch_doc('xuda_contacts', contact_doc);
 
-  return contact_save_ret;
+    return contact_save_ret;
+  } catch (err) {
+    return {
+      code: -24,
+      data: err.message,
+    };
+  }
 };
+
 // invite user
 
 // const contact_ret = await db_module.get_couch_view_raw(
@@ -1449,7 +1687,7 @@ export const archive_contact = async function (req) {
 
 export const add_contact = async function (req, job_id, headers) {
   try {
-    const { uid, email, name, stat, contact_uid, context, source, team_req_id, data } = req;
+    const { uid, email, name, stat, contact_uid, context, source, team_req_id, metadata } = req;
     const contact_ret = await db_module.get_couch_view_raw('xuda_contacts', 'contacts_by_email_address', { key: [uid, email] });
 
     if (contact_ret.rows.length) {
@@ -1477,7 +1715,7 @@ export const add_contact = async function (req, job_id, headers) {
       headers,
       source,
       team_req_id,
-      data,
+      metadata,
     };
     const ret = await db_module.save_couch_doc('xuda_contacts', doc);
 
@@ -1496,6 +1734,12 @@ export const add_contact = async function (req, job_id, headers) {
     return { code: -1, data: err.message };
   }
 };
+
+const get_contact_id = async function (uid, contact_uid) {
+  contact_ret = await db_module.get_couch_view_raw('xuda_contacts', 'contacts_by_contact_uid', { key: [uid, contact_uid] });
+  return contact_ret?.rows?.[0]?.id;
+};
+
 export const update_contact = async function (req) {
   const { uid, email, contact_uid, stat, team_req_id } = req;
   var contact_ret;
@@ -1825,3 +2069,77 @@ export const update_contacts_with_account_changes = async function (uid, changes
     return 'unknown';
   }
 };
+
+export const get_user_card = async function (uid, uid_query) {
+  if (uid === uid_query) return await get_user_contact(uid, uid_query);
+
+  let user_contact_obj; // = { border, card_background, contact_uid, date_created, docType, icon_pattern, name, company, profile_avatar, connection_stat, username, bio, notifications, email, phone };
+
+  const contact_ret = await db_module.get_couch_view_raw('xuda_contacts', 'contacts_by_contact_uid', { key: [uid, uid_query] });
+
+  const contact_id = contact_ret?.rows?.[0]?.id;
+  if (contact_id) {
+    user_contact_obj = await get_contact_info(uid, null, contact_id);
+  } else {
+    user_contact_obj = await get_user_contact(uid, uid_query);
+  }
+  return user_contact_obj;
+};
+
+// export const generate_user_avatar = async function (req, job_id, headers) {
+//   const { uid, account_info } = req;
+//   try {
+//     const ai_module = await import(`${module_path}/ai_module/index.mjs`);
+
+//     ai_module.convert_profile_image_to_avatar({ url: account_info?.profile_picture, uid, account_obj }, job_id, headers);
+
+//     // const account_info = await get_account_name({ uid });
+//     // let username = 'unknown';
+//     // if (account_info) {
+//     //   username = account_info.first_name + ' ' + account_info.last_name;
+
+//     //   if (!username) {
+//     //     username = +account_info.email;
+//     //   }
+//     // }
+
+//     // return username;
+//   } catch (err) {
+//     return 'unknown';
+//   }
+// };
+
+export const onboarding_completed = async function (req, job_id, headers) {
+  const { uid } = req;
+  try {
+    let account_doc = await db_module.get_couch_doc_native('xuda_accounts', uid);
+
+    if (!account_doc.account_info?.profile_picture) {
+      throw new Error(`missing profile_picture`);
+    }
+
+    if (!account_doc.account_info?.profile_avatar) {
+      throw new Error(`missing profile_avatar`);
+    }
+
+    if (!account_doc.account_project_id) {
+      const app_module = await import(`${module_path}/app_module/index.mjs`);
+
+      const ret = await app_module.create_project({ token_ret: req.token_ret, uid, data: { app_name: `Account ${uid} main project`, is_account_project: true, app_plugins_purchased: ['	@xuda.io/xuda-dbs-plugin-xuda', '@xuda.io/xuda-framework-plugin-tailwind'] } }, job_id, headers);
+      if (ret.code > -1) {
+        account_doc.account_project_id = ret.data;
+        const drive_module = await import(`${module_path}/drive_module/index.mjs`);
+        let drive_req = { app_id: account_doc.account_project_id, uid, path: '/' };
+        await drive_module.create_drive_folder_user({ ...drive_req, ...{ folder_name: 'Profile Images', is_system: true } }, job_id, headers);
+        await drive_module.create_drive_folder_user({ ...drive_req, ...{ folder_name: 'Chat Thumbnails', is_system: true } }, job_id, headers);
+        await drive_module.create_drive_folder_user({ ...drive_req, ...{ folder_name: 'Chat Attachments', is_system: true } }, job_id, headers);
+      }
+    }
+
+    account_doc.onboarding = { headers, date_ts: Date.now() };
+    const save_ret = await db_module.save_couch_doc('xuda_accounts', account_doc);
+    return save_ret;
+  } catch (err) {
+    return { code: -44, data: err.message };
+  }
+};

package/package.json

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