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

package/backend/common/page_engine.js

@@ -0,0 +1,487 @@
+const { readFileSync } = require('fs');
+const _ = require('lodash');
+const xmlreader = require('xmlreader');
+const { logger } = require('./logger');
+const { deepMerge } = require('../utils/object');
+const tokenize = require('../utils/tokenize');
+
+/**
+ * 将字符串转 bool
+ * @param {string} v 值
+ * @returns boolean
+ */
+function isbool(v) {
+  return v === 'true' ? true : false;
+}
+
+/**
+ * 出来字符串中的特殊字符  如 %26 -> &
+ * @param {string} str
+ */
+function handleSpecialChars(str) {
+  if (!str || typeof str !== 'string') return str;
+  return str.replace(/%26/g, '&');
+}
+
+/**
+ * 拆分字符串
+ * @param {string} str 源字符串
+ * @param {string?} delimiter 分隔符 默认不传是逗号
+ * @returns string[]
+ */
+function splitStr(str, delimiter = ',') {
+  if (!str || typeof str !== 'string') return [];
+  return str.split(delimiter).map((v) => v.trim());
+}
+
+function handleFields(fields) {
+  if (!Array.isArray(fields)) return [];
+  return fields.map((item) => {
+    let {
+      id,
+      component,
+      clearable,
+      required,
+      multiple,
+      searchable,
+      showValue,
+      block,
+      isFilter,
+      ...rest
+    } = item.attributes();
+
+    let field = {
+      type: typeMap[component] || component,
+      name: id,
+      ...rest,
+    };
+    if (clearable) {
+      field.clearable = isbool(clearable);
+    }
+    if (required) {
+      field.required = isbool(required);
+    }
+    if (multiple) {
+      field.multiple = isbool(multiple);
+    }
+    if (searchable) {
+      field.searchable = isbool(searchable);
+    }
+    if (block) {
+      field.block = isbool(block);
+    }
+    if (showValue) {
+      field.showValue = isbool(showValue);
+    }
+
+    // 是否支持搜索
+    if (isFilter) {
+      field.isFilter = isbool(isFilter) === false ? false : true;
+    }
+
+    if (item.element && Array.isArray(item.element.array)) {
+      field.children = handleFields(item.element.array);
+    }
+    return field;
+  });
+}
+
+// xml type 和 pandora 渲染器对应关系
+let typeMap = {
+  text: 'input-text',
+  dropdown: 'select',
+  date: 'input-date',
+  number: 'input-text',
+  image: 'input-image',
+  file: 'input-file',
+  tag: 'input-tag',
+  textarea: 'textarea',
+};
+
+// schema 缓存
+// TODO. 页面需要存  xml 最好也来一份 因为解析xml也废时间
+const caches = {
+  pages: {},
+  _getKey(keyData) {
+    return (keyData = typeof keyData === 'string' ? keyData : JSON.stringify(keyData));
+  },
+  add(keyData, pageContent) {
+    let cacheId = this._getKey(keyData);
+    this.pages[cacheId] = pageContent;
+  },
+  get(keyData) {
+    let cacheId = this._getKey(keyData);
+    return this.pages[cacheId];
+  },
+};
+
+class BaseXML {
+  constructor(xml, data) {
+    this.data = data;
+    this.xmlPath = xml;
+    this.schema = null;
+  }
+
+  loadXml(xmlPath) {
+    let xmlContent = readFileSync(xmlPath, 'utf8');
+    return xmlContent;
+  }
+
+  getXmlData() {
+    const xmlContent = this.loadXml(this.xmlPath);
+
+    let schema = {};
+    xmlreader.read(xmlContent, (err, res) => {
+      if (err) return logger.error(err);
+      let Fields = res.PageView.Fields;
+      let Operations = res.PageView.Operations;
+      let Table = res.PageView.Table;
+      let Form = res.PageView.Form;
+
+      // 公共的表单信息
+      let fields = handleFields(Array.isArray(Fields?.element?.array) ? Fields.element.array : []);
+
+      // 公共的按钮信息
+      let btns = (Array.isArray(Operations?.element?.array) ? Operations.element.array : []).reduce(
+        (mo, item) => {
+          let { id, ...rest } = item.attributes();
+          if (Reflect.has(rest, 'api')) {
+            rest.api = tokenize(handleSpecialChars(rest.api), this.data);
+          }
+          if (Reflect.has(rest, 'api2')) {
+            rest.api2 = tokenize(handleSpecialChars(rest.api2), this.data);
+          }
+
+          mo[id] = rest;
+          return mo;
+        },
+        {},
+      );
+
+      let body = [];
+
+      if (Table) {
+        let tableSchame = this.parseTable(Table, fields, btns);
+        body.push(tableSchame);
+      }
+
+      if (Form) {
+        let formSchame = this.parseForm(Form, fields, btns);
+        body.push(formSchame);
+      }
+      // PROJECT_ID;
+      let { title, blockApi, initApi } = res.PageView.attributes();
+
+      if (title) {
+        schema.title = title;
+      }
+      if (blockApi) {
+        schema.blockApi = splitStr(handleSpecialChars(blockApi)).map((it) =>
+          tokenize(it, this.data),
+        );
+      }
+      if (initApi) {
+        schema.initApi = splitStr(handleSpecialChars(initApi)).map((it) => tokenize(it, this.data));
+      }
+
+      schema.type = 'page';
+      schema.body = body;
+    });
+    this.schema = schema;
+  }
+
+  getXmlFieldsData() {
+    const xmlContent = this.loadXml(this.xmlPath);
+
+    let fields = {};
+    xmlreader.read(xmlContent, (err, res) => {
+      if (err) return logger.error(err);
+      let Fields = res.PageView.Fields;
+
+      // 公共的表单信息
+      (Array.isArray(Fields?.element?.array) ? Fields.element.array : []).forEach((item) => {
+        let { id, label, component, source } = item.attributes();
+        if (id === 'STAGE_NAME') {
+          (Array.isArray(item?.element?.array) ? item?.element?.array : []).forEach((v) => {
+            let { id, label, component, source } = v.attributes();
+            fields[id] = {
+              label,
+              component,
+              source,
+            };
+          });
+        }
+        fields[id] = {
+          label,
+          component,
+          source,
+        };
+      });
+    });
+
+    return fields;
+  }
+
+  // 解析 表单
+  parseForm() {}
+
+  // 解析 table
+  parseTable(Table, fields, btns) {
+    let DefaultQuery = Table.DefaultQuery;
+    let TableHead = Table.TableHead;
+    let TableBody = Table.TableBody;
+    let TableFoot = Table.TableFoot;
+
+    let {
+      rowKey, // 行唯一key
+      autoFillHeight, // 表格是否一屏显示
+      api, // 表格查询接口
+      getAllApi, // 表格查询接口 (不分页)
+      addApi, // 表格新增接口
+      delApi, // 表格删除接口
+      editApi, // 表格编辑接口
+      saveOrderApi, // 表格排序接口
+      columnApi, // 左上角radio列表接口
+      addModalSize = '', // 新增modal 弹框大小 xs、sm、md、lg,xl, xxl 有五个档 其中xxl 是 全屏， 默认不填 是 sm
+      editModalSize = '', // 编辑modal 弹框大小
+      editSingleSave, // 编辑弹框是否单个保存
+      placeholder = '', // 单元格占位符
+    } = Table.attributes();
+    let schemaTable = {
+      fields,
+      rowKey,
+      placeholder,
+      autoFillHeight: isbool(autoFillHeight),
+      api: tokenize(handleSpecialChars(api), this.data),
+      getAllApi: tokenize(handleSpecialChars(getAllApi), this.data),
+      addApi: tokenize(handleSpecialChars(addApi), this.data),
+      delApi: tokenize(handleSpecialChars(delApi), this.data),
+      editApi: tokenize(handleSpecialChars(editApi), this.data),
+      saveOrderApi: tokenize(handleSpecialChars(saveOrderApi), this.data),
+      columnApi: tokenize(handleSpecialChars(columnApi), this.data),
+      addModalSize,
+      editModalSize,
+      editSingleSave: isbool(editSingleSave),
+    };
+
+    // 默认查询参数
+    if (Array.isArray(DefaultQuery?.element?.array) && DefaultQuery.element.array.length) {
+      schemaTable.defaultParams = {};
+      DefaultQuery.element.array.forEach((item) => {
+        let { id, value } = item.attributes();
+        schemaTable.defaultParams[id] = value;
+      });
+    }
+
+    // 过滤器
+    if (TableHead) {
+      let filterOptions = { leftAction: {}, rightAction: {} };
+      let { isReset, isMode, isContrl, isFilterPlus, isGroup, draggable, defaultGroupKey } =
+        TableHead.attributes();
+      filterOptions.isFilterPlus = isbool(isFilterPlus);
+      filterOptions.draggable = isbool(draggable);
+      filterOptions.rightAction.isReset = isbool(isReset);
+      filterOptions.rightAction.isMode = isbool(isMode);
+      filterOptions.rightAction.isContrl = isbool(isContrl);
+      filterOptions.rightAction.isGroup = isbool(isGroup);
+      if (defaultGroupKey) {
+        filterOptions.rightAction.defaultGroupKey = defaultGroupKey;
+      }
+
+      if (TableHead.filter) {
+        let { list } = TableHead.filter.attributes();
+        filterOptions.rightAction.filter = splitStr(list);
+      }
+      if (TableHead.filterPlus && isbool(isFilterPlus)) {
+        let { get, add, edit, save } = TableHead.filterPlus.attributes();
+        filterOptions.filterPlusApi = {
+          get: tokenize(handleSpecialChars(get), this.data),
+          add: tokenize(handleSpecialChars(add), this.data),
+          edit: tokenize(handleSpecialChars(edit), this.data),
+          save: tokenize(handleSpecialChars(save), this.data),
+        };
+      }
+      if (TableHead.mode) {
+        filterOptions.rightAction.modeOptions = {};
+        let {
+          default: defaultMode,
+          minTableWidth,
+          minDetailWidth,
+          detailWidth,
+        } = TableHead.mode.attributes();
+
+        if (defaultMode) {
+          filterOptions.rightAction.modeOptions.default = defaultMode;
+        }
+        if (minTableWidth) {
+          filterOptions.rightAction.modeOptions.minTableWidth = +minTableWidth;
+        }
+        if (minDetailWidth) {
+          filterOptions.rightAction.modeOptions.minDetailWidth = +minDetailWidth;
+        }
+        if (detailWidth) {
+          filterOptions.rightAction.modeOptions.detailWidth = +detailWidth;
+        }
+      }
+      if (TableHead.contrl) {
+        filterOptions.rightAction.contrlApi = {};
+        let { get, save } = TableHead.contrl.attributes();
+
+        if (get) {
+          filterOptions.rightAction.contrlApi.get = tokenize(handleSpecialChars(get), this.data);
+        }
+        if (save) {
+          filterOptions.rightAction.contrlApi.save = tokenize(handleSpecialChars(save), this.data);
+        }
+      }
+      if (TableHead.action) {
+        let { components } = TableHead.action.attributes();
+        filterOptions.leftAction.action = splitStr(components).reduce((mo, btn) => {
+          if (btn in btns) {
+            mo.push(btns[btn]);
+          }
+          return mo;
+        }, []);
+      }
+      if (TableHead.actionMore) {
+        let { components } = TableHead.actionMore.attributes();
+        filterOptions.leftAction.actionMore = splitStr(components).reduce((mo, btn) => {
+          if (btn in btns) {
+            mo.push(btns[btn]);
+          }
+          return mo;
+        }, []);
+      }
+
+      schemaTable.filterOptions = filterOptions;
+    }
+
+    // 表格列信息
+    let columns = (Array.isArray(TableBody?.column?.array) ? TableBody.column.array : []).map(
+      (item) => {
+        let { id, label, components, width, toggled, fixed, sortable, filterable, showValue } =
+          item.attributes();
+        let column = {
+          name: id,
+        };
+        if (label) {
+          column.label = label;
+        }
+        if (width) {
+          column.width = +width;
+        }
+        if (toggled) {
+          column.toggled = isbool(toggled);
+        }
+        if (fixed) {
+          column.fixed = fixed;
+        }
+        if (sortable) {
+          column.sortable = isbool(sortable);
+        }
+        if (filterable) {
+          column.filterable = isbool(filterable);
+        }
+        if (showValue) {
+          column.showValue = isbool(showValue);
+        }
+
+        if (id === 'opr' && components) {
+          schemaTable.oprBtns = splitStr(components).reduce((mo, btn) => {
+            if (btn in btns) {
+              mo.push(btns[btn]);
+            }
+            return mo;
+          }, []);
+        }
+        return column;
+      },
+    );
+
+    // 表格底部分页部分
+    if (TableFoot) {
+      let { show, showPageInput, statistics, placeLeft, placeRight, switchPage } =
+        TableFoot.attributes();
+      if (show === 'false') {
+        schemaTable.pagination = null;
+      } else {
+        schemaTable.pagination = {
+          place: [],
+          showPageInput: isbool(showPageInput),
+          statistics,
+          switchPage: splitStr(switchPage),
+        };
+        if (placeLeft) {
+          schemaTable.pagination.place[0] = splitStr(placeLeft);
+        }
+        if (placeRight) {
+          schemaTable.pagination.place[1] = splitStr(placeRight);
+        }
+      }
+    }
+
+    schemaTable.type = 'table';
+    schemaTable.columns = columns;
+
+    return schemaTable;
+  }
+}
+
+class PageEngine extends BaseXML {
+  constructor({ json, xml, html }, data) {
+    super(xml, data);
+    this.jsonPath = json;
+    this.htmlPath = html;
+  }
+
+  /**
+   * 生成html
+   * @param {object} schemaData schema 数据，可以传进来也可以不传
+   */
+  renderHtml(schemaData = null) {
+    let schema = schemaData || this.generateSchema();
+
+    let tmplContent = readFileSync(this.htmlPath, 'utf8');
+
+    // TODO. 下面这种约定死的占位 可以优化
+    let html = tmplContent.replace('{title}', schema?.title || '');
+    let htmlContent = html.replace("'{{schema}}'", JSON.stringify(schema));
+
+    return htmlContent;
+  }
+
+  // 生成 schema
+  generateSchema() {
+    let cacheContent = null;
+    if ((cacheContent = caches.get(this.data))) return cacheContent;
+
+    this.getXmlData();
+
+    cacheContent = require(this.jsonPath);
+    if (this.schema) {
+      cacheContent = deepMerge(this.schema, cacheContent);
+    }
+
+    caches.add(this.data, cacheContent);
+    return cacheContent;
+  }
+
+  /**
+   * 获取页面配置 json 不传则返回全部
+   * @param {string?} field json指定字段, 不传返回 整个page，传了 就从 tableJson 第一层拿
+   */
+  renderJson(field) {
+    let schema = this.generateSchema();
+    if (!field) return schema;
+
+    let tableJson = schema?.body?.[0] || {};
+    return tableJson?.[field] || null;
+  }
+
+  getFields() {
+    let fields = this.getXmlFieldsData();
+    return fields;
+  }
+}
+
+module.exports = PageEngine;

