@gingkoo/base-server 0.0.1-alpha.0 → 0.0.1-alpha.2

package/backend/common/services/dict.js

@@ -0,0 +1,487 @@
+'use strict';
+const {
+  sqlExecutor,
+  queryBaseSqlBuilder,
+  insertSqlBuilder,
+  deleteSqlBuilder,
+  updateSqlBuilder,
+  pageQuery,
+  queryParamsBuilder,
+} = require('@gingkoo/node-tools');
+const { logger } = require('../logger/index');
+const entity = require('../entity');
+
+const dictService = {
+  /**
+   * 获取字典按 码表分组
+   * @param {string[]} dictList? 指定码表查询
+   */
+  async getDicts(dictList) {
+    dictList = Array.isArray(dictList) ? dictList : [];
+    let dictids = `'${dictList.join("','")}'`;
+
+    let { error, results } = await sqlExecutor(
+      `select * from ${entity.BASE_DICT_ITEMS} where ORG_ID=? ${
+        dictList.length ? `and DICT_ID in (${dictids})` : ''
+      } order by ORD_NO asc`,
+      [global.orgid],
+    );
+
+    if (error) {
+      logger.error(error);
+      return null;
+    }
+
+    let data = {};
+
+    results.forEach((element) => {
+      if (!data.hasOwnProperty(element.DICT_ID)) {
+        data[element.DICT_ID] = [];
+      }
+      data[element.DICT_ID].push({
+        value: element.ITEM_ID,
+        label: element.ITEM_VALUE,
+        icon: element.ITEM_ICON || '',
+        style: element.ITEM_STYLE || '',
+        color: element.ITEM_COLOR || '',
+      });
+    });
+
+    return data;
+  },
+  /**
+   * 获取字典按 码表分组
+   * @param {string[]} dictList? 指定码表查询
+   * 返回数据为 所有字段
+   */
+  async getDictsAll(dictList) {
+    dictList = Array.isArray(dictList) ? dictList : [];
+    let dictids = `'${dictList.join("','")}'`;
+
+    let { error, results } = await sqlExecutor(
+      `select * from ${entity.BASE_DICT_ITEMS} where ORG_ID=? ${
+        dictList.length ? `and DICT_ID in (${dictids})` : ''
+      } order by ORD_NO asc`,
+      [global.orgid],
+    );
+
+    if (error) {
+      logger.error(error);
+      return null;
+    }
+
+    let data = {};
+
+    results.forEach((element) => {
+      if (!data.hasOwnProperty(element.DICT_ID)) {
+        data[element.DICT_ID] = [];
+      }
+      data[element.DICT_ID].push({
+        value: element.ITEM_ID,
+        label: element.ITEM_VALUE,
+        icon: element.ITEM_ICON || '',
+        style: element.ITEM_STYLE || '',
+        color: element.ITEM_COLOR || '',
+        desc: element.ITEM_DESC || '',
+        parent: element.ITEM_PARENT || '',
+      });
+    });
+
+    return data;
+  },
+
+  /**
+   * 获取字典模块
+   * @param {object} filter
+   */
+  getModules: async function (filter) {
+    filter = filter || {};
+    filter.ORG_ID = global.orgid;
+    let { sql, params } = await queryBaseSqlBuilder(entity.BASE_DICT_MODULE, filter);
+
+    let { error, results } = await sqlExecutor(sql, params);
+    if (error) {
+      logger.error(error);
+      return null;
+    }
+
+    return results;
+  },
+
+  /**
+   * 获取分类
+   * @param {object} filter
+   */
+  getGroups: async function (filter) {
+    filter = filter || {};
+    let { sql, params } = await queryBaseSqlBuilder(entity.BASE_DICT, filter);
+
+    let { error, results } = await sqlExecutor(sql, params);
+    if (error) {
+      logger.error(error);
+      return null;
+    }
+
+    return results;
+  },
+
+  /**
+   * 获取码值
+   * @param {object} filter
+   * @returns
+   */
+  getDictItems: async function (filter, pageInfo) {
+    let pageSize = pageInfo.pageSize;
+    let pageIndex = pageInfo.pageIndex;
+    let searchParam = {};
+    let pops = {};
+    for (let v in filter) {
+      if (v !== 'DICT_ID') {
+        searchParam[v] = filter[v];
+        pops[v] = 'like';
+        Reflect.deleteProperty(filter, v);
+      }
+    }
+    filter = filter || {};
+    filter.ORG_ID = global.orgid;
+    let sql = '';
+    let params = {};
+    const dbResult = await queryBaseSqlBuilder(entity.BASE_DICT_ITEMS, filter);
+    sql += dbResult.sql;
+    params = dbResult.params;
+    if (Object.keys(searchParam).length > 0) {
+      const result = await queryParamsBuilder(searchParam, null, null, pops);
+      sql += ' and ' + result.sql;
+    }
+    sql += '  order by ISNULL(ORD_NO), ORD_NO';
+    let results = await pageQuery(sql, params, pageSize, pageIndex);
+    if (!results) {
+      logger.error(results.error);
+      return null;
+    }
+
+    return results;
+  },
+
+  /**
+   * 获取排序过后的字典模块
+   */
+  getOrderBaseDictModule: async function () {
+    let sql = `SELECT MODULE_ID,DICT_ID,DICT_NAME FROM ${entity.BASE_DICT} ORDER BY ISNULL(DATA_CRT_TIME),DATA_CRT_TIME DESC`;
+    let { error, results } = await sqlExecutor(sql);
+    if (error) {
+      logger.error(error);
+      return null;
+    }
+
+    return results;
+  },
+
+  /***
+   * 获取排序过后的字典信息
+   */
+  getOrderModules: async function () {
+    let sql = `SELECT MODULE_ID,MODULE_NAME FROM ${entity.BASE_DICT_MODULE} WHERE ORG_ID=?   ORDER BY DATA_CRT_TIME DESC`;
+    let { error, results } = await sqlExecutor(sql, [global.orgid]);
+    if (error) {
+      logger.error(error);
+      return null;
+    }
+
+    return results;
+  },
+
+  /**
+   * 创建字典模块
+   * @param {object} insertParams 插入的数据对象
+   * @param {array?} rawParams 不需要将值通过=? 方式引入的 列字段key集合
+   */
+  createModule: async function (insertParams, rawParams) {
+    let { sql, params } = insertSqlBuilder(entity.BASE_DICT_MODULE, insertParams, rawParams);
+
+    let { error, results } = await sqlExecutor(sql, params);
+    if (error) {
+      logger.error(error);
+      return null;
+    }
+
+    return results;
+  },
+
+  /**
+   * 创建字典分组
+   * @param {object} insertParams 插入的数据对象
+   * @param {array?} rawParams 不需要将值通过=? 方式引入的 列字段key集合
+   */
+  createDict: async function (insertParams, rawParams) {
+    let { sql, params } = insertSqlBuilder(entity.BASE_DICT, insertParams, rawParams);
+
+    let { error, results } = await sqlExecutor(sql, params);
+    if (error) {
+      logger.error(error);
+      return null;
+    }
+
+    return results;
+  },
+
+  /**
+   * 创建代码
+   * @param {object} insertParams 插入的数据对象
+   * @param {array?} rawParams 不需要将值通过=? 方式引入的 列字段key集合
+   * @returns
+   */
+  createDictItem: async function (insertParams, rawParams) {
+    const { DICT_ID } = insertParams;
+    let data = await this.getSortDictItem(DICT_ID);
+    if (!data) return null;
+    let orderNo = 1;
+    if (data.length > 0) {
+      for (let i = 0; i < data.length; i++) {
+        if (data[i].ORD_NO !== null) {
+          orderNo = data[i].ORD_NO;
+          break;
+        }
+      }
+    }
+
+    let { sql, params } = insertSqlBuilder(
+      entity.BASE_DICT_ITEMS,
+      {
+        ...insertParams,
+        ORD_NO: orderNo - 1,
+      },
+      rawParams,
+    );
+
+    let { error, results } = await sqlExecutor(sql, params);
+    if (error) {
+      logger.error(error);
+      return null;
+    }
+
+    return results;
+  },
+
+  /**
+   * 删除字典模块
+   * @param {object} filter 删除条件
+   * @returns
+   */
+  deleteModule: async function (filter) {
+    filter = filter || {};
+    filter.ORG_ID = global.orgid;
+
+    let { sql, params } = deleteSqlBuilder(entity.BASE_DICT_MODULE, filter);
+
+    let { error, results } = await sqlExecutor(sql, params);
+    if (error) {
+      logger.error(error);
+      return null;
+    }
+
+    return results;
+  },
+
+  /**
+   * 删除字典分组
+   * @param {object} filter 删除条件
+   * @returns
+   */
+  deleteDict: async function (filter) {
+    filter = filter || {};
+    filter.ORG_ID = global.orgid;
+
+    let { sql, params } = deleteSqlBuilder(entity.BASE_DICT, filter);
+
+    let { error, results } = await sqlExecutor(sql, params);
+    if (error) {
+      logger.error(error);
+      return null;
+    }
+
+    return results;
+  },
+
+  /**
+   * 删除字典代码
+   * @param {string[]} ids 需要删除的代码id ITEM_ID
+   * @param string DICT_ID 需要删除代码的DICT_ID
+   * @returns
+   */
+  deleteDictItem: async function (ids, DICT_ID) {
+    let params = [];
+    let itemIds = ids
+      .map((v) => {
+        params.push(v);
+        return '?';
+      })
+      .join(',');
+
+    params.push(global.orgid);
+    params.push(DICT_ID);
+
+    let sql = `DELETE from ${entity.BASE_DICT_ITEMS} where ITEM_ID in (${itemIds}) and ORG_ID = ? and DICT_ID =?`;
+
+    let { error, results } = await sqlExecutor(sql, params);
+    if (error) {
+      logger.error(error);
+      return null;
+    }
+
+    return results;
+  },
+
+  /**
+   * 更新字典模块
+   * @param {object} updateParams 更新的新值
+   * @param {object} filter 更新条件
+   */
+  updateModule: async function (updateParams, filter) {
+    filter = filter || {};
+    filter.ORG_ID = global.orgid;
+
+    let { sql, params } = updateSqlBuilder(entity.BASE_DICT_MODULE, updateParams, filter);
+
+    let { error, results } = await sqlExecutor(sql, params);
+    if (error) {
+      logger.error(error);
+      return null;
+    }
+
+    return results;
+  },
+
+  /**
+   * 更新字典分类
+   * @param {object} updateParams 更新的新值
+   * @param {object} filter 更新条件
+   */
+  updateDict: async function (updateParams, filter) {
+    filter = filter || {};
+    filter.ORG_ID = global.orgid;
+
+    let { sql, params } = updateSqlBuilder(entity.BASE_DICT, updateParams, filter);
+
+    let { error, results } = await sqlExecutor(sql, params);
+    if (error) {
+      logger.error(error);
+      return null;
+    }
+
+    return results;
+  },
+
+  /**
+   * 更新字典代码
+   * @param {object} updateParams 更新的新值
+   * @param {object} filter 更新条件
+   */
+  updateDictItem: async function (updateParams, filter) {
+    filter = filter || {};
+    filter.ORG_ID = global.orgid;
+
+    let { sql, params } = updateSqlBuilder(entity.BASE_DICT_ITEMS, updateParams, filter);
+
+    let { error, results } = await sqlExecutor(sql, params);
+    if (error) {
+      logger.error(error);
+      return null;
+    }
+
+    return results;
+  },
+
+  /**
+   * 获取排序后的码值
+   * @param {string} DICT 码值
+   * @returns
+   */
+  getSortDictItem: async function (DICT) {
+    const sql = `SELECT * FROM ${entity.BASE_DICT_ITEMS}  WHERE DICT_ID=? AND ORG_ID=? ORDER BY ISNULL(ORD_NO),ORD_NO `;
+    const { results, error } = await sqlExecutor(sql, [DICT, global.orgid]);
+    if (error) {
+      return null;
+    }
+
+    return results;
+  },
+
+  /****
+   * 批量更新字典
+   * @param {array} orderArr {ITEM_ID,}
+   * */
+  batchUpdateItem: async function (orderArr, DICT_ID) {
+    let sql = `UPDATE  ${entity.BASE_DICT_ITEMS} SET ORD_NO = CASE ITEM_ID `;
+    orderArr.map((v, i) => {
+      const { ITEM_ID } = v;
+      sql += ` WHEN '${ITEM_ID}' THEN ${i} `;
+    });
+    sql += ` END WHERE DICT_ID='${DICT_ID}' AND ORG_ID = '${global.orgid}'`;
+    const results = await sqlExecutor(sql);
+    return results;
+  },
+
+  // 判断字典的DICT_ID是否重复
+  isExistDictId: async function (DICT_ID) {
+    const { sql, params } = await queryBaseSqlBuilder(entity.BASE_DICT, { DICT_ID });
+    let result = await sqlExecutor(sql, params);
+    return result;
+  },
+  // 添加字典信息
+  addBaseDict: async function (MODULE_ID, DICT_NAME, DICT_ID) {
+    const { sql, params } = await insertSqlBuilder(entity.BASE_DICT, {
+      MODULE_ID,
+      DICT_NAME,
+      DICT_ID,
+    });
+    let result = await sqlExecutor(sql, params);
+    return result;
+  },
+  // 删除字典信息
+  delBaseDict: async function (filter = {}) {
+    const { sql, params } = await deleteSqlBuilder(entity.BASE_DICT, filter);
+    let result = await sqlExecutor(sql, params);
+    return result;
+  },
+
+  //删除字典项
+  deleteDictItems: async function (filter = {}) {
+    filter.ORG_ID = global.orgid;
+    const { sql, params } = await deleteSqlBuilder(entity.BASE_DICT_ITEMS, filter);
+    let result = await sqlExecutor(sql, params);
+    return result;
+  },
+
+  // 修改字典
+  modifyBaseDict: async function (DICT_ID, DICT_NAME) {
+    const { sql, params } = await updateSqlBuilder(
+      entity.BASE_DICT,
+      {
+        DICT_NAME,
+      },
+      { DICT_ID },
+    );
+    let result = await sqlExecutor(sql, params);
+    return result;
+  },
+
+  // 查询MODULE_ID
+  searchDICTModuleId: async function (DICT_ID) {
+    const sql = `SELECT MODULE_ID FROM ${entity.BASE_DICT} WHERE DICT_ID = '${DICT_ID}'`;
+    let result = await sqlExecutor(sql);
+    return result;
+  },
+
+  //查询字典模块表
+  getBaseDictModule: async function (filter) {
+    let filters = filter || {};
+    filters.ORG_ID = global.orgid;
+    const { sql, params } = await queryBaseSqlBuilder(entity.BASE_DICT_MODULE, filters);
+    let result = await sqlExecutor(sql, params);
+    if (result.error) return null;
+    return result;
+  },
+};
+
+module.exports = dictService;

