@xuda.io/account_module 1.2.99 → 1.2.101

package/index.js

@@ -1,19 +1,10 @@
-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 _ = require("lodash");
-const module_path =
-  path.join(process.env.XUDA_HOME, "cpi") +
-  (!_conf.is_debug ? "/node_modules/@xuda.io" : "");
+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 _ = 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`);
 
 exports.update_account_info = async function (req) {
@@ -36,64 +27,55 @@ exports.update_account_info = async function (req) {
     }
   }
 
-  const ret = await db_module.get_couch_doc("xuda_accounts", uid);
+  const ret = await db_module.get_couch_doc('xuda_accounts', uid);
   var account_obj = ret.data;
   account_obj.ts = Date.now();
-  var change = "";
+  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;
+      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 (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)) {
+      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";
+        error[key] = 'Invalid first name';
       }
-      if (key === "last_name" && !validate_input(val, 35, true, false)) {
-        error[key] = "Invalid last 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 === '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' && (!/^[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";
+        error[key] = 'Invalid phone number';
       }
-      if (key === "address" && !/^[a-z0-9- ]+$/i.test(val)) {
+      if (key === 'address' && !/^[a-z0-9- ]+$/i.test(val)) {
         // if (key === "address" && !preg_match('/^[a-z0-9- ]+$/i', $val)) {
-        error[key] = "Invalid address";
+        error[key] = 'Invalid address';
       }
-      if (key === "city" && !validate_input(val, 255, false, false)) {
-        error[key] = "Invalid city";
+      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 === '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 === '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 (key === 'country' && !validate_input(val, 55, false, false)) {
+        error[key] = 'Invalid country';
       }
     }
   });
@@ -102,14 +84,14 @@ exports.update_account_info = async function (req) {
     return { code: -1310, data: error };
   }
   if (!change) {
-    return { code: 1300, data: "no 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;
-  const ret2 = await db_module.save_couch_doc("xuda_accounts", account_obj);
+  const ret2 = await db_module.save_couch_doc('xuda_accounts', account_obj);
   if (ret2.code > 0) {
-    return { code: 1300, data: "ok" };
+    return { code: 1300, data: 'ok' };
   }
   return ret2;
 };
@@ -117,13 +99,13 @@ 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);
+  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);
+  const ret1 = await db_module.save_couch_doc('xuda_accounts', account_obj);
   if (ret1.code < 0) {
     return ret1;
   }
@@ -131,7 +113,7 @@ exports.update_account_preferences = async function (req) {
 };
 
 exports.save_admin_presets = async function (req) {
-  const ret = await db_module.get_couch_doc("xuda_master", req.app_id);
+  const ret = await db_module.get_couch_doc('xuda_master', req.app_id);
   if (ret.code < 0) {
     return ret;
   }
@@ -144,7 +126,7 @@ exports.save_admin_presets = async function (req) {
   if (ret3.code > -1) {
     obj = {
       code: 1,
-      data: "ok",
+      data: 'ok',
       app_obj: _common.get_clean_app_obj(app_obj),
     };
   } else {
@@ -161,11 +143,7 @@ exports.increment_account_usage = async function (req) {
   if (uid) {
     opt.key = uid;
   }
-  const accounts_ret = await db_module.get_couch_view_raw(
-    "xuda_accounts",
-    "all_accounts",
-    opt
-  );
+  const accounts_ret = await db_module.get_couch_view_raw('xuda_accounts', 'all_accounts', opt);
 
   const drive_module = require(`${module_path}/drive_module`);
 
@@ -178,27 +156,20 @@ exports.increment_account_usage = async function (req) {
 
   const run_account_drive = async function (account_data) {
     try {
-      const usage_id = await _common.xuda_get_uuid("usage");
+      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,
-        }
-      );
+      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",
+        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,
+        account_name: account_data.account_info.first_name + ' ' + account_data.account_info.last_name,
         size: 0,
         price: 0,
         hours: 0,
@@ -212,23 +183,16 @@ exports.increment_account_usage = async function (req) {
 
       if (Date.now() - doc.ts >= interval) {
         const plan = _conf.PLAN_OBJ[account_data.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;
+        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;
+          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);
+          await db_module.save_couch_doc('xuda_usage', doc);
         }
       }
     } catch (err) {
@@ -237,77 +201,58 @@ exports.increment_account_usage = async function (req) {
   };
 
   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,
-      }
-    );
+    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") {
+        if (app.value.app_type === 'master') {
           let size_ret = await drive_module.get_drive_size({
-            drive_type: "studio",
+            drive_type: 'studio',
             app_id: app.id,
           });
-          if (size_ret.code > -1)
-            account_data.studio_drive_size += size_ret.data;
+          if (size_ret.code > -1) account_data.studio_drive_size += size_ret.data;
 
           size_ret = await drive_module.get_drive_size({
-            drive_type: "workspace",
+            drive_type: 'workspace',
             app_id: app.id,
           });
-          if (size_ret.code > -1)
-            account_data.workspace_drive_size += size_ret.data;
+          if (size_ret.code > -1) account_data.workspace_drive_size += size_ret.data;
 
           size_ret = await drive_module.get_drive_size({
-            drive_type: "builds",
+            drive_type: 'builds',
             app_id: app.id,
           });
-          if (size_ret.code > -1)
-            account_data.builds_drive_size += size_ret.data;
+          if (size_ret.code > -1) account_data.builds_drive_size += size_ret.data;
 
           size_ret = await drive_module.get_drive_size({
-            drive_type: "plugins",
+            drive_type: 'plugins',
             app_id: app.id,
           });
-          if (size_ret.code > -1)
-            account_data.plugins_drive_size += size_ret.data;
+          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;
+          account_data.project_data_size += couch_info_ret?.data?.sizes?.active || 0;
         }
 
-        const usage_id = await _common.xuda_get_uuid("usage");
+        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,
-            ],
-          }
-        );
+        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",
+          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,
+          account_name: account_data.account_info.first_name + ' ' + account_data.account_info.last_name,
           app_id: app.id,
           price: 0,
           hours: 0,
@@ -318,7 +263,7 @@ exports.increment_account_usage = async function (req) {
           subscription_id: account_data.stripe_membership_subscription_id,
         };
 
-        if (doc.app_type === "user_group") {
+        if (doc.app_type === 'user_group') {
           doc = {
             ...doc,
             ...{
@@ -342,46 +287,34 @@ exports.increment_account_usage = async function (req) {
           doc.hours++;
 
           switch (doc.app_type) {
-            case "backup":
+            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;
+                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;
+                  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,
-                }
-              );
+            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;
+              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;
+              doc.user_group_members_avg = doc.user_group_members_accumulated / doc.hours;
             }
 
             default:
@@ -390,8 +323,7 @@ exports.increment_account_usage = async function (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;
+              price_per_hour = app.doc.app_hosting.price / _conf.PRICE_OBJ.avg_hours_in_month;
 
               break;
           }
@@ -401,7 +333,7 @@ exports.increment_account_usage = async function (req) {
           }
 
           doc.ts = Date.now();
-          await db_module.save_couch_doc("xuda_usage", doc);
+          await db_module.save_couch_doc('xuda_usage', doc);
         }
       }
     } catch (err) {
@@ -415,7 +347,7 @@ exports.increment_account_usage = async function (req) {
 
     const size_ret = await drive_module.get_drive_size({
       uid: account_data._id,
-      drive_type: "user",
+      drive_type: 'user',
     });
 
     account_data.user_drive_size = size_ret.data;
@@ -428,14 +360,8 @@ exports.increment_account_usage = async function (req) {
     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);
+    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);
   }
 };
 
@@ -456,10 +382,7 @@ exports.get_account_data = async function (req) {
   // };
 
   try {
-    const { data: acc_obj } = await db_module.get_couch_doc(
-      "xuda_accounts",
-      uid
-    );
+    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 = {
@@ -522,30 +445,27 @@ exports.get_account_projects = async function (req) {
     key: uid,
   };
 
-  if (
-    _conf.superuser_account_ids.includes(uid) ||
-    _conf.support.support_team_account_ids.includes(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);
+  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", {
+  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", {
+  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", {
+  return await db_module.get_couch_view('xuda_master', 'user_all_instances', {
     key: req.uid,
   });
 };
@@ -558,17 +478,17 @@ exports.get_account_info = async function (req) {
 };
 
 exports.get_account_name = async function (req) {
-  const data = await db_module.get_couch_doc("xuda_accounts", req.uid_query);
+  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: "",
+    first_name: '',
+    last_name: '',
+    email: '',
+    phone: '',
+    profile_picture: '',
+    username: '',
   };
   if (data.data.account_info) {
     obj = {
@@ -585,17 +505,17 @@ exports.get_account_name = async function (req) {
 
 exports.account_validate_username = async function (req) {
   const opt = {
-    selector: { "account_info.username": req.username },
-    fields: ["_id"],
+    selector: { 'account_info.username': req.username },
+    fields: ['_id'],
     limit: 1,
   };
 
-  var 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" };
+    return { code: -400, data: 'User exist' };
   } else {
-    return { code: 1, data: "ok" };
+    return { code: 1, data: 'ok' };
   }
 };
 
@@ -612,17 +532,17 @@ exports.account_validate_username = async function (req) {
 exports.verify_account = async function (req) {
   const { account_id } = req;
   if (!account_id) {
-    return { code: -10, data: "Missing id" };
+    return { code: -10, data: 'Missing id' };
   }
 
-  const ret = await db_module.get_couch_doc("xuda_accounts", account_id);
+  const ret = await db_module.get_couch_doc('xuda_accounts', account_id);
 
   if (ret.code < 0) {
-    return { code: -1, data: "account not found" };
+    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);
+  const ret_acc = await db_module.save_couch_doc('xuda_accounts', obj);
   if (ret.code < 0) {
     return ret_acc;
   }
@@ -632,16 +552,12 @@ exports.verify_account = async function (req) {
 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,
-    }
-  );
+  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,
@@ -649,10 +565,10 @@ exports.validate_user_plan = async function (req) {
       ret[value.key[1]] = value.value;
       return ret;
     },
-    {}
+    {},
   );
 
-  const ret = await db_module.get_couch_doc("xuda_accounts", account_id);
+  const ret = await db_module.get_couch_doc('xuda_accounts', account_id);
   if (ret.code < 0) {
     return ret;
   }
@@ -660,14 +576,11 @@ exports.validate_user_plan = async function (req) {
   // get plan from user
 
   if (!plan) {
-    return { code: -7, data: "error - no plan defined" };
+    return { code: -7, data: 'error - no plan defined' };
   }
 
   // validate number of projects
-  if (
-    app_obj.app_type === "master" &&
-    ret_obj.master >= plan.features.projects
-  ) {
+  if (app_obj.app_type === 'master' && ret_obj.master >= plan.features.projects) {
     return {
       code: -8,
       data: `Number of projects (${ret.data.plan}) exceeds to the ${plan.features.projects} plan limits`,
@@ -676,21 +589,13 @@ exports.validate_user_plan = async function (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,
-      // group_level: 2,
-    }
-  );
+  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
-  ) {
+  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`,
@@ -722,11 +627,7 @@ exports.get_hosting_plan = function (req) {
       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"
-    );
+    console.error('error: ' + app_obj.app_hosting.app_server_type + ' not found in PRICE_OBJ.server_slugs');
     return { cpu: 0, price: 0 };
   }
 };
