@codertqy/elpis 1.0.0

package/model/index.js

@@ -0,0 +1,129 @@
+const _ = require("lodash");
+const glob = require("glob");
+const path = require("path");
+const { sep } = path;
+
+/**
+ * 项目 project 继承 model 方法
+ * @param {} model 基类的数据
+ * @param {*} project 每一个项目类的数据
+ * @returns
+ */
+const porjectExtendModel = (model, project) => {
+  // 回调函数的参数是与前者对应
+  return _.mergeWith({}, model, project, (modelValue, projValue) => {
+    // 处理数组数据合并的特殊情况，不是数组，使用lodash默认合并
+    // 一般对应着 结构中的 menu 属性
+    if (_.isArray(modelValue) && _.isArray(projValue)) {
+      let result = [];
+      // 因为 project 继承 model 所以需要处理修改和新增内容的情况
+      // project有的，model也有 ---》修改(重载)
+      // project有的，model没有 ---》新增(扩展)
+      // model有的，project也有 ---》保留(继承)
+
+      // 处理 修改/保留  判断项目类中的是否有基类的。有就进行覆盖修改/保留
+      for (let i = 0; i < modelValue.length; i++) {
+        let modelItem = modelValue[i];
+        const projItem = projValue.find(
+          (projItem) => projItem.key === modelItem.key,
+        );
+        // 都有，则递归调用 porjectExtendModel 方法 覆盖修改
+        result.push(
+          projItem ? porjectExtendModel(modelItem, projItem) : modelItem,
+        );
+      }
+      // 处理新增，判断基类中是否有项目类中的，没有则直接新增、有则不做任何操作
+      for (let i = 0; i < projValue.length; i++) {
+        let projItem = projValue[i];
+        const modelItem = modelValue.find(
+          (modelItem) => projItem.key === modelItem.key,
+        );
+        // 找不到直接新增
+        if (!modelItem) {
+          result.push(projItem);
+        }
+      }
+      // 拿到合并后的效果
+      return result;
+    }
+  });
+};
+
+
+/**
+ * 解析 model 配置，并返回组织且继承后的数据结构
+ * [{
+ *  modelKey: ${model},
+ *  project:{
+ *      proj1Key：${proj1},
+ *      proj2Key：${proj2},
+ *  }
+ * },...]
+ */
+
+module.exports = (app) => {
+  const modelList = [];
+  // 遍历当前文件夹，构造模型数据结构，挂载到 modelList 上
+  const modelPath = path.resolve(process.cwd(), `.${sep}model`);
+  const fileList = glob.sync(path.resolve(modelPath, `.${sep}**${sep}**.js`));
+
+  // 遍历每一个文件
+  fileList.forEach((file) => {
+    if (file.indexOf("index.js") > -1) {
+      return;
+    }
+    // 区分配置类型是 （model / project）
+
+    // 具体的模型文件
+    const type = file.indexOf(`/project/`) > -1 ? "project" : "model";
+    if (type === "project") {
+      // 拿到基类key
+      const modelKey = file.match(/\/model\/(.*?)\/project/)?.[1];
+      // 具体的 项目类key
+      const projKey = file.match(/\/project\/(.*?)\.js/)?.[1];
+
+      const modelItem = modelList.find((item) => item.model?.key === modelKey);
+      if (!modelItem) {
+        // 初始化 model 数据结构
+        modelItem = {};
+        modelList.push(modelItem);
+      }
+      if (!modelItem.project) {
+        // 初始化 project 数据结构
+        modelItem.project = {};
+      }
+      // 将项目类的属性与值全部挂载到project上（以projKey作为键），并且注入projKey
+      modelItem.project[projKey] = require(path.resolve(file));
+      modelItem.project[projKey].key = projKey;
+      modelItem.project[projKey].modelKey = modelKey; //注入 modelKey 告诉所属哪一个
+    }
+    // 基类模型，重新构造数据格式
+    if (type === "model") {
+      // 拿到当前基类的类型：buiness / course
+      const modelKey = file.match(/\/model\/(.*?)\/model\.js/)?.[1];
+      let modelItem = modelList.find((item) => item.model?.key === modelKey);
+      if (!modelItem) {
+        // 初始化 model 数据结构
+        modelItem = {};
+        modelList.push(modelItem);
+      }
+      // 将基类中的属性与值全部挂载到model上，并且注入modelKey
+      modelItem.model = require(path.resolve(file));
+      modelItem.model.key = modelKey;
+    }
+  });
+
+  // 数据进一步整理 project ==> 继承 model
+  modelList.forEach((item) => {
+    // 解析基类的数据，以及项目类的数据
+    const { model, project } = item;
+
+    // 遍历项目类数据，继承基类数据
+    for (const key in project) {
+      // 拿到的key属性就是 taobao、pdd之类的
+      // 值是数组，则进行遍历操作，如果是基本类型，则直接进行lodash中的覆盖合并
+      project[key] = porjectExtendModel(model, project[key]);
+    }
+  });
+  return modelList;
+};

