@xuda.io/account_module 1.2.154 → 1.2.156

package/index.mjs

@@ -17,34 +17,35 @@ const db_module = await import(`${module_path}/db_module/index.mjs`);
 const jobs_module = await import(`${module_path}/jobs_module/index.mjs`);
 const logs_module = await import(`${module_path}/logs_module/index.mjs`);
 
-export const update_account_info = async (req) => {
-  const marketplace_module = await import(`${module_path}/marketplace_module/index.mjs`);
+export const update_account_info = async function (req) {
+  const marketplace_module = await import(`${module_path}/marketplace_module.index.mjs`);
 
   const { uid } = req;
   const data = req;
 
-  const validate_input = (string, max_length, is_mandatory, is_pass) => {
+  function validate_input(string, max_length, is_mandatory, is_pass) {
     if (!/^[a-zA-Z0-9,.@ ]*$/.test(string) && !is_pass) {
+      // if (!preg_match('^[a-zA-Z0-9,.@ ]*$', string) && !is_pass) {
+
       return -1;
     } else if ((is_mandatory && !string) || string.length < 2) {
       return -2;
-    } else if (string.length > max_length) {
-      // Fixed: string.count -> string.length
+    } else if (string.count > max_length) {
       return -3;
     } else {
       return 1;
     }
-  };
+  }
 
   const ret = await db_module.get_couch_doc('xuda_accounts', uid);
-  let account_obj = ret.data;
+  var account_obj = ret.data;
   account_obj.ts = Date.now();
-  let change = '';
-  let error = {};
+  var change = '';
+  var error = {};
 
   await marketplace_module.marketplace_save_user({ uid });
 
-  _.forEach(data, (val, key) => {
+  _.forEach(data, function (val, key) {
     if (account_obj.account_info[key] !== val) {
       change += ' from ' + account_obj.account_info[key] + ' to ' + val;
 
@@ -56,6 +57,8 @@ export const update_account_info = async (req) => {
         }
       }
       if (key === 'first_name' && !validate_input(val, 35, true, false)) {
+        // print_r(validate_input($val, 35, true, false)<0);
+        // exit;
         error[key] = 'Invalid first name';
       }
       if (key === 'last_name' && !validate_input(val, 35, true, false)) {
@@ -65,9 +68,11 @@ export const update_account_info = async (req) => {
         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 === 'address' && !/^[a-z0-9- ]+$/i.test(val)) {
+        // if (key === "address" && !preg_match('/^[a-z0-9- ]+$/i', $val)) {
         error[key] = 'Invalid address';
       }
       if (key === 'city' && !validate_input(val, 255, false, false)) {
@@ -96,16 +101,8 @@ export const update_account_info = async (req) => {
   delete account_obj.account_info.uid;
 
   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'],
-      },
-    });
+    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'] } });
     if (ret.code > -1) {
       account_obj.account_project_id = ret.data;
     }
@@ -117,13 +114,12 @@ export const update_account_info = async (req) => {
   }
   return ret2;
 };
-
-export const update_account_preferences = async (req) => {
+export const update_account_preferences = async function (req) {
   const account_id = req.account_id;
   const data = req;
 
   const ret = await db_module.get_couch_doc('xuda_accounts', account_id);
-  let account_obj = ret.data;
+  var account_obj = ret.data;
   account_obj.ts = Date.now();
 
   account_obj.preferences = data;
@@ -135,17 +131,17 @@ export const update_account_preferences = async (req) => {
   return { code: 1300, data: account_obj.preferences };
 };
 
-export const save_admin_presets = async (req) => {
+export const save_admin_presets = async function (req) {
   const ret = await db_module.get_couch_doc('xuda_master', req.app_id);
   if (ret.code < 0) {
     return ret;
   }
-  let app_obj = ret.data;
+  var app_obj = ret.data;
   app_obj.deploy_data.admin_presets = req.admin_presets;
   app_obj.deploy_data.preset_id = req.preset_id;
 
   const ret3 = await db_module.save_app_obj(app_obj, null, req.app_id);
-  let obj = {};
+  var obj = {};
   if (ret3.code > -1) {
     obj = {
       code: 1,
@@ -159,25 +155,25 @@ export const save_admin_presets = async (req) => {
   return obj;
 };
 
-export const increment_account_usage = async (req) => {
+export const increment_account_usage = async function (req) {
   const { uid } = req;
 
-  let opt = {};
+  var opt = {};
   if (uid) {
     opt.key = uid;
   }
   const accounts_ret = await db_module.get_couch_view_raw('xuda_accounts', 'all_accounts', opt);
 
-  const drive_module = await import(`${module_path}/drive_module/index.mjs`);
+  const drive_module = await import(`${module_path}/drive_module.index.mjs`);
 
-  const bytesToGB = (bytes) => {
+  function bytesToGB(bytes) {
     return bytes / 1073741824; // or bytes / (1024 ** 3)
-  };
+  }
 
   // check if last calculation made at least hour ago
-  const interval = 3600 * 1000;
+  const interval = 3600 * 1000; //6000; // 3600 * 1000;
 
-  const run_account_drive = async (account_data) => {
+  const run_account_drive = async function (account_data) {
     try {
       const usage_id = await _common.xuda_get_uuid('usage');
 
@@ -185,7 +181,7 @@ export const increment_account_usage = async (req) => {
         key: account_data._id,
       });
 
-      let doc = {
+      var doc = {
         _id: usage_id,
         docType: 'user_drive_usage',
         date_created: new Date(),
@@ -208,7 +204,7 @@ export const increment_account_usage = async (req) => {
         const plan = _conf.PLAN_OBJ[account_data.membership_plan];
         const drive_size_total = account_data.user_drive_size + account_data.studio_drive_size + account_data.workspace_drive_size + account_data.builds_drive_size + account_data.plugins_drive_size;
         if (bytesToGB(drive_size_total) > plan.features.drive) {
-          let price_per_hour = (bytesToGB(drive_size_total) * _conf.PRICE_OBJ.price_per_gb_drive) / _conf.PRICE_OBJ.avg_hours_in_month;
+          var price_per_hour = (bytesToGB(drive_size_total) * _conf.PRICE_OBJ.price_per_gb_drive) / _conf.PRICE_OBJ.avg_hours_in_month;
 
           doc.hours++;
           doc.size = drive_size_total;
@@ -223,7 +219,7 @@ export const increment_account_usage = async (req) => {
     }
   };
 
-  const run_account_apps = async (account_data) => {
+  const run_account_apps = async function (account_data) {
     const apps_ret = await db_module.get_couch_view('xuda_master', 'user_apps', {
       startkey: [account_data._id, ''],
       endkey: [account_data._id, 'ZZZZZ'],
@@ -268,7 +264,7 @@ export const increment_account_usage = async (req) => {
           key: [app.id, app.doc?.app_hosting?.app_server_type || app.doc.app_type],
         });
 
-        let doc = {
+        var doc = {
           _id: usage_id,
           docType: 'app_usage',
           date_created: new Date(),
@@ -282,6 +278,7 @@ export const increment_account_usage = async (req) => {
           ts: 0,
           name: app.value.app_name,
           app_type: app.value.app_type,
+
           subscription_id: account_data.stripe_membership_subscription_id,
         };
 
@@ -301,7 +298,7 @@ export const increment_account_usage = async (req) => {
           doc = usage_ret.rows[0].value;
         }
 
-        let price_per_hour;
+        var price_per_hour;
 
         // check if last calculation made at least hour ago
         const interval = 6000; // 3600 * 1000;
@@ -315,6 +312,7 @@ export const increment_account_usage = async (req) => {
                 price_per_hour = (app.value.app_hosting.disk * _conf.PRICE_OBJ.price_per_gb_backup) / _conf.PRICE_OBJ.avg_hours_in_month;
               } else {
                 // backup of project
+
                 const info_ret = await db_module.get_couch_app_info(doc.app_id);
                 if (info_ret.code > 0) {
                   const size = info_ret.data.sizes.active / 1000 / 1000 / 1000; //gb
@@ -323,22 +321,20 @@ export const increment_account_usage = async (req) => {
               }
               break;
 
-            case 'user_group':
-              {
-                const team_ret = await db_module.get_couch_view('xuda_team', 'user_group_shares_count', {
-                  key: app.id,
-                  reduce: true,
-                  group_level: 1,
-                });
-
-                const team_members = team_ret.data.rows?.[0]?.value || 0;
-                const price_per_hour_team = (team_members * _conf.PRICE_OBJ.price_per_user_group_member) / _conf.PRICE_OBJ.avg_hours_in_month;
-                doc.price_user_group += price_per_hour_team;
-                doc.user_group_members = team_members;
-                doc.user_group_members_accumulated += team_members;
-                doc.user_group_members_avg = doc.user_group_members_accumulated / doc.hours;
-              }
-              break; // Added break
+            case 'user_group': {
+              const team_ret = await db_module.get_couch_view('xuda_team', 'user_group_shares_count', {
+                key: app.id,
+                reduce: true,
+                group_level: 1,
+              });
+
+              const team_members = team_ret.data.rows?.[0]?.value || 0;
+              const price_per_hour_team = (team_members * _conf.PRICE_OBJ.price_per_user_group_member) / _conf.PRICE_OBJ.avg_hours_in_month;
+              doc.price_user_group += price_per_hour_team;
+              doc.user_group_members = team_members;
+              doc.user_group_members_accumulated += team_members;
+              doc.user_group_members_avg = doc.user_group_members_accumulated / doc.hours;
+            }
 
             default:
               // deployments,vps,master,instances and datacenters
@@ -347,6 +343,7 @@ export const increment_account_usage = async (req) => {
               doc.app_hosting = app.doc.app_hosting;
               doc.server_type = app.doc.app_hosting.app_server_type;
               price_per_hour = app.doc.app_hosting.price / _conf.PRICE_OBJ.avg_hours_in_month;
+
               break;
           }
           doc.price += price_per_hour;
@@ -365,7 +362,7 @@ export const increment_account_usage = async (req) => {
 
   // iterate on all status account except deleted accounts
   for await (let val of accounts_ret.rows) {
-    let account_data = val.value;
+    var account_data = val.value;
 
     const size_ret = await drive_module.get_drive_size({
       uid: account_data._id,
@@ -387,12 +384,26 @@ export const increment_account_usage = async (req) => {
   }
 };
 
-export const get_account_data = async (req) => {
-  let { uid, enforce_usage } = req;
+export const get_account_data = async function (req) {
+  var { uid, enforce_usage } = req;
+  // const get_info = async function () {
+  // const get_stripe_subscription = async function (subscription_id) {
+  //   if (!subscription_id) {
+  //     return { code: -1, data: "subscription_id missing" };
+  //   }
+  //   try {
+  //     const ret = await stripe.subscriptions.retrieve(subscription_id);
+
+  //     return { code: 1, data: ret };
+  //   } catch (err) {
+  //     return { code: -400, data: err };
+  //   }
+  // };
 
   try {
     const { data: acc_obj } = await db_module.get_couch_doc('xuda_accounts', uid);
-    let ret = { code: 1 };
+    // const account_obj= account_ret.data
+    var ret = { code: 1 };
     ret.data = {
       _id: acc_obj._id,
       account_info: acc_obj.account_info,
@@ -432,15 +443,38 @@ export const get_account_data = async (req) => {
       stripe_connect_account_status: acc_obj?.stripe_connect_account_status,
     };
 
+    // if (account_ret.data.stripe_membership_subscription_id) {
+    //   const subscription_ret = await get_stripe_subscription(
+    //     account_ret.data.stripe_membership_subscription_id
+    //   );
+
+    //   if (subscription_ret.code > 0) {
+    //     ret.data.stripe_membership_subscription_id = subscription_ret.data.id;
+    //   }
+    // }
+
+    // if (!acc_obj.account_project_id && req.token_ret) {
+    //   let = account_obj = acc_obj;
+    //   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 } });
+    //   if (ret.code > -1) {
+    //     account_obj.account_project_id = ret.data;
+    //     const ret2 = await db_module.save_couch_doc('xuda_accounts', account_obj);
+    //   }
+    // }
+
     return ret;
   } catch (error) {
     return { code: -1, data: error };
   }
+  // };
+
+  // return get_info();
 };
 
-export const get_account_projects = async (req) => {
+export const get_account_projects = async function (req) {
   const { uid } = req;
-  let opt = {
+  var opt = {
     key: uid,
   };
 
@@ -448,42 +482,40 @@ export const get_account_projects = async (req) => {
     opt = {};
   }
 
-  let ret = await db_module.get_couch_view('xuda_master', 'user_projects', opt);
+  var ret = await db_module.get_couch_view('xuda_master', 'user_projects', opt);
 
   return ret;
 };
 
-export const get_account_datacenters = async (req) => {
+export const get_account_datacenters = async function (req) {
   return await db_module.get_couch_view('xuda_master', 'user_datacenters', {
     key: req.uid,
   });
 };
-
-export const get_account_deployments = async (req) => {
+export const get_account_deployments = async function (req) {
   return await db_module.get_couch_view('xuda_master', 'user_deployments', {
     key: req.uid,
   });
 };
-
-export const get_account_instances = async (req) => {
+export const get_account_instances = async function (req) {
   return await db_module.get_couch_view('xuda_master', 'user_all_instances', {
     key: req.uid,
   });
 };
 
-export const get_account_info = async (req) => {
-  return await get_account_data({
+export const get_account_info = async function (req) {
+  return await this.get_account_data({
     uid: req.uid,
     enforce_usage: req.enforce_usage,
   });
 };
 
-export const get_account_name = async (req) => {
+export const get_account_name = async function (req) {
   const data = await db_module.get_couch_doc('xuda_accounts', req.uid_query);
   if (data.code < 0) {
     return data;
   }
-  let obj = {
+  var obj = {
     first_name: '',
     last_name: '',
     email: '',
@@ -504,14 +536,14 @@ export const get_account_name = async (req) => {
   return { code: 1, data: obj };
 };
 
-export const account_validate_username = async (req) => {
+export const account_validate_username = async function (req) {
   const opt = {
     selector: { 'account_info.username': req.username },
     fields: ['_id'],
     limit: 1,
   };
 
-  let ret = await db_module.find_couch_query('xuda_accounts', opt);
+  var ret = await db_module.find_couch_query('xuda_accounts', opt);
 
   if (ret.docs.length) {
     return { code: -400, data: 'User exist' };
@@ -520,7 +552,17 @@ export const account_validate_username = async (req) => {
   }
 };
 
-export const verify_account = async (req) => {
+// export const get_account_activity = async function (req) {
+//   return await db_module.get_couch_view(
+//     "xuda_activity",
+//     "activity_per_account",
+//     {
+//       key: req.uid,
+//     }
+//   );
+// };
+
+export const verify_account = async function (req) {
   const { account_id } = req;
   if (!account_id) {
     return { code: -10, data: 'Missing id' };
@@ -531,7 +573,7 @@ export const verify_account = async (req) => {
   if (ret.code < 0) {
     return { code: -1, data: 'account not found' };
   }
-  let obj = ret.data;
+  var obj = ret.data;
   obj.stat = 3;
   const ret_acc = await db_module.save_couch_doc('xuda_accounts', obj);
   if (ret.code < 0) {
@@ -540,7 +582,7 @@ export const verify_account = async (req) => {
   return { code: 1, data: ret_acc.data };
 };
 
-export const validate_user_plan = async (req) => {
+export const validate_user_plan = async function (req) {
   const { account_id, app_obj } = req;
 
   const apps_ret = await db_module.get_couch_view('xuda_master', 'user_apps_count', {
@@ -550,7 +592,7 @@ export const validate_user_plan = async (req) => {
     group_level: 2,
   });
 
-  let ret_obj = _.reduce(
+  var ret_obj = _.reduce(
     apps_ret.data.rows,
     (ret, value) => {
       ret[value.key[1]] = value.value;
@@ -563,7 +605,8 @@ export const validate_user_plan = async (req) => {
   if (ret.code < 0) {
     return ret;
   }
-  let plan = _conf.PLAN_OBJ[ret.data.membership_plan];
+  var plan = _conf.PLAN_OBJ[ret.data.membership_plan];
+  // get plan from user
 
   if (!plan) {
     return { code: -7, data: 'error - no plan defined' };
@@ -578,6 +621,7 @@ export const validate_user_plan = async (req) => {
   }
 
   // validate number of team members
+
   const user_active_app_requests_count_ret = await db_module.get_couch_view('xuda_team', 'user_active_app_requests_count', {
     key: account_id,
     reduce: true,
@@ -594,23 +638,23 @@ export const validate_user_plan = async (req) => {
   return { code: 1, data: ret.data };
 };
 
-export const get_hosting_plan = (req) => {
+export const get_hosting_plan = function (req) {
   const { app_obj } = req;
   if (app_obj.app_hosting) {
     if (_conf.PRICE_OBJ.server_slugs[app_obj.app_hosting.app_server_type]) {
       return _conf.PRICE_OBJ.server_slugs[app_obj.app_hosting.app_server_type];
     }
-    // debugger;
+    debugger;
     console.error('error: ' + app_obj.app_hosting.app_server_type + ' not found in PRICE_OBJ.server_slugs');
     return { cpu: 0, price: 0 };
   }
 };
 
-export const get_cpu = async (req) => {
+export const get_cpu = async function (req) {
   const { app_obj } = req;
-  let cpu = 1;
+  var cpu = 1;
   if (app_obj.app_hosting) {
-    const hosting_plan = get_hosting_plan({
+    const hosting_plan = this.get_hosting_plan({
       app_obj,
     });
 
@@ -621,7 +665,7 @@ export const get_cpu = async (req) => {
   return cpu;
 };
 
-const get_account_log_object = (body, status, service, source, response_data, ip, headers, security) => {
+const get_account_log_object = function (body, status, service, source, response_data, ip, headers, security) {
   return {
     uid: body.uid,
     ip,
@@ -639,31 +683,37 @@ const get_account_log_object = (body, status, service, source, response_data, ip
   };
 };
 
-export const add_account_log_util = (body, status, service, source, response_data, ip, headers) => {
+export const add_account_log_util = async function (body, status, service, source, response_data, ip, headers) {
+  // non error log
+  // if (status < 400) {
+  // console.log("error", "add_account_log_util", service);
+
   if (!_conf.cpi_methods?.[service]) return;
   if (_conf.cpi_methods?.[service]?.private) return;
   const security = _conf.cpi_methods?.[service].security;
   if (!security) {
     if (service.substr(0, 4) === 'get_' && !body.api_pk && !body.api_sk) return;
   }
-
+  // }
+  const logs_module = await import(`${module_path}/logs_module.index.mjs`);
   logs_module.add_account_log(get_account_log_object(body, status, service, source, response_data, ip, headers, security));
 };
 
-export const save_ssh_key = async (req) => {
+export const save_ssh_key = async function (req) {
   const { uid, _id, ssh_key_name, ssh_key_content } = req;
 
-  const isValidSSHPublicKey = (sshPublicKey) => {
+  function isValidSSHPublicKey(sshPublicKey) {
     // Regular expression to match SSH public keys
     const sshKeyRegex = /^ssh-(rsa|ed25519|ecdsa-sha2-nistp[0-9]+) [A-Za-z0-9+/]+[=]{0,3}( [^@]+@[^@]+)?$/;
+
     return sshKeyRegex.test(sshPublicKey);
-  };
+  }
 
   if (!isValidSSHPublicKey(ssh_key_content)) {
     return { code: -1, data: 'invalid ssh key' };
   }
 
-  let doc = {
+  var doc = {
     uid,
     docType: 'ssh_key',
     date_created_ts: Date.now(),
@@ -689,15 +739,14 @@ export const save_ssh_key = async (req) => {
 
   return save_ret;
 };
-
-export const delete_ssh_key = async (req) => {
+export const delete_ssh_key = async function (req) {
   const { ssh_key_id } = req;
 
   const ret = await db_module.get_couch_doc('xuda_ssh_keys', ssh_key_id);
   if (ret.code < 0) {
     return ret;
   }
-  let doc = ret.data;
+  var doc = ret.data;
   doc.date_updated_ts = Date.now();
   doc.stat = 4;
 
@@ -706,7 +755,7 @@ export const delete_ssh_key = async (req) => {
   return save_ret;
 };
 
-export const get_ssh_keys = async (req) => {
+export const get_ssh_keys = async function (req) {
   const { uid, _id } = req;
 
   let opt = {
@@ -717,11 +766,15 @@ export const get_ssh_keys = async (req) => {
     opt._id = _id;
   }
 
-  let ret = await db_module.find_couch_query('xuda_ssh_keys', opt);
+  var ret = await db_module.find_couch_query('xuda_ssh_keys', opt);
   return ret;
 };
 
-export const search_users = async (req) => {
+export const search_users = async function (req) {
+  // search
+  // skip
+  // limit
+  // bookmark
   try {
     if (!_conf.superuser_account_ids.includes(req.uid)) {
       throw new Error('user is not authorized for this method');
@@ -736,19 +789,48 @@ export const search_users = async (req) => {
       selector = {
         ...selector,
         $or: [
-          { 'account_info.first_name': { $regex: `(?i)${req.search}` } },
-          { 'account_info.last_name': { $regex: `(?i)${req.search}` } },
-          { 'account_info.company_name': { $regex: `(?i)${req.search}` } },
-          { 'account_info.tel': { $regex: `(?i)${req.search}` } },
-          { 'account_info.email': { $regex: `(?i)${req.search}` } },
-          { 'account_info.address': { $regex: `(?i)${req.search}` } },
-          { _id: { $regex: `(?i)${req.search}` } },
+          {
+            'account_info.first_name': {
+              $regex: `(?i)${req.search}`,
+            },
+          },
+          {
+            'account_info.last_name': {
+              $regex: `(?i)${req.search}`,
+            },
+          },
+          {
+            'account_info.company_name': {
+              $regex: `(?i)${req.search}`,
+            },
+          },
+          {
+            'account_info.tel': {
+              $regex: `(?i)${req.search}`,
+            },
+          },
+          {
+            'account_info.email': {
+              $regex: `(?i)${req.search}`,
+            },
+          },
+          {
+            'account_info.address': {
+              $regex: `(?i)${req.search}`,
+            },
+          },
+          {
+            _id: {
+              $regex: `(?i)${req.search}`,
+            },
+          },
         ],
       };
     }
 
     const opt = {
       selector,
+
       limit: req.limit ? req.limit : 99999,
     };
 
@@ -761,23 +843,30 @@ export const search_users = async (req) => {
     }
 
     try {
-      let ret = await db_module.find_couch_query('xuda_accounts', opt);
-      return { code: 1, data: ret };
+      var ret = await db_module.find_couch_query('xuda_accounts', opt);
+
+      return {
+        code: 1,
+        data: ret,
+      };
     } catch (e) {
-      return { code: -400, data: e };
+      return {
+        code: -400,
+        data: e,
+      };
     }
   } catch (err) {
     return { code: -1, data: err.message };
   }
 };
 
-export const read_emails = async (req) => {
+export const read_emails = async function (req) {
   const { uid, email_account_address, email_account_id, accessToken, vendor } = req;
 
-  const email_module = await import(`${module_path}/email_module/index.mjs`);
+  const email_module = await import(`${module_path}/email_module.index.mjs`);
 
-  const read_mailbox = async (mailbox_path, mailbox_name, is_sent) => {
-    let emails_ret = await db_module.find_couch_query('xuda_emails', {
+  const read_mailbox = async function (mailbox_path, mailbox_name, is_sent) {
+    var emails_ret = await db_module.find_couch_query('xuda_emails', {
       selector: {
         docType: 'email',
         uid,
@@ -790,7 +879,7 @@ export const read_emails = async (req) => {
       sort: [{ 'message.seq': 'desc' }],
     });
 
-    let imap_ret;
+    var imap_ret;
 
     const seq = emails_ret?.docs?.[0]?.message?.seq || 1;
     imap_ret = await email_module.query_imap({
@@ -801,9 +890,9 @@ export const read_emails = async (req) => {
       accessToken,
     });
 
-    let senders = {};
-    let recipient = {};
-    let docs = [];
+    var senders = {};
+    var recipient = {};
+    var docs = [];
 
     for await (let message of imap_ret) {
       delete message.modseq;
@@ -830,6 +919,23 @@ export const read_emails = async (req) => {
       await db_module.save_couch_bulk_docs('xuda_emails', docs);
 
       for await (let [email, name] of Object.entries(is_sent ? recipient : senders)) {
+        // const contact_ret = await db_module.get_couch_view_raw(
+        //   "xuda_contacts",
+        //   "contacts_by_email_address",
+        //   { key: [uid, email] }
+        // );
+
+        // if (!contact_ret.rows.length) {
+        //   await db_module.save_couch_doc("xuda_contacts", {
+        //     _id: await _common.xuda_get_uuid("contact"),
+        //     email: [email],
+        //     name,
+        //     stat: 1,
+        //     date_created: Date.now(),
+        //     docType: "contact",
+        //     uid,
+        //   });
+        // }
         await add_contact({ uid, name, email });
       }
     }
@@ -847,6 +953,7 @@ export const read_emails = async (req) => {
         if (!['[Gmail]/Starred', '[Gmail]/Drafts', '[Gmail]/All Mail', '[Gmail]/Spam', '[Gmail]/Trash', '[Gmail]', '[Gmail]/Important'].includes(mailbox_obj.path)) {
           await read_mailbox(mailbox_obj.path, mailbox_obj.name, mailbox_obj.path === '[Gmail]/Sent Mail');
         }
+
         break;
 
       default:
@@ -858,11 +965,11 @@ export const read_emails = async (req) => {
   }
 };
 
-export const get_email_accounts = async (req) => {
+export const get_email_accounts = async function (req) {
   const { uid, stat } = req;
 
-  const db_module = await import(`${module_path}/db_module/index.mjs`);
-  let email_account_ret = await db_module.find_couch_query('xuda_emails', {
+  const db_module = await import(`${module_path}/db_module.index.mjs`);
+  var email_account_ret = await db_module.find_couch_query('xuda_emails', {
     selector: {
       docType: 'email_account',
       uid,
@@ -872,23 +979,28 @@ export const get_email_accounts = async (req) => {
   return { code: 1, data: email_account_ret };
 };
 
-const generate_gmail_access_token = async (email_account) => {
-  const response = await fetch('https://oauth2.googleapis.com/token', {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({
-      refresh_token: email_account.authorization_data.refresh_token,
-      client_id: _conf.gmail.clientId,
-      client_secret: _conf.gmail.clientSecret,
-      grant_type: 'refresh_token',
-    }),
+const generate_gmail_access_token = async function (email_account) {
+  return new Promise((resolve, reject) => {
+    fetch('https://oauth2.googleapis.com/token', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        refresh_token: email_account.authorization_data.refresh_token,
+        client_id: _conf.gmail.clientId,
+        client_secret: _conf.gmail.clientSecret,
+        grant_type: 'refresh_token',
+      }),
+    })
+      .then((response) => response.json())
+      .then((data) => {
+        resolve(data);
+      });
   });
-  return await response.json();
 };
 
-export const find_contact_duplicates = async (req) => {
+export const find_contact_duplicates = async function (req) {
   const { uid, name } = req;
-  let opt = {
+  var opt = {
     selector: {
       docType: 'contact',
       stat: { $lt: 4 },
@@ -901,8 +1013,8 @@ export const find_contact_duplicates = async (req) => {
     opt.selector.name = name;
   }
   const contact_ret = await db_module.find_couch_query('xuda_contacts', opt);
-  let duplicates = {};
-  for (let contact of contact_ret.docs) {
+  var duplicates = {};
+  for (contact of contact_ret.docs) {
     if (!duplicates[contact.name]) {
       duplicates[contact.name] = [];
     }
@@ -922,9 +1034,9 @@ export const find_contact_duplicates = async (req) => {
   return { code: 1, data: duplicates };
 };
 
-export const merge_contact = async (req) => {
+export const merge_contact = async function (req) {
   const { uid, name } = req;
-  let duplicate_ret = await find_contact_duplicates({
+  var duplicate_ret = await find_contact_duplicates({
     uid,
     name,
   });
@@ -932,13 +1044,13 @@ export const merge_contact = async (req) => {
     return duplicate_ret;
   }
 
-  let duplicate_arr = duplicate_ret?.data?.[name] || [];
+  var duplicate_arr = duplicate_ret?.data?.[name] || [];
   if (!duplicate_arr.length) {
     return { code: 1, data: 'no merge performed' };
   }
-  let contact_to_merge;
-  let contact_to_delete = [];
-  for (let contact of duplicate_arr) {
+  var contact_to_merge;
+  var contact_to_delete = [];
+  for (contact of duplicate_arr) {
     if (contact.primary) {
       contact_to_merge = contact._id;
       continue;
@@ -949,7 +1061,7 @@ export const merge_contact = async (req) => {
   if (!contact_to_merge) {
     // find best match for primary
     for (let [i, contact_id] of Object.entries(contact_to_delete)) {
-      let contact_obj = duplicate_arr.find((e) => e._id === contact_id);
+      var contact_obj = duplicate_arr.find((e) => e._id === contact_id);
 
       if (contact_obj.name && !['spam', 'newsletter', 'noreply', 'no-reply'].includes(contact_obj.email?.[0]?.toLowerCase())) {
         contact_to_merge = contact_id;
@@ -969,13 +1081,13 @@ export const merge_contact = async (req) => {
   if (primary_contact_ret.code < 0) {
     return primary_contact_ret;
   }
-  let primary_contact_doc = primary_contact_ret.data;
+  var primary_contact_doc = primary_contact_ret.data;
 
   primary_contact_doc.stat_ts = Date.now();
   primary_contact_doc.stat_reason = 'merge';
 
   for (let contact_id of contact_to_delete) {
-    let email_address = duplicate_arr.find((e) => e._id === contact_id).email[0];
+    var email_address = duplicate_arr.find((e) => e._id === contact_id).email[0];
 
     primary_contact_doc.email.push(email_address);
   }
@@ -988,19 +1100,19 @@ export const merge_contact = async (req) => {
       continue;
     }
 
-    let contact_doc = contact_ret.data;
+    var contact_doc = contact_ret.data;
     contact_doc.stat = 4;
     contact_doc.stat_ts = Date.now();
     contact_doc.stat_reason = 'merge';
     await db_module.save_couch_doc('xuda_contacts', contact_doc);
   }
 
-  return primary_contact_save_ret;
+  return primary_contact_save_ret; //{ code: 1, data: duplicate_arr };
 };
 
-export const get_contacts = async (req) => {
+export const get_contacts = async function (req) {
   const { uid, name, limit, skip, bookmark } = req;
-  let opt = {
+  var opt = {
     selector: {
       docType: 'contact',
       uid,
@@ -1025,14 +1137,14 @@ export const get_contacts = async (req) => {
   return contacts_ret;
 };
 
-export const delete_contact = async (req) => {
+export const delete_contact = async function (req) {
   const { _id } = req;
 
   const contact_ret = await db_module.get_couch_doc('xuda_contacts', _id);
   if (contact_ret.code < 0) {
     return contact_ret;
   }
-  let contact_doc = contact_ret.data;
+  var contact_doc = contact_ret.data;
 
   contact_doc.stat_ts = Date.now();
   contact_doc.stat_reason = 'deleted';
@@ -1041,8 +1153,20 @@ export const delete_contact = async (req) => {
 
   return contact_save_ret;
 };
-
-export const add_contact = async (req) => {
+// invite user
+
+// const contact_ret = await db_module.get_couch_view_raw(
+//   "xuda_contacts",
+//   "contacts_by_name_count",
+//   {
+//     startkey: [uid, ""],
+//     endkey: [uid, "ZZZZZZZZZZ"],
+//     reduce: true,
+//     group_level: 2,
+//   }
+// );
+
+export const add_contact = async function (req) {
   const { uid, email, name, stat, contact_uid, req_id } = req;
   const contact_ret = await db_module.get_couch_view_raw('xuda_contacts', 'contacts_by_email_address', { key: [uid, email] });
 
@@ -1062,17 +1186,16 @@ export const add_contact = async (req) => {
   }
   return { code: -1, data: 'contact already exist active or deleted' };
 };
-
-export const update_contact = async (req) => {
+export const update_contact = async function (req) {
   const { uid, email, contact_uid, stat, req_id } = req;
-  let contact_ret;
+  var contact_ret;
   if (email) {
     contact_ret = await db_module.get_couch_view_raw('xuda_contacts', 'contacts_by_email_address', { key: [uid, email] });
   } else if (contact_uid) {
     contact_ret = await db_module.get_couch_view_raw('xuda_contacts', 'contacts_by_contact_uid', { key: [uid, contact_uid] });
   }
   if (contact_ret.rows.length) {
-    let doc = contact_ret.rows[0].value;
+    var doc = contact_ret.rows[0].value;
     if (stat) {
       doc.stat = stat;
       doc.stat_ts = Date.now();
@@ -1084,25 +1207,26 @@ export const update_contact = async (req) => {
   }
   return { code: -1, data: 'contact not found' };
 };
-
-export const invite_user = async (req) => {
+export const invite_user = async function (req) {
   const { email, name, uid } = req;
 
-  const team_module = await import(`${module_path}/team_module/index.mjs`);
+  const team_module = await import(`${module_path}/team_module.index.mjs`);
   const ret = await team_module.create_team_request({
     email,
     access_type: 'contact',
     uid,
   });
+
+  // return { code: -1, data: "contact already exist active or deleted" };
 };
 
-export const get_account_rt_info = async (uid) => {
+export const get_account_rt_info = async function (uid) {
   const doc_ret = await db_module.get_couch_doc('xuda_accounts', uid);
   if (doc_ret.code < 0) {
     console.error('get_account_rt_info', doc_ret);
     return {};
   }
-  let account_info = doc_ret.data.account_info;
+  var account_info = doc_ret.data.account_info;
 
   delete account_info.user_id;
 
@@ -1110,7 +1234,106 @@ export const get_account_rt_info = async (uid) => {
   return account_info;
 };
 
-const get_prices = (uid, item) => {
+// export const validate_account_topup = async function (uid, items = []) {
+//   const stripe_module = await import(`${module_path}/stripe_module.index.mjs`);
+
+//   const { code, data } = await stripe_module.get_billing_metrics({ uid });
+//   if (code < 0) {
+//     throw new Error(data);
+//   }
+//   let topup = 0;
+//   for (const item of items) {
+//     topup += get_prices(uid, item);
+//   }
+
+//   // if ((!data?.customer_obj?.default_source, { billing_problem: true, topup })) {
+//   //   throw new Error("no card on file");
+//   // }
+//   debugger;
+//   if (data?.balance?.past_due) {
+//     throw new Error(`past_due ${data?.balance?.past_due}`, {
+//       billing_problem: true,
+//       topup,
+//     });
+//   }
+
+//   const balance = data?.balance?.account || 0; // minus balance represents positive balance
+
+//   if (balance > 0) {
+//     throw new Error(`negative balance ${-balance}`, {
+//       billing_problem: true,
+//       topup: topup - balance, // ask for whole balance
+//     });
+//   }
+
+//   if (topup + balance > 0) {
+//     throw new Error(`not enough balance ${topup + balance}`, {
+//       billing_problem: true,
+//       topup, //-(topup + balance)
+//     });
+//   }
+
+//   return true;
+// };
+
+export const validate_account_topup = async function (uid, items = []) {
+  const stripe_module = await import(`${module_path}/stripe_module.index.mjs`);
+
+  const { code, data } = await stripe_module.get_billing_metrics({ uid });
+  if (code < 0) {
+    throw new Error(data);
+  }
+  let topup = 0;
+  for (const item of items) {
+    topup += get_prices(uid, item);
+  }
+
+  if (!data?.customer_obj?.default_source) {
+    let err = new Error('no card on file');
+    err.code = -90;
+    err.billing_problem = true;
+    throw err;
+    // throw new Error('no card on file');
+  }
+
+  if (data?.balance?.past_due) {
+    let err = new Error(`past_due ${data.balance.past_due}`);
+    err.code = -91;
+    err.billing_problem = true;
+    err.topup = topup + data.balance.past_due;
+    err.open_invoices = data?.open_invoices;
+    throw err;
+  }
+  // if (data?.balance?.past_due) {
+  //   let err = new Error(`past_due ${data?.balance?.past_due}`);
+  //   err.code = -91;
+  //   err.billing_problem = true;
+  //   err.topup = topup;
+  //   throw err;
+  // }
+
+  const balance = data?.balance?.account || 0; // minus balance represents positive balance
+
+  if (balance > 0) {
+    let err = new Error(`negative balance ${-balance}`);
+    err.code = -92;
+    err.billing_problem = true;
+    err.topup = topup - balance; // ask for whole balance
+    throw err;
+  }
+
+  if (topup + balance > 0) {
+    let err = new Error(`not enough balance ${topup + balance}`);
+    err.code = -93;
+    err.billing_problem = true;
+    err.topup = topup;
+    throw err;
+  }
+
+  return true;
+};
+
+const get_prices = function (uid, item) {
   let price;
 
   switch (item) {
@@ -1172,56 +1395,7 @@ const get_prices = (uid, item) => {
   return price;
 };
 
-export const validate_account_topup = async (uid, items = []) => {
-  const stripe_module = await import(`${module_path}/stripe_module/index.mjs`);
-
-  const { code, data } = await stripe_module.get_billing_metrics({ uid });
-  if (code < 0) {
-    throw new Error(data);
-  }
-  let topup = 0;
-  for (const item of items) {
-    topup += get_prices(uid, item);
-  }
-
-  if (!data?.customer_obj?.default_source) {
-    let err = new Error('no card on file');
-    err.code = -90;
-    err.billing_problem = true;
-    throw err;
-  }
-
-  if (data?.balance?.past_due) {
-    let err = new Error(`past_due ${data.balance.past_due}`);
-    err.code = -91;
-    err.billing_problem = true;
-    err.topup = topup + data.balance.past_due;
-    err.open_invoices = data?.open_invoices;
-    throw err;
-  }
-
-  const balance = data?.balance?.account || 0; // minus balance represents positive balance
-
-  if (balance > 0) {
-    let err = new Error(`negative balance ${-balance}`);
-    err.code = -92;
-    err.billing_problem = true;
-    err.topup = topup - balance; // ask for whole balance
-    throw err;
-  }
-
-  if (topup + balance > 0) {
-    let err = new Error(`not enough balance ${topup + balance}`);
-    err.code = -93;
-    err.billing_problem = true;
-    err.topup = topup;
-    throw err;
-  }
-
-  return true;
-};
-
-export const create_account_oauth_link = async (req, job_id) => {
+export const create_account_oauth_link = async function (req, job_id) {
   const link = `https://accounts.google.com/o/oauth2/v2/auth?scope=https://mail.google.com/&access_type=offline&include_granted_scopes=true&response_type=code&state=${req.uid}&redirect_uri=https://${_conf.is_debug ? 'dev.' : ''}xuda.io/oauth&client_id=${_conf.gmail.clientId}`;
   await jobs_module.update_job(
     {
@@ -1232,9 +1406,70 @@ export const create_account_oauth_link = async (req, job_id) => {
     global[`_account_module_ch`],
   );
   await _utils.delay(20000);
-  // debugger;
+  debugger;
   return {
     code: 1,
     data: link,
   };
 };
+
+// setTimeout(async () => {
+//   const uid = "0489f946c213947316647b468f029ed9"; //"aecc740881fd0a35098c738652000fab";
+
+//   // // clear data
+//   // const contact_ret = await db_module.find_couch_query("xuda_contacts", {
+//   //   selector: {
+//   //     docType: "contact",
+//   //   },
+//   //   limit: 99999,
+//   // });
+//   // var contact_docs = [];
+//   // for (let val of contact_ret.docs) {
+//   //   val._deleted = true;
+//   //   contact_docs.push(val);
+//   // }
+//   // await db_module.save_couch_bulk_docs("xuda_contacts", contact_docs);
+
+//   // const emails_ret = await db_module.find_couch_query("xuda_emails", {
+//   //   selector: {
+//   //     docType: "email",
+//   //   },
+//   //   limit: 99999,
+//   // });
+//   // var email_docs = [];
+//   // for (let val of emails_ret.docs) {
+//   //   val._deleted = true;
+//   //   email_docs.push(val);
+//   // }
+
+//   // await db_module.save_couch_bulk_docs("xuda_emails", email_docs);
+
+//   ///////////////////////////////////
+//   return;
+//   const email_account_ret = await  get_email_accounts({
+//     uid,
+//   });
+
+//   var accessToken;
+//   for await (let email_account of email_account_ret.data.docs) {
+//     switch (email_account.vendor) {
+//       case "gmail":
+//         const ret = await generate_gmail_access_token(email_account);
+//         accessToken = ret.access_token;
+//         break;
+
+//       default:
+//         break;
+//     }
+
+//      read_emails({
+//       uid,
+//       email_account_address: email_account.email,
+//       accessToken,
+//       email_account_id: email_account._id,
+//       vendor: email_account.vendor,
+//     });
+//   }
+
+//   // console.log(await  get_contact({ uid, name: "bo" }));
+// }, 2000);

package/package.json

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