package/backend/common/services/email.js

@@ -0,0 +1,49 @@
+'use strict';
+
+const {
+  sqlExecutor,
+  insertSqlBuilder,
+  updateSqlBuilder,
+  queryParamsBuilder,
+} = require('@gingkoo/node-tools');
+const entity = require('../entity');
+
+module.exports = {
+  /**
+   * 通用 获取邮件模版
+   * @returns any[]
+   */
+  getTempateInfo: async function (filters) {
+    let sql = `select * from ${entity.BASE_EMAIL_TEMPLATE} where `;
+    let params = queryParamsBuilder(filters);
+    let { error, results } = await sqlExecutor(sql + params.sql, params.params);
+    if (error) {
+      return null;
+    }
+    return results;
+  },
+  getEmailTempate: async function () {
+    let sql = `select * from ${entity.BASE_EMAIL_TEMPLATE}  WHERE  STATUS ='00' ORDER BY DATA_CRT_TIME `;
+    let { error, results } = await sqlExecutor(sql, []);
+    if (error) {
+      return [];
+    }
+    return results;
+  },
+  postEailTempate: async function (props) {
+    let param = insertSqlBuilder(entity.BASE_EMAIL_TEMPLATE, props);
+    let { error, results } = await sqlExecutor(param.sql, param.params);
+    if (error) {
+      return null;
+    }
+    return results;
+  },
+  putEailTempate: async function (filter, props) {
+    let param = updateSqlBuilder(entity.BASE_EMAIL_TEMPLATE, props, filter);
+    let { error, results } = await sqlExecutor(param.sql, param.params);
+    if (error) {
+      return null;
+    }
+    return results;
+  },
+};