package/package.json

@@ -0,0 +1,92 @@
+{
+  "name": "@codertqy/elpis",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "lint": "eslint --quiet --ext js,vue .",
+    "test": "set _ENV=local && mocha ./test/**/*.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://git.code.tencent.com/codertqy/elpis.git"
+  },
+  "author": "codertqy",
+  "license": "ISC",
+  "dependencies": {
+    "@babel/core": "^7.24.0",
+    "@element-plus/icons-vue": "^2.3.2",
+    "ajv": "^6.10.2",
+    "axios": "^0.19.2",
+    "echarts": "^5.5.0",
+    "element-plus": "^2.3.7",
+    "generate-password": "^1.7.1",
+    "glob": "^7.1.4",
+    "jsonwebtoken": "^9.0.2",
+    "knex": "^0.19.0",
+    "koa": "2.7.0",
+    "koa-bodyparser": "^4.2.1",
+    "koa-nunjucks-2": "^3.0.2",
+    "koa-router": "^7.4.0",
+    "koa-static": "^5.0.0",
+    "koa-useragent": "2.0.0",
+    "koa2-cors": "^2.0.6",
+    "less": "^3.8.1",
+    "lodash": "^4.17.21",
+    "log4js": "^6.9.1",
+    "md5": "^2.2.1",
+    "moment": "^2.29.4",
+    "mysql": "^2.18.1",
+    "node-schedule": "^2.1.1",
+    "nodemon": "^1.19.2",
+    "path": "^0.12.7",
+    "pinia": "^2.1.6",
+    "superagent": "^8.1.2",
+    "vue": "^3.3.4",
+    "vue-json-viewer": "^3.0.4",
+    "vue-router": "^4.2.4",
+    "vuex": "^4.1.0",
+    "@babel/plugin-transform-runtime": "^7.1.0",
+    "@babel/preset-env": "^7.4.5",
+    "babel-loader": "^8.0.4",
+    "clean-webpack-plugin": "^0.1.19",
+    "consoler": "^0.2.0",
+    "cross-env": "^10.1.0",
+    "css-loader": "^0.23.1",
+    "css-minimizer-webpack-plugin": "^5.0.1",
+    "directory-named-webpack-plugin": "^4.0.1",
+    "express": "^4.18.2",
+    "file-loader": "^6.2.0",
+    "html-webpack-inject-attributes-plugin": "^1.0.1",
+    "html-webpack-plugin": "^5.5.3",
+    "less-loader": "^11.1.3",
+    "mini-css-extract-plugin": "^2.7.6",
+    "style-loader": "^0.14.1",
+    "terser-webpack-plugin": "^5.3.16",
+    "thread-loader": "^4.0.4",
+    "url-loader": "^4.1.1",
+    "vue-loader": "^17.2.2",
+    "vue-style-loader": "^4.1.2",
+    "webpack": "^5.88.1",
+    "webpack-dev-middleware": "^6.1.1",
+    "webpack-hot-middleware": "^2.25.4",
+    "webpack-merge": "^4.2.1"
+  },
+  "devDependencies": {
+    "assert": "^2.0.0",
+    "babel-eslint": "^10.0.2",
+    "eslint": "^7.32.0",
+    "eslint-plugin-import": "^2.28.1",
+    "eslint-plugin-vue": "^9.17.0",
+    "ghooks": "~1.0.3",
+    "mocha": "^6.1.4",
+    "supertest": "^4.0.2",
+    "validate-commit-msg": "~2.14.0"
+  },
+  "config": {
+    "ghooks": {
+      "commit-msg": "validate-commit-msg",
+      "pre-commit": "npm run lint"
+    }
+  }
+}

