@xuda.io/account_module 1.2.2258 → 1.2.2260

package/index.js

@@ -0,0 +1,1467 @@
+const path = require('path');
+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'));
+
+const _ = require('lodash');
+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`);
+
+exports.update_account_info = async function (req) {
+  const marketplace_module = require(`${module_path}/marketplace_module`);
+
+  const { uid } = req;
+  const data = req;
+
+  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.count > max_length) {
+      return -3;
+    } else {
+      return 1;
+    }
+  }
+
+  const ret = await db_module.get_couch_doc('xuda_accounts', uid);
+  var account_obj = ret.data;
+  account_obj.ts = Date.now();
+  var change = '';
+  var error = {};
+
+  await marketplace_module.marketplace_save_user({ uid });
+
+  _.forEach(data, function (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)) {
+        // 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)) {
+        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)) {
+        // 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)) {
+        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;
+};
+exports.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);
+  var 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 };
+};
+
+exports.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;
+  }
+  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);
+  var obj = {};
+  if (ret3.code > -1) {
+    obj = {
+      code: 1,
+      data: 'ok',
+      app_obj: _common.get_clean_app_obj(app_obj),
+    };
+  } else {
+    obj = ret3;
+  }
+
+  return obj;
+};
+
+exports.increment_account_usage = async function (req) {
+  const { uid } = req;
+
+  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 = require(`${module_path}/drive_module`);
+
+  function bytesToGB(bytes) {
+    return bytes / 1073741824; // or bytes / (1024 ** 3)
+  }
+
+  // check if last calculation made at least hour ago
+  const interval = 3600 * 1000; //6000; // 3600 * 1000;
+
+  const run_account_drive = async function (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,
+      });
+
+      var 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) {
+          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;
+          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 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'],
+      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],
+        });
+
+        var 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;
+        }
+
+        var 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;
+            }
+
+            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) {
+    var 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);
+  }
+};
+
+exports.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);
+    // const account_obj= account_ret.data
+    var 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,
+    };
+
+    // 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 = 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 } });
+    //   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();
+};
+
+exports.get_account_projects = async function (req) {
+  const { uid } = req;
+  var opt = {
+    key: uid,
+  };
+
+  if (_conf.superuser_account_ids.includes(uid) || _conf.support.support_team_account_ids.includes(uid)) {
+    opt = {};
+  }
+
+  var ret = await db_module.get_couch_view('xuda_master', 'user_projects', opt);
+
+  return ret;
+};
+
+exports.get_account_datacenters = async function (req) {
+  return await db_module.get_couch_view('xuda_master', 'user_datacenters', {
+    key: req.uid,
+  });
+};
+exports.get_account_deployments = async function (req) {
+  return await db_module.get_couch_view('xuda_master', 'user_deployments', {
+    key: req.uid,
+  });
+};
+exports.get_account_instances = async function (req) {
+  return await db_module.get_couch_view('xuda_master', 'user_all_instances', {
+    key: req.uid,
+  });
+};
+
+exports.get_account_info = async function (req) {
+  return await this.get_account_data({
+    uid: req.uid,
+    enforce_usage: req.enforce_usage,
+  });
+};
+
+exports.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;
+  }
+  var 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 };
+};
+
+exports.account_validate_username = async function (req) {
+  const opt = {
+    selector: { 'account_info.username': req.username },
+    fields: ['_id'],
+    limit: 1,
+  };
+
+  var 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' };
+  }
+};
+
+// exports.get_account_activity = async function (req) {
+//   return await db_module.get_couch_view(
+//     "xuda_activity",
+//     "activity_per_account",
+//     {
+//       key: req.uid,
+//     }
+//   );
+// };
+
+exports.verify_account = async function (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' };
+  }
+  var 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 };
+};
+
+exports.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', {
+    startkey: [account_id, ''],
+    endkey: [account_id, 'ZZZZZ'],
+    reduce: true,
+    group_level: 2,
+  });
+
+  var 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;
+  }
+  var plan = _conf.PLAN_OBJ[ret.data.membership_plan];
+  // get plan from user
+
+  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 };
+};
+
+exports.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;
+    console.error('error: ' + app_obj.app_hosting.app_server_type + ' not found in PRICE_OBJ.server_slugs');
+    return { cpu: 0, price: 0 };
+  }
+};
+
+exports.get_cpu = async function (req) {
+  const { app_obj } = req;
+  var cpu = 1;
+  if (app_obj.app_hosting) {
+    const hosting_plan = this.get_hosting_plan({
+      app_obj,
+    });
+
+    if (hosting_plan.cpu) {
+      cpu = hosting_plan.cpu;
+    }
+  }
+  return cpu;
+};
+
+const get_account_log_object = function (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,
+  };
+};
+
+exports.add_account_log_util = 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 = require(`${module_path}/logs_module`);
+  logs_module.add_account_log(get_account_log_object(body, status, service, source, response_data, ip, headers, security));
+};
+
+exports.save_ssh_key = async function (req) {
+  const { uid, _id, ssh_key_name, ssh_key_content } = req;
+
+  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' };
+  }
+
+  var 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;
+};
+exports.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;
+  }
+  var 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;
+};
+
+exports.get_ssh_keys = async function (req) {
+  const { uid, _id } = req;
+
+  let opt = {
+    selector: { docType: 'ssh_key', uid, stat: { $lt: 4 } },
+  };
+
+  if (_id) {
+    opt._id = _id;
+  }
+
+  var ret = await db_module.find_couch_query('xuda_ssh_keys', opt);
+  return ret;
+};
+
+exports.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');
+    }
+
+    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 {
+      var 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 };
+  }
+};
+
+exports.read_emails = async function (req) {
+  const { uid, email_account_address, email_account_id, accessToken, vendor } = req;
+
+  const email_module = require(`${module_path}/email_module`);
+
+  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,
+        email_account_address,
+        email_account_id,
+        mailbox_path,
+      },
+      fields: ['message.seq'],
+      limit: 1,
+      sort: [{ 'message.seq': 'desc' }],
+    });
+
+    var 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,
+    });
+
+    var senders = {};
+    var recipient = {};
+    var 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)) {
+        // 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 module.exports.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;
+    }
+  }
+};
+
+exports.get_email_accounts = async function (req) {
+  const { uid, stat } = req;
+
+  const db_module = require(`${module_path}/db_module`);
+  var 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 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);
+      });
+  });
+};
+
+exports.find_contact_duplicates = async function (req) {
+  const { uid, name } = req;
+  var 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);
+  var duplicates = {};
+  for (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 };
+};
+
+exports.merge_contact = async function (req) {
+  const { uid, name } = req;
+  var duplicate_ret = await module.exports.find_contact_duplicates({
+    uid,
+    name,
+  });
+  if (duplicate_ret.code < 0) {
+    return duplicate_ret;
+  }
+
+  var duplicate_arr = duplicate_ret?.data?.[name] || [];
+  if (!duplicate_arr.length) {
+    return { code: 1, data: 'no merge performed' };
+  }
+  var contact_to_merge;
+  var contact_to_delete = [];
+  for (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)) {
+      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;
+        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;
+  }
+  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) {
+    var 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;
+    }
+
+    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; //{ code: 1, data: duplicate_arr };
+};
+
+exports.get_contacts = async function (req) {
+  const { uid, name, limit, skip, bookmark } = req;
+  var 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;
+};
+
+exports.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;
+  }
+  var 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;
+};
+// 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,
+//   }
+// );
+
+exports.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] });
+
+  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' };
+};
+exports.update_contact = async function (req) {
+  const { uid, email, contact_uid, stat, req_id } = req;
+  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) {
+    var 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' };
+};
+exports.invite_user = async function (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,
+  });
+
+  // return { code: -1, data: "contact already exist active or deleted" };
+};
+
+exports.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 {};
+  }
+  var account_info = doc_ret.data.account_info;
+
+  delete account_info.user_id;
+
+  account_info.uid = doc_ret.data._id;
+  return account_info;
+};
+
+// exports.validate_account_topup = async function (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, { 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;
+// };
+
+exports.validate_account_topup = async function (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;
+    // 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) {
+    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;
+};
+
+exports.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(
+    {
+      job_id,
+      current_step_name: 'creating link',
+      response: link,
+    },
+    global[`_account_module_ch`],
+  );
+  await _utils.delay(20000);
+  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 module.exports.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;
+//     }
+
+//     module.exports.read_emails({
+//       uid,
+//       email_account_address: email_account.email,
+//       accessToken,
+//       email_account_id: email_account._id,
+//       vendor: email_account.vendor,
+//     });
+//   }
+
+//   // console.log(await module.exports.get_contact({ uid, name: "bo" }));
+// }, 2000);