package/backend/common/services/generalConfig.js

@@ -0,0 +1,137 @@
+'use strict';
+
+const {
+  sqlExecutor,
+  insertSqlBuilder,
+  updateSqlBuilder,
+  queryParamsBuilder,
+} = require('@gingkoo/node-tools');
+const entity = require('../entity');
+
+module.exports = {
+  /**
+   * 通用一般配置查询
+   * @param {*} filters
+   * @returns
+   */
+  getConfigInfo: async function (filters) {
+    if (!filters) return;
+    let sql = `select * from ${entity.BASE_CONFIG} where `;
+    let params = queryParamsBuilder(filters);
+    sql = sql + params.sql + ` ORDER BY DATA_CRT_TIME`;
+    let { error, results } = await sqlExecutor(sql, params.params);
+    if (error) {
+      return null;
+    }
+    return results;
+  },
+  /**
+   * 获取查询  所有配置信息
+   * @returns any[]
+   */
+  getConfig: async function () {
+    let sql = `select * from ${entity.BASE_CONFIG} WHERE  STATUS ='00'  ORDER BY DATA_CRT_TIME `;
+    let { error, results } = await sqlExecutor(sql, []);
+    if (error) {
+      return [];
+    }
+    return results;
+  },
+
+  /**
+   *
+   * @param {*} filters
+   * @returns
+   */
+  getFromConfig: async function (filters) {
+    if (!filters) return null;
+    let results = await this.getConfigInfo(filters);
+    let data = null;
+    if (Array.isArray(results)) {
+      data = results.reduce((x, y) => {
+        return {
+          ...x,
+          [y.CONFIG_ID]: y.CONFIG_VALUE,
+        };
+      }, {});
+    }
+    return data;
+  },
+
+  /**
+   * @param {*} props
+   * @param {*} props
+   * @returns
+   */
+  postConfig: async function (props) {
+    let param = insertSqlBuilder(entity.BASE_CONFIG, props);
+    let { error } = await sqlExecutor(param.sql, param.params);
+    if (error) {
+      return null;
+    }
+    return true;
+  },
+
+  /**
+   * 修改 一般配置配置信息
+   * 表：base_config
+   * @param {*} filter  筛洗条件
+   * @param {*} props   修改过内容
+   * @returns  true |null
+   */
+  putConfig: async function (filter, props) {
+    if (!filter || !props) return null;
+    let param = updateSqlBuilder(entity.BASE_CONFIG, props, filter);
+    let { error } = await sqlExecutor(param.sql, param.params);
+    if (error) {
+      console.log(error, 'error');
+      return null;
+    }
+    return true;
+  },
+
+  getGroupInfo: async function (filters) {
+    if (!filters) return;
+    let sql = `select * from ${entity.BASE_CONFIG_GROUP} where `;
+    let params = queryParamsBuilder(filters);
+    let { error, results } = await sqlExecutor(sql + params.sql, params.params);
+    if (error) {
+      return [];
+    }
+    return results;
+  },
+
+  getGroup: async function () {
+    let sql = `select * from ${entity.BASE_CONFIG_GROUP} WHERE  STATUS ='00' ORDER BY DATA_CRT_TIME`;
+    let { error, results } = await sqlExecutor(sql, []);
+    if (error) {
+      return [];
+    }
+    return results;
+  },
+
+  postGroup: async function (props) {
+    let param = insertSqlBuilder(entity.BASE_CONFIG_GROUP, props);
+    let { error } = await sqlExecutor(param.sql, param.params);
+    if (error) {
+      return null;
+    }
+    return true;
+  },
+
+  /**
+   * 修改一般配置分组
+   * 表：base_config_groups
+   * @param {*} filter  筛洗条件
+   * @param {*} props   修改内容
+   * @returns true|null
+   */
+  putGroup: async function (filter, props) {
+    let param = updateSqlBuilder(entity.BASE_CONFIG_GROUP, props, filter);
+    let { error } = await sqlExecutor(param.sql, param.params);
+    if (error) {
+      return null;
+    }
+    return true;
+  },
+};

package/backend/common/services/login.js

@@ -0,0 +1,18 @@
+const generalConfigServices = require('./generalConfig');
+
+const loginType = {
+  wechat: 'wechat',
+  account: 'account',
+};
+
+const getLoginMethod = async () => {
+  let res = await generalConfigServices.getConfigInfo({
+    CONFIG_ID: 'qywx_LOGIN',
+  });
+  if (res?.[0]?.CONFIG_VALUE === '1') {
+    return loginType.wechat;
+  }
+  return loginType.account;
+};
+
+module.exports = { loginType, getLoginMethod };