@@ -746,16 +647,7 @@ exports.get_cpu = async function (req) {
   return cpu;
 };
 
-const get_account_log_object = function (
-  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,
@@ -773,15 +665,7 @@ const get_account_log_object = function (
   };
 };
 
-exports.add_account_log_util = function (
-  body,
-  status,
-  service,
-  source,
-  response_data,
-  ip,
-  headers
-) {
+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);
@@ -790,22 +674,11 @@ exports.add_account_log_util = function (
   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;
+    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
-    )
-  );
+  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) {
@@ -813,46 +686,45 @@ exports.save_ssh_key = async function (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}( [^@]+@[^@]+)?$/;
+    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" };
+    return { code: -1, data: 'invalid ssh key' };
   }
 
   var doc = {
     uid,
-    docType: "ssh_key",
+    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);
+    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._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);
+  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);
+  const ret = await db_module.get_couch_doc('xuda_ssh_keys', ssh_key_id);
   if (ret.code < 0) {
     return ret;
   }
@@ -860,7 +732,7 @@ exports.delete_ssh_key = async function (req) {
   doc.date_updated_ts = Date.now();
   doc.stat = 4;
 
-  const save_ret = await db_module.save_couch_doc("xuda_ssh_keys", doc);
+  const save_ret = await db_module.save_couch_doc('xuda_ssh_keys', doc);
 
   return save_ret;
 };