package/backend/common/schedule.js

@@ -0,0 +1,45 @@
+// 定时任务
+const schedule = require('node-schedule');
+const { schedulelog } = require('./logger');
+
+class Schedule {
+  tasks = {};
+  /**
+   * Registers a new task with a given name, cron expression, and callback function.
+   *
+   * @param {string} name - The name of the task.
+   * @param {string} cron - The cron expression for the task's schedule.
+   * @param {function} cb - The callback function to be executed when the task runs.
+   *
+   * @returns {void} - No return value.
+   *
+   * @example
+   * const schedule = require('./schedule');
+   * const task = new schedule.Schedule();
+   * task.registerTask('myTask', '0 0 * * *', () => {
+   *   console.log('This task runs every minute');
+   * });
+   */
+  registerTask(name, cron, cb) {
+    if (typeof name !== 'string') return console.log('请输入定时器名字');
+    if (typeof cron !== 'string') return console.log('请输入定时器规则');
+    if (typeof cb !== 'function') return console.log('请输入定时器逻辑');
+
+    this.tasks[name] = {
+      cron,
+      cb,
+    };
+  }
+  run() {
+    for (const name in this.tasks) {
+      schedule.scheduleJob(this.tasks[name].cron, () => {
+        schedulelog.debug(`执行job: ${name}`);
+        this.tasks[name].cb(() => {
+          schedulelog.debug(`${name} 执行完成`);
+        });
+      });
+    }
+  }
+}
+
+module.exports = new Schedule();

