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

package/backend/common/logger/index.js

@@ -0,0 +1,96 @@
+const log4js = require('log4js');
+const path = require('path');
+const config = require('../../config');
+
+const appenders = {
+  console: {
+    type: 'console',
+  },
+  applog: {
+    type: 'dateFile',
+    filename: path.join(config.app.home, 'logs', 'app.log'),
+    pattern: 'yyyy-MM-dd.log',
+    // alwaysIncludePattern: true,
+    // maxLogSize: 10, // 无效
+    // backups: 5, // 无效
+    compress: false,
+    numBackups: 7,
+  },
+  wslog: {
+    type: 'dateFile',
+    filename: path.join(config.app.home, 'logs', 'ws.log'),
+    pattern: 'yyyy-MM-dd.log',
+    compress: false,
+    numBackups: 7,
+  },
+
+  infolog: {
+    type: 'dateFile',
+    filename: path.join(config.app.home, 'logs', 'info.log'),
+    pattern: 'yyyy-MM-dd.log',
+    compress: true,
+    numBackups: 7,
+  },
+  scheduleLog: {
+    type: 'dateFile',
+    filename: path.join(config.app.home, 'logs', 'schedule.log'),
+    pattern: 'yyyy-MM-dd.log',
+    compress: false,
+    numBackups: 7,
+  },
+  ...config.logger.appenders,
+};
+
+const categories = {
+  default: {
+    appenders: ['console'],
+    level: 'debug',
+  },
+  applog: {
+    // 指定为上面定义的appender，如果不指定，无法写入
+    appenders: ['console', 'applog'],
+    level: 'debug', // 指定等级
+  },
+  infolog: {
+    appenders: ['console', 'infolog'],
+    level: 'info',
+  },
+  wslog: {
+    appenders: ['console', 'wslog'],
+    level: 'debug',
+  },
+
+  schedulelog: {
+    appenders: ['console', 'scheduleLog'],
+    level: 'debug', // 指定等级
+  },
+  ...config.logger.categories,
+};
+
+log4js.configure({
+  appenders,
+  categories,
+  // for pm2...
+  pm2: true,
+  disableClustering: true, // not sure...
+});
+
+function getLogger(type) {
+  return log4js.getLogger(type);
+}
+
+module.exports = new Proxy(appenders, {
+  get(target, prop) {
+    if (prop === 'getLogger') {
+      return getLogger;
+    }
+    if (prop === 'logger') {
+      return log4js.getLogger('applog');
+    }
+    if (prop in target) {
+      return log4js.getLogger(prop);
+    }
+
+    return null;
+  },
+});

package/backend/common/mapping.js

@@ -0,0 +1,128 @@
+const isPlainObject = require('lodash/isPlainObject');
+const dictService = require('./services/dict');
+
+const userService = require('./services/user');
+
+class MappingFactory {
+  /**
+   * interface DictMap {
+   *  [module: string]: {
+   *    [DICT_ID: string]: any
+   *  }
+   * }
+   */
+  dictMap = {};
+
+  register(module, moduleMapping) {
+    if (typeof module !== 'string') return console.log('MappingFactory register 缺少参数 module');
+
+    this.dictMap[module] = moduleMapping ?? {};
+  }
+
+  async getMapping(module, dict_ids, extra) {
+    let mapping = {};
+    let list = {};
+
+    if (!Array.isArray(dict_ids) || !dict_ids?.length) {
+      return {
+        dict: mapping,
+        list: list,
+      };
+    }
+
+    let modulesMap = {
+      async USER_LIST() {
+        let res = await userService.getUsers();
+        let arr = [];
+        let dict = res.reduce((mo, item) => {
+          if (item.USER_ID) {
+            arr.push({ value: item.USER_ID, label: item.USER_NAME });
+            mo[item.USER_ID] = item.USER_NAME;
+          }
+          return mo;
+        }, {});
+
+        return {
+          dict,
+          list: arr,
+        };
+      },
+    };
+
+    if (module in this.dictMap) {
+      modulesMap = {
+        ...modulesMap,
+        ...this.dictMap[module],
+      };
+    }
+
+    // 字典表字典
+    let base_dict = [];
+    // 模块字典
+    let module_dict = [];
+
+    dict_ids.forEach((id) => {
+      if (modulesMap[id]) {
+        module_dict.push(id);
+      } else {
+        base_dict.push(id);
+      }
+    });
+
+    if (base_dict.length) {
+      let dicts = await dictService.getDicts(base_dict);
+      if (isPlainObject(dicts)) {
+        Object.entries(dicts).forEach((dict) => {
+          let [key, value] = dict;
+          if (Array.isArray(value) && value.length) {
+            mapping[key] = value.reduce((mo, item) => {
+              let { value, ...rest } = item;
+              mo[value] = rest;
+              return mo;
+            }, {});
+            list[key] = value.map((item) => {
+              return {
+                label: item.label,
+                value: item.value,
+              };
+            });
+          }
+        });
+      }
+    }
+
+    if (module_dict.length) {
+      await module_dict.myforeach(async (dict_id) => {
+        let fn = modulesMap[dict_id];
+        let result = {};
+        if (isAsync(fn)) {
+          result = await fn(extra);
+        } else if (typeof fn === 'function') {
+          result = fn(extra);
+        } else {
+          result = fn;
+        }
+
+        if (isPlainObject(result)) {
+          if (result['dict']) {
+            mapping[dict_id] = result['dict'];
+          }
+          if (result['list']) {
+            list[dict_id] = result['list'];
+          }
+        }
+      });
+    }
+
+    return {
+      dict: mapping,
+      list: list,
+    };
+  }
+}
+
+function isAsync(func) {
+  return Object.prototype.toString.call(func) === '[object AsyncFunction]';
+}
+
+module.exports = new MappingFactory();