@@ -869,14 +741,14 @@ exports.get_ssh_keys = async function (req) {
   const { uid, _id } = req;
 
   let opt = {
-    selector: { docType: "ssh_key", uid, stat: { $lt: 4 } },
+    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);
+  var ret = await db_module.find_couch_query('xuda_ssh_keys', opt);
   return ret;
 };
 
@@ -887,11 +759,11 @@ exports.search_users = async function (req) {
   // bookmark
   try {
     if (!_conf.superuser_account_ids.includes(req.uid)) {
-      throw new Error("user is not authorized for this method");
+      throw new Error('user is not authorized for this method');
     }
 
     let selector = {
-      docType: "account",
+      docType: 'account',
       stat: 3,
     };
 
@@ -900,32 +772,32 @@ exports.search_users = async function (req) {
         ...selector,
         $or: [
           {
-            "account_info.first_name": {
+            'account_info.first_name': {
               $regex: `(?i)${req.search}`,
             },
           },
           {
-            "account_info.last_name": {
+            'account_info.last_name': {
               $regex: `(?i)${req.search}`,
             },
           },
           {
-            "account_info.company_name": {
+            'account_info.company_name': {
               $regex: `(?i)${req.search}`,
             },
           },
           {
-            "account_info.tel": {
+            'account_info.tel': {
               $regex: `(?i)${req.search}`,
             },
           },
           {
-            "account_info.email": {
+            'account_info.email': {
               $regex: `(?i)${req.search}`,
             },
           },
           {
-            "account_info.address": {
+            'account_info.address': {
               $regex: `(?i)${req.search}`,
             },
           },
@@ -948,12 +820,12 @@ exports.search_users = async function (req) {
       opt.skip = req.skip;
     }
 
-    if (req?.bookmark !== "nil") {
+    if (req?.bookmark !== 'nil') {
       opt.bookmark = req.bookmark;
     }
 
     try {
-      var ret = await db_module.find_couch_query("xuda_accounts", opt);
+      var ret = await db_module.find_couch_query('xuda_accounts', opt);
 
       return {
         code: 1,
@@ -971,23 +843,22 @@ exports.search_users = async function (req) {
 };
 
 exports.read_emails = async function (req) {
-  const { uid, email_account_address, email_account_id, accessToken, vendor } =
-    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", {
+    var emails_ret = await db_module.find_couch_query('xuda_emails', {
       selector: {
-        docType: "email",
+        docType: 'email',
         uid,
         email_account_address,
         email_account_id,
         mailbox_path,
       },
-      fields: ["message.seq"],
+      fields: ['message.seq'],
       limit: 1,
-      sort: [{ "message.seq": "desc" }],
+      sort: [{ 'message.seq': 'desc' }],
     });
 
     var imap_ret;
@@ -995,7 +866,7 @@ exports.read_emails = async function (req) {
     const seq = emails_ret?.docs?.[0]?.message?.seq || 1;
     imap_ret = await email_module.query_imap({
       email_account_address,
-      type: "all",
+      type: 'all',
       boxLock: mailbox_path,
       seq,
       accessToken,
@@ -1009,8 +880,8 @@ exports.read_emails = async function (req) {
       delete message.modseq;
       if (message.seq > seq) {
         docs.push({
-          _id: await _common.xuda_get_uuid("email"),
-          docType: "email",
+          _id: await _common.xuda_get_uuid('email'),
+          docType: 'email',
           uid,
           email_account_address,
           email_account_id,
@@ -1019,21 +890,17 @@ exports.read_emails = async function (req) {
           mailbox_name,
         });
         if (is_sent) {
-          recipient[message.envelope.to[0].address] =
-            message.envelope.to[0].name;
+          recipient[message.envelope.to[0].address] = message.envelope.to[0].name;
         } else {
-          senders[message.envelope.sender[0].address] =
-            message.envelope.sender[0].name;
+          senders[message.envelope.sender[0].address] = message.envelope.sender[0].name;
         }
       }
     }
 
     if (docs.length) {
-      await db_module.sava_couch_bulk_docs("xuda_emails", docs);
+      await db_module.save_couch_bulk_docs('xuda_emails', docs);
 
-      for await (let [email, name] of Object.entries(
-        is_sent ? recipient : senders
-      )) {
+      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",
@@ -1064,29 +931,15 @@ exports.read_emails = async function (req) {
 
   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"
-          );
+      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)) {
+        if (['INBOX', 'Sent Mail'].includes(mailbox_obj.path)) {
           await read_mailbox(mailbox_obj.path, mailbox_obj.name);
         }
         break;
@@ -1098,9 +951,9 @@ 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", {
+  var email_account_ret = await db_module.find_couch_query('xuda_emails', {
     selector: {
-      docType: "email_account",
+      docType: 'email_account',
       uid,
       stat: stat || 3,
     },
@@ -1110,14 +963,14 @@ exports.get_email_accounts = async function (req) {
 
 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" },
+    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",
+        grant_type: 'refresh_token',
       }),
     })
       .then((response) => response.json())
@@ -1131,17 +984,17 @@ exports.find_contact_duplicates = async function (req) {
   const { uid, name } = req;
   var opt = {
     selector: {
-      docType: "contact",
+      docType: 'contact',
       stat: { $lt: 4 },
       uid,
     },
     limit: 999999,
   };
 
-  if (typeof name !== "undefined") {
+  if (typeof name !== 'undefined') {
     opt.selector.name = name;
   }
-  const contact_ret = await db_module.find_couch_query("xuda_contacts", opt);
+  const contact_ret = await db_module.find_couch_query('xuda_contacts', opt);
   var duplicates = {};
   for (contact of contact_ret.docs) {
     if (!duplicates[contact.name]) {
@@ -1175,7 +1028,7 @@ exports.merge_contact = async function (req) {
 
   var duplicate_arr = duplicate_ret?.data?.[name] || [];
   if (!duplicate_arr.length) {
-    return { code: 1, data: "no merge performed" };
+    return { code: 1, data: 'no merge performed' };
   }
   var contact_to_merge;
   var contact_to_delete = [];
@@ -1192,12 +1045,7 @@ exports.merge_contact = async function (req) {
     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()
-        )
-      ) {
+      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;
@@ -1211,35 +1059,25 @@ exports.merge_contact = async function (req) {
   }
 
   // get the primary account
-  const primary_contact_ret = await db_module.get_couch_doc(
-    "xuda_contacts",
-    contact_to_merge
-  );
+  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";
+  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];
+    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
-  );
+  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
-    );
+    const contact_ret = await db_module.get_couch_doc('xuda_contacts', contact_id);
     if (contact_ret.code < 0) {
       continue;
     }
@@ -1247,8 +1085,8 @@ exports.merge_contact = async function (req) {
     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);
+    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 };
@@ -1258,14 +1096,14 @@ exports.get_contacts = async function (req) {
   const { uid, name, limit, skip, bookmark } = req;
   var opt = {
     selector: {
-      docType: "contact",
+      docType: 'contact',
       uid,
       stat: { $lt: 4 },
     },
     limit: limit ? limit : 99999,
   };
 
-  if (typeof name !== "undefined") {
+  if (typeof name !== 'undefined') {
     opt.selector.name = { $regex: `(?i)${name}` };
   }
 
@@ -1273,10 +1111,10 @@ exports.get_contacts = async function (req) {
     opt.skip = skip;
   }
 
-  if (bookmark !== "nil") {
+  if (bookmark !== 'nil') {
     opt.bookmark = bookmark;
   }
-  const contacts_ret = await db_module.find_couch_query("xuda_contacts", opt);
+  const contacts_ret = await db_module.find_couch_query('xuda_contacts', opt);
 
   return contacts_ret;
 };
@@ -1284,19 +1122,16 @@ exports.get_contacts = async function (req) {
 exports.delete_contact = async function (req) {
   const { _id } = req;
 
-  const contact_ret = await db_module.get_couch_doc("xuda_contacts", _id);
+  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";
+  contact_doc.stat_reason = 'deleted';
 
-  const contact_save_ret = await db_module.save_couch_doc(
-    "xuda_contacts",
-    contact_doc
-  );
+  const contact_save_ret = await db_module.save_couch_doc('xuda_contacts', contact_doc);
 
   return contact_save_ret;
 };
@@ -1315,43 +1150,31 @@ exports.delete_contact = async function (req) {
 
 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] }
-  );
+  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"),
+    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",
+      docType: 'contact',
       contact_uid,
       uid,
       req_id,
     });
     return ret;
   }
-  return { code: -1, data: "contact already exist active or deleted" };
+  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] }
-    );
+    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] }
-    );
+    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;
@@ -1362,9 +1185,9 @@ exports.update_contact = async function (req) {
     if (req_id) {
       doc.req_id = req_id;
     }
-    return await db_module.save_couch_doc("xuda_contacts", doc);
+    return await db_module.save_couch_doc('xuda_contacts', doc);
   }
-  return { code: -1, data: "contact not found" };
+  return { code: -1, data: 'contact not found' };
 };
 exports.invite_user = async function (req) {
   const { email, name, uid } = req;
@@ -1372,7 +1195,7 @@ exports.invite_user = async function (req) {
   const team_module = require(`${module_path}/team_module`);
   const ret = await team_module.create_team_request({
     email,
-    access_type: "contact",
+    access_type: 'contact',
     uid,
   });
 
@@ -1380,9 +1203,9 @@ exports.invite_user = async function (req) {
 };
 
 exports.get_account_rt_info = async function (uid) {
-  const doc_ret = await db_module.get_couch_doc("xuda_accounts", 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);
+    console.error('get_account_rt_info', doc_ret);
     return {};
   }
   var account_info = doc_ret.data.account_info;
@@ -1451,7 +1274,7 @@ exports.validate_account_topup = async function (uid, items = []) {
     err.code = -90;
     err.billing_problem = true;
 
-    throw new Error("no card on file");
+    throw new Error('no card on file');
   }
 
   if (data?.balance?.past_due) {
@@ -1495,45 +1318,49 @@ 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":
+    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":
+    case 'drive_ocr':
       price = _conf.PRICE_OBJ.drive_addons.ocr.price;
       break;
 
-    case "auto_backup":
+    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":
+    case 'deployment_offline':
       price = _conf.PRICE_OBJ.deployment_offline_per_month;
       break;
 
-    case "xuda_subdomain":
+    case 'xuda_subdomain':
       price = _conf.PRICE_OBJ.xuda_subdomain_per_month;
       break;
 
-    case "custom_domain":
+    case 'custom_domain':
       price = _conf.PRICE_OBJ.custom_domain_per_month;
       break;
 
-    case "user_monitor":
+    case 'user_monitor':
       price = _conf.PRICE_OBJ.user_monitor_per_month;
       break;
 
-    case "branding":
+    case 'branding':
       price = _conf.PRICE_OBJ.branding_per_month;
       break;
 
-    case "utility_screen":
+    case 'utility_screen':
       price = _conf.PRICE_OBJ.utility_screen_per_month;
       break;
 
@@ -1563,7 +1390,7 @@ const get_prices = function (uid, item) {
 //   //   val._deleted = true;
 //   //   contact_docs.push(val);
 //   // }
-//   // await db_module.sava_couch_bulk_docs("xuda_contacts", contact_docs);
+//   // await db_module.save_couch_bulk_docs("xuda_contacts", contact_docs);
 
 //   // const emails_ret = await db_module.find_couch_query("xuda_emails", {
 //   //   selector: {
@@ -1577,7 +1404,7 @@ const get_prices = function (uid, item) {
 //   //   email_docs.push(val);
 //   // }
 
-//   // await db_module.sava_couch_bulk_docs("xuda_emails", email_docs);
+//   // await db_module.save_couch_bulk_docs("xuda_emails", email_docs);
 
 //   ///////////////////////////////////
 //   return;

package/package.json

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