package/backend/common/services/dataCombine.js

@@ -0,0 +1,67 @@
+'use strict';
+const { v4: uuidv4 } = require('uuid');
+const { sqlExecutor, queryBaseSqlBuilder, insertSqlBuilder } = require('@gingkoo/node-tools');
+const { logger } = require('../logger/index');
+const entity = require('../entity');
+
+const dataCombineService = {
+  fetchFields: [
+    'DATA_ID', //  数据 id
+    'MODULE_ID', //  模块 id
+  ],
+
+  createFields: [
+    'DATA_LINK_ID', //关联 id, 逗号分割
+    'MODULE_ID', //模块
+    'DATA_DESC', //描述
+    'EXPIRED_TIME', //过期时间
+  ],
+
+  async fetch(_where) {
+    let where = {};
+    this.fetchFields.forEach((field) => {
+      if (Reflect.has(_where, field)) {
+        where[field] = _where[field];
+      }
+    });
+
+    let filter = {
+      ORG_ID: global.orgid,
+      STATUS: '00',
+      ...where,
+    };
+    let { sql, params } = await queryBaseSqlBuilder(entity.DATA_COMBINE, filter);
+    let { error, results } = await sqlExecutor(sql + ' order by DATA_CRT_TIME desc', params);
+    if (error) {
+      logger.error('查询数据失败', error);
+    }
+
+    return [error, results];
+  },
+
+  async create(_props) {
+    let props = {};
+    this.createFields.forEach((field) => {
+      if (Reflect.has(_props, field)) {
+        props[field] = _props[field];
+      }
+    });
+
+    let DATA_ID = uuidv4();
+    props = {
+      ORG_ID: global.orgid,
+      STATUS: '00',
+      DATA_ID,
+      ...props,
+    };
+
+    let { sql, params } = insertSqlBuilder(entity.DATA_COMBINE, props);
+    let { error } = await sqlExecutor(sql, params);
+    if (error) {
+      logger.error('配置数据记录失败', error);
+    }
+    return [error, DATA_ID];
+  },
+};
+
+module.exports = dataCombineService;

package/backend/common/services/dept.js

@@ -0,0 +1,37 @@
+'use strict';
+const { sqlExecutor, insertSqlBuilder } = require('@gingkoo/node-tools');
+const { logger } = require('../logger/index');
+const entity = require('../entity');
+
+const deptService = {
+  // 获取部门列表
+  async getDepts() {
+    let { error, results } = await sqlExecutor(
+      `select DEPT_NO, DEPT_NAME FROM ${entity.IDM_DEPTS} where ORG_ID=?`,
+      [global.orgid],
+    );
+
+    if (error || !results.length) {
+      error && logger.error(error);
+      return null;
+    }
+
+    return results;
+  },
+
+  // 添加部门
+  async createDept(params) {
+    if (!params.DEPT_NO) return null;
+    !params.ORG_ID && (params['ORG_ID'] = global.orgid);
+    let sqlResult = insertSqlBuilder(entity.IDM_DEPTS, params);
+    let dbResult = await sqlExecutor(sqlResult.sql, sqlResult.params);
+    if (dbResult.error) {
+      logger.error(dbResult.error);
+      return null;
+    }
+
+    return true;
+  },
+};
+
+module.exports = deptService;