package/backend/common/middleware/auth.js

@@ -0,0 +1,109 @@
+'use strict';
+const jwt = require('../../utils/jwt');
+const config = require('../../config/index');
+const { loginType, getLoginMethod } = require('../services/login');
+
+// 后端登录
+async function authCheck(req, res, next) {
+  if (req.login) return next();
+  let token = req.cookies['X-Token'] || req.get('X-Token');
+  const authorization = req.headers.authorization;
+  if (!token && authorization) {
+    token = authorization?.split?.('Bearer ')?.[1] || '';
+  }
+
+  let data = jwt.token2data(token);
+  if (data) {
+    let { userid, exp } = data;
+    if (userid) {
+      req.headers['x-userid'] = userid;
+      let expires = new Date();
+      expires.setDate(expires.getDate() + 3);
+      if (exp + 30 * 60 > Math.floor(Date.now() / 1000)) {
+        let token = jwt.generateToken(tokenData);
+        res.cookie('X-Token', token, { expires });
+      }
+    }
+    return next();
+  }
+
+  if ((await getLoginMethod()) === loginType.wechat) {
+    res.redirect('/wechat/auth');
+  } else {
+    let referer = req.headers.referer;
+    let pandoraPort = '3002';
+    if (referer && ~referer.indexOf(pandoraPort)) {
+      req.headers['x-userid'] = config['testUser'];
+      return next();
+    } else {
+      res.redirect('/#/login');
+    }
+  }
+}
+
+// 前端登录
+function checkLogin(req, res, next) {
+  let token = req.cookies['X-Token'] || req.get('X-Token');
+  const ip = req.ip;
+  const authorization = req.headers.authorization;
+  if (!token && authorization) {
+    token = authorization?.split?.('Bearer ')?.[1] || '';
+  }
+
+  let data = jwt.token2data(token);
+  if (data) {
+    let { userid, exp } = data;
+    if (userid) {
+      req.headers['x-userid'] = userid;
+      let expires = new Date();
+      expires.setDate(expires.getDate() + 3);
+      if (exp + 30 * 60 > Math.floor(Date.now() / 1000)) {
+        let token = jwt.generateToken(tokenData);
+        res.cookie('X-Token', token, { expires });
+      }
+    }
+    return next();
+  }
+
+  if (config.allowedIPs.some((it) => ip.startsWith(it))) {
+    req.headers['x-userid'] = req.query.userid || config.testUser || '';
+    return next();
+  }
+
+  res.sendStatus(401);
+}
+
+// 机器人登录校验
+function appAuthCheck(req, res, next) {
+  const authorization = req.headers.authorization;
+  if (authorization) {
+    const appid = jwt.token2data(authorization.split('Bearer ')?.[1], 'appid');
+    if (appid) {
+      req.headers.appid = appid;
+    }
+  }
+  return next();
+}
+
+// 用户授权的第三方应用 token校验，
+function userAppAuthCheck(req, res, next) {
+  const authorization = req.headers.authorization;
+  if (authorization) {
+    const token = authorization.split('Bearer ')?.[1];
+    const cert = req.headers.cert;
+    if ((token, cert)) {
+      const userid = jwt.token2data(token, 'userid', cert);
+      if (userid) {
+        req.headers['x-userid'] = userid || '';
+      }
+    }
+  }
+  return next();
+}
+
+module.exports = {
+  authCheck,
+  checkLogin,
+  appAuthCheck,
+  userAppAuthCheck,
+};

package/backend/common/middleware/cors.js

@@ -0,0 +1,13 @@
+module.exports = function allowCors(req, res, next) {
+  res.header('Access-Control-Allow-Origin', req.headers.origin);
+  res.header('Access-Control-Allow-Methods', 'GET,PUT,POST,DELETE,OPTIONS');
+  res.header('Access-Control-Allow-Headers', 'Content-Type,X-Token');
+  res.header('Access-Control-Allow-Credentials', 'true');
+
+  if (req.method === 'OPTIONS') {
+    res.sendStatus(200);
+  } else {
+    // 处理实际请求
+    next();
+  }
+};

package/backend/common/middleware/response.js

@@ -0,0 +1,25 @@
+const errorCode = {};
+
+const response = (req, res, next) => {
+  res.sendOk = (data = null) => {
+    res.json({
+      code: 'OK',
+      message: 'success',
+      data,
+    });
+  };
+
+  res.sendErr = (message, code = '-1', data) => {
+    let content = {
+      code,
+      message: errorCode[code] || message,
+    };
+    if (data) {
+      content.data = data;
+    }
+    res.json(content);
+  };
+  next();
+};
+
+module.exports = response;