package/test/controller/project.test.js

@@ -0,0 +1,214 @@
+// 断言库
+const assert = require("assert");
+// 单元测试 模拟请求测试的服务
+const supertest = require("supertest");
+const md5 = require("md5");
+const elpisCore = require("../../elpis-core/index");
+
+const signKey = "bgkjibal2kbhkc4vbakjl3sdvhja";
+const st = Date.now();
+
+describe("测试 project 相关接口", function () {
+  this.timeout(60000);
+
+  let modelList;
+  const projectList = [];
+  let request;
+  it("启动服务", async () => {
+    const app = await elpisCore.start();
+
+    // 进行对比的数据
+    modelList = require("../../model/index")(app);
+    modelList.forEach((modelItem) => {
+      const { project } = modelItem;
+      for (const projKey in project) {
+        // 将pdd，taobao这种添加到projectList
+        projectList.push(project[projKey]);
+      }
+    });
+
+    request = supertest(app.listen());
+  });
+
+  // 测试 /api/project 接口
+  it("GET /api/project without proj_key", async () => {
+    let tmpRequest = request.get("/api/project");
+    tmpRequest = tmpRequest.set("s_sign", md5(`${signKey}_${st}`));
+    tmpRequest = tmpRequest.set("s_t", st);
+    const res = await tmpRequest;
+    assert(res.body.success === false);
+
+    const resBody = res.body;
+    assert(resBody.code === 442);
+    assert(resBody.message.indexOf("request validate fail") > -1);
+  });
+
+  it("GET /api/project fail", async () => {
+    let tmpRequest = request.get("/api/project");
+    tmpRequest = tmpRequest.set("s_sign", md5(`${signKey}_${st}`));
+    tmpRequest = tmpRequest.set("s_t", st);
+    tmpRequest = tmpRequest.query({
+      proj_key: "xxxxxxxxxxxxxxx",
+    });
+    const res = await tmpRequest;
+    console.log(res.body);
+    assert(res.body.success === false);
+    const resBody = res.body;
+    assert(resBody.code === 50000);
+    assert(resBody.message.indexOf("项目异常") > -1);
+  });
+  it("GET /api/project with proj_key", async () => {
+    // 校验 menu 菜单
+    const checkMenuItem = (menuItem) => {
+      console.log(`--------- GET /api/project with proj_key - menuKey: ${projKey}`);
+      assert(menuItem.key);
+      assert(menuItem.name);
+      assert(menuItem.menuType);
+
+      if (menuItem.menuType === "group") {
+        assert(menuItem.subMenu !== undefined);
+        menuItem.subMenu.forEach((subMenuItem) => {
+          // 递归调用 subMenu 里面的每一项 都是使用 checkMenuItem 方法
+          checkMenuItem(subMenuItem);
+        });
+      } else if (menuItem.menuType === "module") {
+        checkModule(menuItem);
+      }
+    };
+
+    // 校验 module 菜单配置
+    const checkModule = (menuItem) => {
+      const { moduleType } = menuItem;
+      assert(moduleType);
+      if (moduleType === "sider") {
+        const { siderConfig } = menuItem;
+        assert(siderConfig);
+        assert(siderConfig.menu);
+        siderConfig.menu.forEach((siderMenuItem) => {
+          // 递归调用 menu 里面的每一项 都是使用 checkMenuItem 方法
+          checkMenuItem(siderMenuItem);
+        });
+      }
+      if (moduleType === "iframe") {
+        const { iframeConfig } = menuItem;
+        assert(iframeConfig);
+        assert(iframeConfig.path !== undefined);
+      }
+      if (moduleType === "custom") {
+        const { customConfig } = menuItem;
+        assert(customConfig);
+        assert(customConfig.path !== undefined);
+      }
+      if (moduleType === "schema") {
+        const { schemaConfig } = menuItem;
+        assert(schemaConfig);
+        assert(schemaConfig.api !== undefined);
+        assert(schemaConfig.schema);
+      }
+    };
+    // 循环获取 projKey 验证每一个
+    for (let i = 0; i < projectList.length; i++) {
+      const { key: projKey } = projectList[i];
+      console.log(`GET /api/project with proj_key: ${projKey}`);
+      let tmpRequest = request.get("/api/project");
+      tmpRequest = tmpRequest.set("s_sign", md5(`${signKey}_${st}`));
+      tmpRequest = tmpRequest.set("s_t", st);
+      tmpRequest = tmpRequest.query({
+        proj_key: projKey,
+      });
+      const res = await tmpRequest;
+      assert(res.body.success === true);
+
+      const resData = res.body.data;
+      assert(resData.key === projKey);
+      assert(resData.name);
+      assert(resData.modelKey);
+      assert(resData.desc !== undefined);
+      assert(resData.homePage !== undefined);
+
+      const { menu } = resData;
+      menu.forEach((menuItem) => {
+        checkMenuItem(menuItem);
+      });
+    }
+  });
+
+  // 测试 /api/project/list 接口
+  it("GET /api/project/list without proj_key", async () => {
+    let tmpRequest = request.get("/api/project/list");
+    tmpRequest = tmpRequest.set("s_sign", md5(`${signKey}_${st}`));
+    tmpRequest = tmpRequest.set("s_t", st);
+    const res = await tmpRequest;
+    // 针对数据进行断言
+    assert(res.body.success === true);
+
+    const resData = res.body.data;
+    assert(resData.length === projectList.length);
+    for (let i = 0; i < resData.length; i++) {
+      const item = resData[i];
+      assert(item.key);
+      assert(item.name);
+      assert(item.desc !== undefined);
+      assert(item.modelKey);
+      assert(item.homePage !== undefined);
+    }
+  });
+
+  it("GET /api/project/list with proj_key", async () => {
+    // 取出project对象中的每一个对象中的唯一的key属性
+    const { key: projKey } =
+      projectList[Math.floor(Math.random() * projectList.length)];
+    // 查找当前的 projKey 所属已存在的那一个里面
+    const { modelKey } = projectList.find((item) => item.key === projKey);
+    let tmpRequest = request.get("/api/project/list");
+    tmpRequest = tmpRequest.set("s_sign", md5(`${signKey}_${st}`));
+    tmpRequest = tmpRequest.set("s_t", st);
+    // 携带请求参数
+    tmpRequest = tmpRequest.query({
+      proj_key: projKey,
+    });
+    const res = await tmpRequest;
+    assert(res.body.success === true);
+
+    const resData = res.body.data;
+    assert(
+      projectList.filter(
+        (item) => (item.modelKey === modelKey.length) === resData.length,
+      ),
+    );
+    for (let i = 0; i < resData.length; i++) {
+      const item = resData[i];
+      assert(item.key);
+      assert(item.name);
+      assert(item.desc !== undefined);
+      assert(item.modelKey);
+      assert(item.homePage !== undefined);
+    }
+  });
+
+  // 测试 /api/project/model_list 接口
+  it("GET /api/project/model_list", async () => {
+    let tmpRequest = request.get("/api/project/model_list");
+    tmpRequest = tmpRequest.set("s_sign", md5(`${signKey}_${st}`));
+    tmpRequest = tmpRequest.set("s_t", st);
+    const res = await tmpRequest;
+
+    // 针对数据进行断言
+    assert(res.body.success === true);
+
+    const resData = res.body.data;
+    assert(resData.length > 0);
+
+    for (let i = 0; i < resData.length; i++) {
+      const item = resData[i];
+      assert(item.model);
+      assert(item.model.key);
+      assert(item.model.name);
+      assert(item.project);
+      for (const projKey in item.project) {
+        assert(item.project[projKey].key);
+        assert(item.project[projKey].name);
+      }
+    }
+  });
+});