@xuda.io/account_module 1.2.144 → 1.2.146

package/index.mjs

@@ -0,0 +1,1239 @@
+import path from 'path';
+import _ from 'lodash';
+import { createRequire } from 'module';
+
+// Initialize require for dynamic paths based on environment variables
+const require = createRequire(import.meta.url);
+
+// Load Globals and Config
+global._conf = require(path.join(process.env.XUDA_HOME, process.env.XUDA_CONFIG));
+
+const _common = require(path.join(process.env.XUDA_HOME, 'common', 'xuda_node_common.js'));
+const _utils = require(path.join(process.env.XUDA_HOME, 'common', 'xuda-cpi-utils.js'));
+
+// Module Paths
+const module_path = path.join(process.env.XUDA_HOME, 'cpi') + (!_conf.is_debug ? '/node_modules/@xuda.io' : '');
+const db_module = require(`${module_path}/db_module`);
+const jobs_module = require(`${module_path}/jobs_module`);
+
+export const update_account_info = async (req) => {
+  const marketplace_module = require(`${module_path}/marketplace_module`);
+
+  const { uid } = req;
+  const data = req;
+
+  const validate_input = (string, max_length, is_mandatory, is_pass) => {
+    if (!/^[a-zA-Z0-9,.@ ]*$/.test(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
+      return -3;
+    } else {
+      return 1;
+    }
+  };
+
+  const ret = await db_module.get_couch_doc('xuda_accounts', uid);
+  let account_obj = ret.data;
+  account_obj.ts = Date.now();
+  let change = '';
+  let error = {};
+
+  await marketplace_module.marketplace_save_user({ uid });
+
+  _.forEach(data, (val, key) => {
+    if (account_obj.account_info[key] !== val) {
+      change += ' from ' + account_obj.account_info[key] + ' to ' + val;
+
+      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) {
+          error[key] = 'Invalid company';
+        }
+      }
+      if (key === 'first_name' && !validate_input(val, 35, true, false)) {
+        error[key] = 'Invalid first name';
+      }
+      if (key === 'last_name' && !validate_input(val, 35, true, false)) {
+        error[key] = 'Invalid last name';
+      }
+      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)) {
+        error[key] = 'Invalid phone number';
+      }
+      if (key === 'address' && !/^[a-z0-9- ]+$/i.test(val)) {
+        error[key] = 'Invalid address';
+      }
+      if (key === 'city' && !validate_input(val, 255, false, false)) {
+        error[key] = 'Invalid city';
+      }
+      if (key === 'state' && !validate_input(val, 50, false, false)) {
+        error[key] = 'Invalid state';
+      }
+      if (key === 'zip' && validate_input(val, 9, false, false) < 0) {
+        error[key] = 'Invalid zip';
+      }
+      if (key === 'country' && !validate_input(val, 55, false, false)) {
+        error[key] = 'Invalid country';
+      }
+    }
+  });
+
+  if (!_.isEmpty(error)) {
+    return { code: -1310, data: error };
+  }
+  if (!change) {
+    return { code: 1300, data: 'no change' };
+  }
+  delete account_obj.account_info.gtp_token;
+  delete account_obj.account_info.client_id;
+  delete account_obj.account_info.uid;
+
+  if (!account_obj.account_project_id) {
+    const app_module = require(`${module_path}/app_module`);
+    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;
+    }
+  }
+
+  const ret2 = await db_module.save_couch_doc('xuda_accounts', account_obj);
+  if (ret2.code > 0) {
+    return { code: 1300, data: 'ok' };
+  }
+  return ret2;
+};
+
+export const update_account_preferences = async (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;
+  account_obj.ts = Date.now();
+
+  account_obj.preferences = data;
+
+  const ret1 = await db_module.save_couch_doc('xuda_accounts', account_obj);
+  if (ret1.code < 0) {
+    return ret1;
+  }
+  return { code: 1300, data: account_obj.preferences };
+};
+
+export const save_admin_presets = async (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;
+  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 = {};
+  if (ret3.code > -1) {
+    obj = {
+      code: 1,
+      data: 'ok',
+      app_obj: _common.get_clean_app_obj(app_obj),
+    };
+  } else {
+    obj = ret3;
+  }
+
+  return obj;
+};
+
+export const increment_account_usage = async (req) => {
+  const { uid } = req;
+
+  let opt = {};
+  if (uid) {
+    opt.key = uid;
+  }
+  const accounts_ret = await db_module.get_couch_view_raw('xuda_accounts', 'all_accounts', opt);
+
+  const drive_module = require(`${module_path}/drive_module`);
+
+  const bytesToGB = (bytes) => {
+    return bytes / 1073741824; // or bytes / (1024 ** 3)
+  };
+
+  // check if last calculation made at least hour ago
+  const interval = 3600 * 1000;
+
+  const run_account_drive = async (account_data) => {
+    try {
+      const usage_id = await _common.xuda_get_uuid('usage');
+
+      const usage_ret = await db_module.get_couch_view_raw('xuda_usage', 'open_drive_usage', {
+        key: account_data._id,
+      });
+
+      let doc = {
+        _id: usage_id,
+        docType: 'user_drive_usage',
+        date_created: new Date(),
+        stat: 1,
+        uid: account_data._id,
+        stripe_customer_id: account_data.stripe_customer_id,
+        account_name: account_data.account_info.first_name + ' ' + account_data.account_info.last_name,
+        size: 0,
+        price: 0,
+        hours: 0,
+        ts: 0,
+        subscription_id: account_data.stripe_membership_subscription_id,
+      };
+
+      if (usage_ret?.rows?.[0]) {
+        doc = usage_ret.rows[0].value;
+      }
+
+      if (Date.now() - doc.ts >= interval) {
+        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;
+
+          doc.hours++;
+          doc.size = drive_size_total;
+          doc.price += price_per_hour;
+
+          doc.ts = Date.now();
+          await db_module.save_couch_doc('xuda_usage', doc);
+        }
+      }
+    } catch (err) {
+      console.error(err.message);
+    }
+  };
+
+  const run_account_apps = async (account_data) => {
+    const apps_ret = await db_module.get_couch_view('xuda_master', 'user_apps', {
+      startkey: [account_data._id, ''],
+      endkey: [account_data._id, 'ZZZZZ'],
+      include_docs: true,
+    });
+
+    try {
+      for await (let app of apps_ret.data.rows) {
+        if (app.value.app_type === 'master') {
+          let size_ret = await drive_module.get_drive_size({
+            drive_type: 'studio',
+            app_id: app.id,
+          });
+          if (size_ret.code > -1) account_data.studio_drive_size += size_ret.data;
+
+          size_ret = await drive_module.get_drive_size({
+            drive_type: 'workspace',
+            app_id: app.id,
+          });
+          if (size_ret.code > -1) account_data.workspace_drive_size += size_ret.data;
+
+          size_ret = await drive_module.get_drive_size({
+            drive_type: 'builds',
+            app_id: app.id,
+          });
+          if (size_ret.code > -1) account_data.builds_drive_size += size_ret.data;
+
+          size_ret = await drive_module.get_drive_size({
+            drive_type: 'plugins',
+            app_id: app.id,
+          });
+          if (size_ret.code > -1) account_data.plugins_drive_size += size_ret.data;
+
+          // db data
+          const couch_info_ret = await db_module.get_couch_app_info(app.id);
+          account_data.project_data_size += couch_info_ret?.data?.sizes?.active || 0;
+        }
+
+        const usage_id = await _common.xuda_get_uuid('usage');
+
+        const usage_ret = await db_module.get_couch_view_raw('xuda_usage', 'open_app_usage', {
+          key: [app.id, app.doc?.app_hosting?.app_server_type || app.doc.app_type],
+        });
+
+        let doc = {
+          _id: usage_id,
+          docType: 'app_usage',
+          date_created: new Date(),
+          stat: 1,
+          uid: account_data._id,
+          stripe_customer_id: account_data.stripe_customer_id,
+          account_name: account_data.account_info.first_name + ' ' + account_data.account_info.last_name,
+          app_id: app.id,
+          price: 0,
+          hours: 0,
+          ts: 0,
+          name: app.value.app_name,
+          app_type: app.value.app_type,
+          subscription_id: account_data.stripe_membership_subscription_id,
+        };
+
+        if (doc.app_type === 'user_group') {
+          doc = {
+            ...doc,
+            ...{
+              user_group_members: 0,
+              user_group_members_accumulated: 0,
+              user_group_members_avg: 0,
+              price_user_group: 0,
+            },
+          };
+        }
+
+        if (usage_ret?.rows?.[0]) {
+          doc = usage_ret.rows[0].value;
+        }
+
+        let price_per_hour;
+
+        // check if last calculation made at least hour ago
+        const interval = 6000; // 3600 * 1000;
+        if (Date.now() - doc.ts >= interval) {
+          doc.hours++;
+
+          switch (doc.app_type) {
+            case 'backup':
+              if (app.value.app_hosting) {
+                // backup of deployment
+                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
+                  price_per_hour = (size * _conf.PRICE_OBJ.price_per_gb_backup) / _conf.PRICE_OBJ.avg_hours_in_month;
+                }
+              }
+              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
+
+            default:
+              // deployments,vps,master,instances and datacenters
+              if (!app.doc.app_hosting) continue;
+
+              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;
+          if (doc.price < 1) {
+            doc.price = 1;
+          }
+
+          doc.ts = Date.now();
+          await db_module.save_couch_doc('xuda_usage', doc);
+        }
+      }
+    } catch (err) {
+      console.error(err.message);
+    }
+  };
+
+  // iterate on all status account except deleted accounts
+  for await (let val of accounts_ret.rows) {
+    let account_data = val.value;
+
+    const size_ret = await drive_module.get_drive_size({
+      uid: account_data._id,
+      drive_type: 'user',
+    });
+
+    account_data.user_drive_size = size_ret.data;
+    account_data.studio_drive_size = 0;
+    account_data.workspace_drive_size = 0;
+    account_data.plugins_drive_size = 0;
+    account_data.builds_drive_size = 0;
+    account_data.project_data_size = 0;
+
+    await run_account_apps(account_data);
+    await run_account_drive(account_data);
+
+    account_data.total_drive_size = account_data.user_drive_size + account_data.studio_drive_size + account_data.workspace_drive_size + account_data.plugins_drive_size + account_data.builds_drive_size + account_data.project_data_size;
+    await db_module.save_couch_doc('xuda_accounts', account_data);
+  }
+};
+
+export const get_account_data = async (req) => {
+  let { uid, enforce_usage } = req;
+
+  try {
+    const { data: acc_obj } = await db_module.get_couch_doc('xuda_accounts', uid);
+    let ret = { code: 1 };
+    ret.data = {
+      _id: acc_obj._id,
+      account_info: acc_obj.account_info,
+      usage: acc_obj.activity_usage,
+      membership_plan: acc_obj.membership_plan,
+      plan_changed: acc_obj.plan_changed,
+      plan_info: acc_obj.plan_info,
+      support_plan: acc_obj.support_plan,
+      support_plan_changed: acc_obj.support_plan_changed,
+      storage_plan: acc_obj.storage_plan,
+      storage_plan_changed: acc_obj.storage_plan_changed,
+      account_project_id: acc_obj.account_project_id,
+
+      prices_info: acc_obj.prices_info,
+      activity_usage: acc_obj.activity_usage,
+      uid: acc_obj._id,
+      stat: acc_obj.stat,
+      preferences: acc_obj.preferences || {},
+      billing_status: {
+        account_suspension_status: acc_obj.account_suspension_status,
+        account_suspension_data: acc_obj.account_suspension_data,
+        account_billing_hold_status: acc_obj.account_billing_hold_status,
+        account_billing_hold_data: acc_obj.account_billing_hold_date,
+        account_termination_status: acc_obj.account_termination_status,
+        account_termination_data: acc_obj.account_termination_data,
+      },
+      drive_usage: {
+        user_drive_size: acc_obj.user_drive_size || 0,
+        studio_drive_size: acc_obj.studio_drive_size || 0,
+        workspace_drive_size: acc_obj.workspace_drive_size || 0,
+        plugins_drive_size: acc_obj.plugins_drive_size || 0,
+        builds_drive_size: acc_obj.builds_drive_size || 0,
+        project_data_size: acc_obj.project_data_size || 0,
+        total_drive_size: acc_obj.total_drive_size || 0,
+      },
+      stripe_connect_account_id: acc_obj?.stripe_connect_account_obj?.id,
+      stripe_connect_account_status: acc_obj?.stripe_connect_account_status,
+    };
+
+    return ret;
+  } catch (error) {
+    return { code: -1, data: error };
+  }
+};
+
+export const get_account_projects = async (req) => {
+  const { uid } = req;
+  let opt = {
+    key: uid,
+  };
+
+  if (_conf.superuser_account_ids.includes(uid) || _conf.support.support_team_account_ids.includes(uid)) {
+    opt = {};
+  }
+
+  let ret = await db_module.get_couch_view('xuda_master', 'user_projects', opt);
+
+  return ret;
+};
+
+export const get_account_datacenters = async (req) => {
+  return await db_module.get_couch_view('xuda_master', 'user_datacenters', {
+    key: req.uid,
+  });
+};
+
+export const get_account_deployments = async (req) => {
+  return await db_module.get_couch_view('xuda_master', 'user_deployments', {
+    key: req.uid,
+  });
+};
+
+export const get_account_instances = async (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({
+    uid: req.uid,
+    enforce_usage: req.enforce_usage,
+  });
+};
+
+export const get_account_name = async (req) => {
+  const data = await db_module.get_couch_doc('xuda_accounts', req.uid_query);
+  if (data.code < 0) {
+    return data;
+  }
+  let obj = {
+    first_name: '',
+    last_name: '',
+    email: '',
+    phone: '',
+    profile_picture: '',
+    username: '',
+  };
+  if (data.data.account_info) {
+    obj = {
+      first_name: data.data.account_info.first_name,
+      last_name: data.data.account_info.last_name,
+      email: data.data.account_info.email,
+      phone: data.data.account_info.tel,
+      profile_picture: data.data.account_info.profile_picture,
+      username: data.data.account_info.username,
+    };
+  }
+  return { code: 1, data: obj };
+};
+
+export const account_validate_username = async (req) => {
+  const opt = {
+    selector: { 'account_info.username': req.username },
+    fields: ['_id'],
+    limit: 1,
+  };
+
+  let ret = await db_module.find_couch_query('xuda_accounts', opt);
+
+  if (ret.docs.length) {
+    return { code: -400, data: 'User exist' };
+  } else {
+    return { code: 1, data: 'ok' };
+  }
+};
+
+export const verify_account = async (req) => {
+  const { account_id } = req;
+  if (!account_id) {
+    return { code: -10, data: 'Missing id' };
+  }
+
+  const ret = await db_module.get_couch_doc('xuda_accounts', account_id);
+
+  if (ret.code < 0) {
+    return { code: -1, data: 'account not found' };
+  }
+  let obj = ret.data;
+  obj.stat = 3;
+  const ret_acc = await db_module.save_couch_doc('xuda_accounts', obj);
+  if (ret.code < 0) {
+    return ret_acc;
+  }
+  return { code: 1, data: ret_acc.data };
+};
+
+export const validate_user_plan = async (req) => {
+  const { account_id, app_obj } = req;
+
+  const apps_ret = await db_module.get_couch_view('xuda_master', 'user_apps_count', {
+    startkey: [account_id, ''],
+    endkey: [account_id, 'ZZZZZ'],
+    reduce: true,
+    group_level: 2,
+  });
+
+  let ret_obj = _.reduce(
+    apps_ret.data.rows,
+    (ret, value) => {
+      ret[value.key[1]] = value.value;
+      return ret;
+    },
+    {},
+  );
+
+  const ret = await db_module.get_couch_doc('xuda_accounts', account_id);
+  if (ret.code < 0) {
+    return ret;
+  }
+  let plan = _conf.PLAN_OBJ[ret.data.membership_plan];
+
+  if (!plan) {
+    return { code: -7, data: 'error - no plan defined' };
+  }
+
+  // validate number of projects
+  if (app_obj.app_type === 'master' && ret_obj.master >= plan.features.projects) {
+    return {
+      code: -8,
+      data: `Number of projects (${ret.data.membership_plan}) exceeds to the ${plan.features.projects} plan limits`,
+    };
+  }
+
+  // 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,
+    // group_level: 2,
+  });
+
+  if (app_obj.app_type === 'master' && user_active_app_requests_count_ret.data?.rows?.[0]?.value >= plan.features.team) {
+    return {
+      code: -9,
+      data: `Number of team shares (${user_active_app_requests_count_ret.data.rows[0].value}) exceeds to the ${plan.features.team} plan limits`,
+    };
+  }
+
+  return { code: 1, data: ret.data };
+};
+
+export const get_hosting_plan = (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;
+    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) => {
+  const { app_obj } = req;
+  let cpu = 1;
+  if (app_obj.app_hosting) {
+    const hosting_plan = get_hosting_plan({
+      app_obj,
+    });
+
+    if (hosting_plan.cpu) {
+      cpu = hosting_plan.cpu;
+    }
+  }
+  return cpu;
+};
+
+const get_account_log_object = (body, status, service, source, response_data, ip, headers, security) => {
+  return {
+    uid: body.uid,
+    ip,
+    method: service,
+    req_body: body,
+    client_headers: headers,
+    security: _conf.cpi_methods?.[service]?.log,
+    api_pk: body.api_pk,
+    api_sk: body.api_sk,
+    dashboard: !body.api_pk && !body.api_sk,
+    response_status_code: status,
+    response_data,
+    source,
+    security,
+  };
+};
+
+export const add_account_log_util = (body, status, service, source, response_data, ip, headers) => {
+  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 = require(`${module_path}/logs_module`);
+  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) => {
+  const { uid, _id, ssh_key_name, ssh_key_content } = req;
+
+  const 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 = {
+    uid,
+    docType: 'ssh_key',
+    date_created_ts: Date.now(),
+    date_created: Date.now(),
+    stat: 3,
+  };
+
+  if (_id) {
+    const ret = await db_module.get_couch_doc('xuda_ssh_keys', _id);
+    if (ret.code < 0) {
+      return ret;
+    }
+    doc = ret.data;
+    doc.date_updated_ts = Date.now();
+  } else {
+    doc._id = await _common.xuda_get_uuid('ssh_key');
+  }
+
+  doc.ssh_key_name = ssh_key_name;
+  doc.ssh_key_content = ssh_key_content;
+
+  const save_ret = await db_module.save_couch_doc('xuda_ssh_keys', doc);
+
+  return save_ret;
+};
+
+export const delete_ssh_key = async (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;
+  doc.date_updated_ts = Date.now();
+  doc.stat = 4;
+
+  const save_ret = await db_module.save_couch_doc('xuda_ssh_keys', doc);
+
+  return save_ret;
+};
+
+export const get_ssh_keys = async (req) => {
+  const { uid, _id } = req;
+
+  let opt = {
+    selector: { docType: 'ssh_key', uid, stat: { $lt: 4 } },
+  };
+
+  if (_id) {
+    opt._id = _id;
+  }
+
+  let ret = await db_module.find_couch_query('xuda_ssh_keys', opt);
+  return ret;
+};
+
+export const search_users = async (req) => {
+  try {
+    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) {
+      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}` } },
+        ],
+      };
+    }
+
+    const opt = {
+      selector,
+      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_accounts', opt);
+      return { code: 1, data: ret };
+    } catch (e) {
+      return { code: -400, data: e };
+    }
+  } catch (err) {
+    return { code: -1, data: err.message };
+  }
+};
+
+export const read_emails = async (req) => {
+  const { uid, email_account_address, email_account_id, accessToken, vendor } = req;
+
+  const email_module = require(`${module_path}/email_module`);
+
+  const read_mailbox = async (mailbox_path, mailbox_name, is_sent) => {
+    let emails_ret = await db_module.find_couch_query('xuda_emails', {
+      selector: {
+        docType: 'email',
+        uid,
+        email_account_address,
+        email_account_id,
+        mailbox_path,
+      },
+      fields: ['message.seq'],
+      limit: 1,
+      sort: [{ 'message.seq': 'desc' }],
+    });
+
+    let imap_ret;
+
+    const seq = emails_ret?.docs?.[0]?.message?.seq || 1;
+    imap_ret = await email_module.query_imap({
+      email_account_address,
+      type: 'all',
+      boxLock: mailbox_path,
+      seq,
+      accessToken,
+    });
+
+    let senders = {};
+    let recipient = {};
+    let docs = [];
+
+    for await (let message of imap_ret) {
+      delete message.modseq;
+      if (message.seq > seq) {
+        docs.push({
+          _id: await _common.xuda_get_uuid('email'),
+          docType: 'email',
+          uid,
+          email_account_address,
+          email_account_id,
+          message,
+          mailbox_path,
+          mailbox_name,
+        });
+        if (is_sent) {
+          recipient[message.envelope.to[0].address] = message.envelope.to[0].name;
+        } else {
+          senders[message.envelope.sender[0].address] = message.envelope.sender[0].name;
+        }
+      }
+    }
+
+    if (docs.length) {
+      await db_module.save_couch_bulk_docs('xuda_emails', docs);
+
+      for await (let [email, name] of Object.entries(is_sent ? recipient : senders)) {
+        await add_contact({ uid, name, email });
+      }
+    }
+  };
+
+  const mailboxes_ret = await email_module.list_mailboxes({
+    email_account_address,
+    email_account_id,
+    accessToken,
+  });
+
+  for await (let mailbox_obj of mailboxes_ret) {
+    switch (vendor) {
+      case 'gmail':
+        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:
+        if (['INBOX', 'Sent Mail'].includes(mailbox_obj.path)) {
+          await read_mailbox(mailbox_obj.path, mailbox_obj.name);
+        }
+        break;
+    }
+  }
+};
+
+export const get_email_accounts = async (req) => {
+  const { uid, stat } = req;
+
+  const db_module = require(`${module_path}/db_module`);
+  let email_account_ret = await db_module.find_couch_query('xuda_emails', {
+    selector: {
+      docType: 'email_account',
+      uid,
+      stat: stat || 3,
+    },
+  });
+  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',
+    }),
+  });
+  return await response.json();
+};
+
+export const find_contact_duplicates = async (req) => {
+  const { uid, name } = req;
+  let opt = {
+    selector: {
+      docType: 'contact',
+      stat: { $lt: 4 },
+      uid,
+    },
+    limit: 999999,
+  };
+
+  if (typeof name !== 'undefined') {
+    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) {
+    if (!duplicates[contact.name]) {
+      duplicates[contact.name] = [];
+    }
+    if (contact.stat === 3) {
+      contact.primary = true;
+    }
+    duplicates[contact.name].push(contact);
+  }
+
+  // filter results
+  for await (let [name, val] of Object.entries(duplicates)) {
+    if (val.length < 2) {
+      delete duplicates[name];
+    }
+  }
+
+  return { code: 1, data: duplicates };
+};
+
+export const merge_contact = async (req) => {
+  const { uid, name } = req;
+  let duplicate_ret = await find_contact_duplicates({
+    uid,
+    name,
+  });
+  if (duplicate_ret.code < 0) {
+    return duplicate_ret;
+  }
+
+  let 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) {
+    if (contact.primary) {
+      contact_to_merge = contact._id;
+      continue;
+    }
+    contact_to_delete.push(contact._id);
+  }
+
+  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);
+
+      if (contact_obj.name && !['spam', 'newsletter', 'noreply', 'no-reply'].includes(contact_obj.email?.[0]?.toLowerCase())) {
+        contact_to_merge = contact_id;
+        contact_to_delete = contact_to_delete.splice(i, 1);
+        break;
+      }
+    }
+
+    if (!contact_to_merge) {
+      contact_to_merge = contact_to_delete[0];
+      contact_to_delete = contact_to_delete.slice(1);
+    }
+  }
+
+  // get the primary account
+  const primary_contact_ret = await db_module.get_couch_doc('xuda_contacts', contact_to_merge);
+  if (primary_contact_ret.code < 0) {
+    return primary_contact_ret;
+  }
+  let 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];
+
+    primary_contact_doc.email.push(email_address);
+  }
+
+  const primary_contact_save_ret = await db_module.save_couch_doc('xuda_contacts', primary_contact_doc);
+
+  for (let contact_id of contact_to_delete) {
+    const contact_ret = await db_module.get_couch_doc('xuda_contacts', contact_id);
+    if (contact_ret.code < 0) {
+      continue;
+    }
+
+    let 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;
+};
+
+export const get_contacts = async (req) => {
+  const { uid, name, limit, skip, bookmark } = req;
+  let opt = {
+    selector: {
+      docType: 'contact',
+      uid,
+      stat: { $lt: 4 },
+    },
+    limit: limit ? limit : 99999,
+  };
+
+  if (typeof name !== 'undefined') {
+    opt.selector.name = { $regex: `(?i)${name}` };
+  }
+
+  if (skip) {
+    opt.skip = skip;
+  }
+
+  if (bookmark !== 'nil') {
+    opt.bookmark = bookmark;
+  }
+  const contacts_ret = await db_module.find_couch_query('xuda_contacts', opt);
+
+  return contacts_ret;
+};
+
+export const delete_contact = async (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;
+
+  contact_doc.stat_ts = Date.now();
+  contact_doc.stat_reason = 'deleted';
+
+  const contact_save_ret = await db_module.save_couch_doc('xuda_contacts', contact_doc);
+
+  return contact_save_ret;
+};
+
+export const add_contact = async (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] });
+
+  if (!contact_ret.rows.length) {
+    const ret = await db_module.save_couch_doc('xuda_contacts', {
+      _id: await _common.xuda_get_uuid('contact'),
+      email: [email],
+      name,
+      stat: stat || 1,
+      date_created: Date.now(),
+      docType: 'contact',
+      contact_uid,
+      uid,
+      req_id,
+    });
+    return ret;
+  }
+  return { code: -1, data: 'contact already exist active or deleted' };
+};
+
+export const update_contact = async (req) => {
+  const { uid, email, contact_uid, stat, req_id } = req;
+  let 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;
+    if (stat) {
+      doc.stat = stat;
+      doc.stat_ts = Date.now();
+    }
+    if (req_id) {
+      doc.req_id = req_id;
+    }
+    return await db_module.save_couch_doc('xuda_contacts', doc);
+  }
+  return { code: -1, data: 'contact not found' };
+};
+
+export const invite_user = async (req) => {
+  const { email, name, uid } = req;
+
+  const team_module = require(`${module_path}/team_module`);
+  const ret = await team_module.create_team_request({
+    email,
+    access_type: 'contact',
+    uid,
+  });
+};
+
+export const get_account_rt_info = async (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;
+
+  delete account_info.user_id;
+
+  account_info.uid = doc_ret.data._id;
+  return account_info;
+};
+
+const get_prices = (uid, item) => {
+  let price;
+
+  switch (item) {
+    case 'user_group':
+    case 'pwa':
+    case 'preview':
+    case 'android':
+    case 'ios':
+    case 'macos':
+    case 'emitter':
+      price = _conf.PRICE_OBJ.deployments[item];
+      break;
+
+    case 'drive_ocr':
+      price = _conf.PRICE_OBJ.drive_addons.ocr.price;
+      break;
+
+    case 'drive_edit_image':
+      price = _conf.PRICE_OBJ.drive_addons.edit_image.price;
+      break;
+
+    case 'auto_backup':
+      price = _conf.PRICE_OBJ.auto_backup_per_month;
+      break;
+
+    case 'deployment_offline':
+      price = _conf.PRICE_OBJ.deployment_offline_per_month;
+      break;
+
+    case 'xuda_subdomain':
+      price = _conf.PRICE_OBJ.xuda_subdomain_per_month;
+      break;
+
+    case 'custom_domain':
+      price = _conf.PRICE_OBJ.custom_domain_per_month;
+      break;
+
+    case 'user_monitor':
+      price = _conf.PRICE_OBJ.user_assist_per_month;
+      break;
+
+    case 'branding':
+      price = _conf.PRICE_OBJ.branding_per_month;
+      break;
+
+    case 'utility_screen':
+      price = _conf.PRICE_OBJ.utility_screen_per_month;
+      break;
+
+    default:
+      price = 0;
+      break;
+  }
+
+  if (_conf.PRICE_OBJ.server_slugs[item]) {
+    price = _conf.PRICE_OBJ.server_slugs[item].price;
+  }
+
+  return price;
+};
+
+export const validate_account_topup = async (uid, items = []) => {
+  const stripe_module = require(`${module_path}/stripe_module`);
+
+  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) => {
+  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(
+    {
+      job_id,
+      current_step_name: 'creating link',
+      response: link,
+    },
+    global[`_account_module_ch`],
+  );
+  await _utils.delay(20000);
+  // debugger;
+  return {
+    code: 1,
+    data: link,
+  };
+};

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@xuda.io/account_module",
-  "version": "1.2.144",
+  "version": "1.2.146",
   "description": "Xuda Account Server Module",
-  "main": "index.js",
+  "main": "index.mjs",
   "dependencies": {
     "lodash": "^4.17.21",
     "validator": "^13.1.1"