.autod.conf.js

@@ -0,0 +1,29 @@
+'use strict';
+
+module.exports = {
+  write: true,
+  prefix: '^',
+  plugin: 'autod-egg',
+  test: [
+    'test',
+    'benchmark',
+  ],
+  dep: [
+    'egg',
+    'egg-scripts',
+  ],
+  devdep: [
+    'egg-ci',
+    'egg-bin',
+    'egg-mock',
+    'autod',
+    'autod-egg',
+    'eslint',
+    'eslint-config-egg',
+  ],
+  exclude: [
+    './test/fixtures',
+    './dist',
+  ],
+};
+

.eslintignore

@@ -0,0 +1 @@
+coverage

.eslintrc

@@ -0,0 +1,3 @@
+{
+  "extends": "eslint-config-egg"
+}

.github/workflows/nodejs.yml

@@ -0,0 +1,42 @@
+# This workflow will do a clean install of node dependencies, build the source code and run tests across different versions of node
+# For more information see: https://help.github.com/actions/language-and-framework-guides/using-nodejs-with-github-actions
+
+name: Node.js CI
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+  schedule:
+    - cron: '0 2 * * *'
+
+jobs:
+  build:
+    runs-on: ${{ matrix.os }}
+
+    strategy:
+      fail-fast: false
+      matrix:
+        node-version: [10]
+        os: [ubuntu-latest, windows-latest, macos-latest]
+
+    steps:
+    - name: Checkout Git Source
+      uses: actions/checkout@v2
+
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v1
+      with:
+        node-version: ${{ matrix.node-version }}
+
+    - name: Install Dependencies
+      run: npm i -g npminstall && npminstall
+
+    - name: Continuous Integration
+      run: npm run ci
+
+    - name: Code Coverage
+      uses: codecov/codecov-action@v1
+      with:
+        token: ${{ secrets.CODECOV_TOKEN }}

.gitignore

@@ -0,0 +1,14 @@
+logs/
+npm-debug.log
+yarn-error.log
+node_modules/
+package-lock.json
+yarn.lock
+coverage/
+.idea/
+run/
+.DS_Store
+*.sw*
+*.un~
+typings/
+.nyc_output/

.travis.yml

@@ -0,0 +1,12 @@
+
+language: node_js
+node_js:
+  - '10'
+before_install:
+  - npm i npminstall -g
+install:
+  - npminstall
+script:
+  - npm run ci
+after_script:
+  - npminstall codecov && codecov

app/controller/adminUser.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const Controller = require('egg').Controller;
+
+class AdminUserController extends Controller {
+  async create() {
+    const { ctx } = this;
+    const res = await ctx.service.adminUser.create(ctx.request.body);
+    ctx.body = res;
+  }
+  async update() {
+    const { ctx } = this;
+    const res = await ctx.service.adminUser.update(ctx.request.body);
+    ctx.body = res;
+  }
+  async del() {
+    const { ctx } = this;
+    const res = await ctx.service.adminUser.del(ctx.params);
+    ctx.body = res;
+  }
+  async query() {
+    const { ctx } = this;
+    const res = await ctx.service.adminUser.query(ctx.query);
+    ctx.body = res;
+  }
+  async pwdUpdate() {
+    const { ctx } = this;
+    const res = await ctx.service.adminUser.pwdUpdate(ctx.request.body);
+    ctx.body = res;
+  }
+}
+
+module.exports = AdminUserController;

app/controller/banner.js

@@ -0,0 +1,28 @@
+'use strict';
+
+const Controller = require('egg').Controller;
+
+class BannerController extends Controller {
+  async create() {
+    const { ctx } = this;
+    const res = await ctx.service.banner.create(ctx.request.body);
+    ctx.body = res;
+  }
+  async update() {
+    const { ctx } = this;
+    const res = await ctx.service.banner.update(ctx.request.body);
+    ctx.body = res;
+  }
+  async del() {
+    const { ctx } = this;
+    const res = await ctx.service.banner.del(ctx.params);
+    ctx.body = res;
+  }
+  async query() {
+    const { ctx } = this;
+    const res = await ctx.service.banner.query(ctx.query);
+    ctx.body = res;
+  }
+}
+
+module.exports = BannerController;

app/controller/column.js

@@ -0,0 +1,28 @@
+'use strict';
+
+const Controller = require('egg').Controller;
+
+class ColumnController extends Controller {
+  async create() {
+    const { ctx } = this;
+    const res = await ctx.service.contentType.create(ctx.request.body);
+    ctx.body = res;
+  }
+  async update() {
+    const { ctx } = this;
+    const res = await ctx.service.contentType.update(ctx.request.body);
+    ctx.body = res;
+  }
+  async del() {
+    const { ctx } = this;
+    const res = await ctx.service.contentType.del(ctx.params);
+    ctx.body = res;
+  }
+  async query() {
+    const { ctx } = this;
+    const res = await ctx.service.contentType.query(ctx.query);
+    ctx.body = res;
+  }
+}
+
+module.exports = ColumnController;

app/controller/configuration.js

@@ -0,0 +1,23 @@
+'use strict';
+
+const Controller = require('egg').Controller;
+
+class ConfigurationController extends Controller {
+  async create() {
+    const { ctx } = this;
+    const res = await ctx.service.contentType.create(ctx.request.body);
+    ctx.body = res;
+  }
+  async update() {
+    const { ctx } = this;
+    const res = await ctx.service.contentType.update(ctx.request.body);
+    ctx.body = res;
+  }
+  async query() {
+    const { ctx } = this;
+    const res = await ctx.service.contentType.query(ctx.query);
+    ctx.body = res;
+  }
+}
+
+module.exports = ConfigurationController;

app/controller/content.js

@@ -0,0 +1,28 @@
+'use strict';
+
+const Controller = require('egg').Controller;
+
+class ContentController extends Controller {
+  async create() {
+    const { ctx } = this;
+    const res = await ctx.service.content.create(ctx.request.body);
+    ctx.body = res;
+  }
+  async update() {
+    const { ctx } = this;
+    const res = await ctx.service.content.update(ctx.request.body);
+    ctx.body = res;
+  }
+  async del() {
+    const { ctx } = this;
+    const res = await ctx.service.content.del(ctx.params);
+    ctx.body = res;
+  }
+  async query() {
+    const { ctx } = this;
+    const res = await ctx.service.content.query(ctx.query);
+    ctx.body = res;
+  }
+}
+
+module.exports = ContentController;

app/controller/files.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const Controller = require('egg').Controller;
+
+class FilesController extends Controller {
+  async create() {
+    const { ctx } = this;
+    const res = await ctx.service.files.create(ctx.request.body);
+    ctx.body = res;
+  }
+  async update() {
+    const { ctx } = this;
+    const res = await ctx.service.files.update(ctx.request.body);
+    ctx.body = res;
+  }
+  async del() {
+    const { ctx } = this;
+    const res = await ctx.service.files.del(ctx.params);
+    ctx.body = res;
+  }
+  async query() {
+    const { ctx } = this;
+    const res = await ctx.service.files.query(ctx.query);
+    ctx.body = res;
+  }
+  async upload() {
+    const { ctx } = this;
+    const res = await ctx.service.files.query(this.ctx.request.body);
+    ctx.body = res;
+  }
+}
+
+module.exports = FilesController;

app/controller/links.js

@@ -0,0 +1,28 @@
+'use strict';
+
+const Controller = require('egg').Controller;
+
+class LinksController extends Controller {
+  async create() {
+    const { ctx } = this;
+    const res = await ctx.service.links.create(ctx.request.body);
+    ctx.body = res;
+  }
+  async update() {
+    const { ctx } = this;
+    const res = await ctx.service.links.update(ctx.request.body);
+    ctx.body = res;
+  }
+  async del() {
+    const { ctx } = this;
+    const res = await ctx.service.links.del(ctx.params);
+    ctx.body = res;
+  }
+  async query() {
+    const { ctx } = this;
+    const res = await ctx.service.links.query(ctx.query);
+    ctx.body = res;
+  }
+}
+
+module.exports = LinksController;

app/controller/menu.js

@@ -0,0 +1,28 @@
+'use strict';
+
+const Controller = require('egg').Controller;
+
+class MenuController extends Controller {
+  async create() {
+    const { ctx } = this;
+    const res = await ctx.service.menu.create(ctx.request.body);
+    ctx.body = res;
+  }
+  async update() {
+    const { ctx } = this;
+    const res = await ctx.service.menu.update(ctx.request.body);
+    ctx.body = res;
+  }
+  async del() {
+    const { ctx } = this;
+    const res = await ctx.service.menu.del(ctx.params);
+    ctx.body = res;
+  }
+  async query() {
+    const { ctx } = this;
+    const res = await ctx.service.menu.query();
+    ctx.body = res;
+  }
+}
+
+module.exports = MenuController;

app/controller/page.js

@@ -0,0 +1,28 @@
+'use strict';
+
+const Controller = require('egg').Controller;
+
+class PageController extends Controller {
+  async create() {
+    const { ctx } = this;
+    const res = await ctx.service.page.create(ctx.request.body);
+    ctx.body = res;
+  }
+  async update() {
+    const { ctx } = this;
+    const res = await ctx.service.page.update(ctx.request.body);
+    ctx.body = res;
+  }
+  async del() {
+    const { ctx } = this;
+    const res = await ctx.service.page.del(ctx.params);
+    ctx.body = res;
+  }
+  async query() {
+    const { ctx } = this;
+    const res = await ctx.service.page.query(ctx.query);
+    ctx.body = res;
+  }
+}
+
+module.exports = PageController;

app/controller/power.js

@@ -0,0 +1,13 @@
+'use strict';
+
+const Controller = require('egg').Controller;
+
+class LoginController extends Controller {
+  async login() {
+    const { ctx } = this;
+    const res = await ctx.service.power.login(ctx.request.body);
+    ctx.body = res;
+  }
+}
+
+module.exports = LoginController;

app/controller/resource.js

@@ -0,0 +1,28 @@
+'use strict';
+
+const Controller = require('egg').Controller;
+
+class ResourceController extends Controller {
+  async create() {
+    const { ctx } = this;
+    const res = await ctx.service.resource.create(ctx.request.body);
+    ctx.body = res;
+  }
+  async update() {
+    const { ctx } = this;
+    const res = await ctx.service.resource.update(ctx.request.body);
+    ctx.body = res;
+  }
+  async del() {
+    const { ctx } = this;
+    const res = await ctx.service.resource.del(ctx.params);
+    ctx.body = res;
+  }
+  async query() {
+    const { ctx } = this;
+    const res = await ctx.service.resource.query(ctx.query);
+    ctx.body = res;
+  }
+}
+
+module.exports = ResourceController;

app/controller/role.js

@@ -0,0 +1,28 @@
+'use strict';
+
+const Controller = require('egg').Controller;
+
+class RoleController extends Controller {
+  async create() {
+    const { ctx } = this;
+    const res = await ctx.service.role.create(ctx.request.body);
+    ctx.body = res;
+  }
+  async update() {
+    const { ctx } = this;
+    const res = await ctx.service.role.update(ctx.request.body);
+    ctx.body = res;
+  }
+  async del() {
+    const { ctx } = this;
+    const res = await ctx.service.role.del(ctx.params);
+    ctx.body = res;
+  }
+  async query() {
+    const { ctx } = this;
+    const res = await ctx.service.role.query(ctx.query);
+    ctx.body = res;
+  }
+}
+
+module.exports = RoleController;

app/middleware/error_handler.js

@@ -0,0 +1,15 @@
+'use strict';
+module.exports = () => {
+  return async function errorHandler(ctx, next) {
+    try {
+      await next();
+    } catch (err) {
+      console.log(err);
+      console.log(err.code);
+      // const { message } = err;
+      // const json = JSON.parse(message);
+      // ctx.body = json;
+      ctx.status = 400;
+    }
+  };
+};

app/middleware/jwt.js

@@ -0,0 +1,29 @@
+'use strict';
+module.exports = options => {
+  return async function jwt(ctx, next) {
+    const token = ctx.request.header.authorization;
+    let decode;
+    if (token) {
+      try {
+        // 解码token
+        decode = ctx.app.jwt.verify(token, options.secret);
+        await next();
+        return decode;
+      } catch (error) {
+        ctx.status = 401;
+        ctx.body = {
+          errmsg: error.message,
+          errcode: -1001,
+        };
+        return;
+      }
+    } else {
+      ctx.status = 401;
+      ctx.body = {
+        errmsg: '身份过期,重新登录',
+        errcode: -1002,
+      };
+      return;
+    }
+  };
+};

app/model/AdminUser.js

@@ -0,0 +1,44 @@
+'use strict';
+module.exports = app => {
+  const { mongoose } = app;
+  const { Schema } = mongoose;
+  const AdminUserSchema = new Schema({
+    // 帐号
+    acct: {
+      type: String,
+    },
+    // 密码（加密存储）
+    password: {
+      type: String,
+    },
+    // 用户名
+    userName: {
+      type: String,
+    },
+    // 创建时间
+    createAt: {
+      type: String,
+    },
+    // 手机号
+    phone: {
+      type: Number,
+    },
+    // 用户角色绑定组
+    roleList: {
+      type: Array,
+    },
+    // 用户栏目绑定组
+    columnList: {
+      type: Array,
+    },
+    // 用户状态
+    state: {
+      type: Number,
+    },
+    // 用户id
+    id: {
+      type: String,
+    },
+  });
+  return mongoose.model('AdminUser', AdminUserSchema);
+};

app/model/Banner.js

@@ -0,0 +1,40 @@
+'use strict';
+module.exports = app => {
+  const { mongoose } = app;
+  const { Schema } = mongoose;
+  const BannerSchema = new Schema({
+    // 标题
+    title: {
+      type: String,
+    },
+    // 短标题
+    shortTitle: {
+      type: String,
+    },
+    // 摘要
+    slug: {
+      type: String,
+    },
+    // banner地址
+    path: {
+      tyoe: String,
+    },
+    // 附件
+    annex: {
+      type: String,
+    },
+    // 内容
+    content: {
+      type: Array,
+    },
+    // 创建时间
+    createAt: {
+      type: String,
+    },
+    // 数据id
+    id: {
+      type: String,
+    },
+  });
+  return mongoose.model('Banner', BannerSchema);
+};

app/model/Column.js

@@ -0,0 +1,23 @@
+'use strict';
+module.exports = app => {
+  const { mongoose } = app;
+  const { Schema } = mongoose;
+  const ColumnSchema = new Schema({
+    name: {
+      type: String,
+    },
+    code: {
+      type: String,
+    },
+    id: {
+      type: String,
+    },
+    menuList: {
+      type: Array,
+    },
+    createAt: {
+      type: String,
+    },
+  });
+  return mongoose.model('Column', ColumnSchema);
+};

app/model/Configuration.js

@@ -0,0 +1,40 @@
+'use strict';
+module.exports = app => {
+  const { mongoose } = app;
+  const { Schema } = mongoose;
+  const ConfigurationSchema = new Schema({
+    // 名称
+    name: {
+      type: String,
+    },
+    // 描述
+    describe: {
+      type: String,
+    },
+    // 单位
+    company: {
+      type: String,
+    },
+    // 电话
+    phone: {
+      type: String,
+    },
+    // 地址
+    address: {
+      type: String,
+    },
+    // 邮箱
+    mail: {
+      type: String,
+    },
+    // 邮编
+    postcode: {
+      type: String,
+    },
+    // 备案号
+    record: {
+      type: String,
+    },
+  });
+  return mongoose.model('Configuration', ConfigurationSchema);
+};

app/model/Content.js

@@ -0,0 +1,48 @@
+'use strict';
+module.exports = app => {
+  const { mongoose } = app;
+  const { Schema } = mongoose;
+  const ContentSchema = new Schema({
+    // 标题
+    title: {
+      type: String,
+    },
+    // 短标题
+    shortTitle: {
+      type: String,
+    },
+    // 摘要
+    slug: {
+      type: String,
+    },
+    // 缩略图
+    thumbnail: {
+      tyoe: String,
+    },
+    // 附件
+    annex: {
+      type: String,
+    },
+    // 内容
+    content: {
+      type: Array,
+    },
+    // 创建时间
+    createAt: {
+      type: String,
+    },
+    // 置顶
+    istop: {
+      type: Number,
+    },
+    // 数据id
+    id: {
+      type: String,
+    },
+    // 绑定栏目组
+    columnList: {
+      type: Array,
+    },
+  });
+  return mongoose.model('Content', ContentSchema);
+};

app/model/Files.js

@@ -0,0 +1,20 @@
+'use strict';
+module.exports = app => {
+  const { mongoose } = app;
+  const { Schema } = mongoose;
+  const FilesSchema = new Schema({
+    // 文件名
+    name: {
+      type: String,
+    },
+    // 文件路径
+    path: {
+      type: String,
+    },
+    // 数据id
+    id: {
+      type: String,
+    },
+  });
+  return mongoose.model('Files', FilesSchema);
+};

app/model/Links.js

@@ -0,0 +1,24 @@
+'use strict';
+module.exports = app => {
+  const { mongoose } = app;
+  const { Schema } = mongoose;
+  const LinksSchema = new Schema({
+    // 名称
+    name: {
+      type: String,
+    },
+    // 图片地址
+    path: {
+      type: String,
+    },
+    // id
+    id: {
+      type: String,
+    },
+    // 访问地址
+    links: {
+      type: String,
+    },
+  });
+  return mongoose.model('Links', LinksSchema);
+};

app/model/Menu.js

@@ -0,0 +1,29 @@
+'use strict';
+module.exports = app => {
+  const { mongoose } = app;
+  const { Schema } = mongoose;
+  const MenuSchema = new Schema({
+    name: {
+      type: String,
+    },
+    code: {
+      type: String,
+    },
+    id: {
+      type: String,
+    },
+    state: {
+      type: Number,
+    },
+    type: {
+      type: Number,
+    },
+    uri: {
+      type: String,
+    },
+    pid: {
+      type: String,
+    },
+  });
+  return mongoose.model('Menu', MenuSchema);
+};

app/model/Page.js

@@ -0,0 +1,44 @@
+'use strict';
+module.exports = app => {
+  const { mongoose } = app;
+  const { Schema } = mongoose;
+  const PageSchema = new Schema({
+    // 标题
+    title: {
+      type: String,
+    },
+    // 短标题
+    shortTitle: {
+      type: String,
+    },
+    // 摘要
+    slug: {
+      type: String,
+    },
+    // 缩略图
+    thumbnail: {
+      tyoe: String,
+    },
+    // 附件
+    annex: {
+      type: String,
+    },
+    // 内容
+    content: {
+      type: Array,
+    },
+    // 创建时间
+    createAt: {
+      type: String,
+    },
+    // 数据id
+    id: {
+      type: String,
+    },
+    // 绑定菜单
+    menu: {
+      type: String,
+    },
+  });
+  return mongoose.model('Page', PageSchema);
+};

app/model/Resource.js

@@ -0,0 +1,20 @@
+'use strict';
+module.exports = app => {
+  const { mongoose } = app;
+  const { Schema } = mongoose;
+  const ResourceSchema = new Schema({
+    // 文件名
+    name: {
+      type: String,
+    },
+    // 文件路径
+    path: {
+      type: String,
+    },
+    // 数据id
+    id: {
+      type: String,
+    },
+  });
+  return mongoose.model('Resource', ResourceSchema);
+};

app/model/Role.js

@@ -0,0 +1,28 @@
+'use strict';
+module.exports = app => {
+  const { mongoose } = app;
+  const { Schema } = mongoose;
+  const RoleSchema = new Schema({
+    // 角色名
+    name: {
+      type: String,
+    },
+    // 角色编码
+    code: {
+      type: String,
+    },
+    // 角色id
+    id: {
+      type: String,
+    },
+    // 角色状态
+    state: {
+      type: Number,
+    },
+    // 角色绑定系统菜单组
+    adminMenuList: {
+      type: Array,
+    },
+  });
+  return mongoose.model('Role', RoleSchema);
+};

app/router.js

@@ -0,0 +1,36 @@
+'use strict';
+
+/**
+ * @param {Egg.Application} app - egg application
+ */
+module.exports = app => {
+  const { router, controller } = app;
+  const jwt = app.middleware.jwt(app.config.jwt);
+  // 系统用户
+  router.post('/api/adminUser/create', jwt, controller.adminUser.create);
+  router.post('/api/adminUser/update', jwt, controller.adminUser.update);
+  router.delete('/api/adminUser/delete/:id', jwt, controller.adminUser.del);
+  router.get('/api/adminUser/query', jwt, controller.adminUser.query);
+  // 角色
+  router.post('/api/role/create', jwt, controller.role.create);
+  router.post('/api/role/update', jwt, controller.role.update);
+  router.delete('/api/role/delete/:id', jwt, controller.role.del);
+  router.get('/api/role/query', jwt, controller.role.query);
+  // 菜单
+  router.post('/api/menu/create', jwt, controller.menu.create);
+  router.post('/api/menu/update', jwt, controller.menu.update);
+  router.delete('/api/menu/delete/:id', jwt, controller.menu.del);
+  router.get('/api/menu/query', jwt, controller.menu.query);
+  // 栏目
+  router.post('/api/column/create', controller.column.create);
+  router.post('/api/column/update', controller.column.update);
+  router.delete('/api/column/delete/:id', jwt, controller.column.del);
+  router.get('/api/column/query', jwt, controller.column.query);
+  // 登录
+  router.post('/api/power/login', controller.power.login);
+  // 内容
+  router.post('/api/content/create', jwt, controller.content.create);
+  router.post('/api/content/update', jwt, controller.content.update);
+  router.delete('/api/content/delete/:id', jwt, controller.content.del);
+  router.get('/api/content/query', jwt, controller.content.query);
+};

app/service/adminUser.js

@@ -0,0 +1,79 @@
+'use strict';
+
+const Service = require('egg').Service;
+const assert = require('assert');
+const moment = require('moment');
+const crypto = require('crypto');
+class adminUserService extends Service {
+  async create({ acct, password, userName, phone, state, roleList, columnList }) {
+    assert(acct, '帐号不存在');
+    assert(password, '密码不存在');
+    assert(userName, '用户名不存在');
+    assert(phone, '手机号不存在');
+    assert(state, '状态不存在');
+    const { AdminUser: model } = this.ctx.model;
+    const createAt = moment().format('x');
+    const hash = crypto.createHmac('sha256', this.app.config.userSecret);
+    const pwa = hash.update(password).digest('hex');
+    try {
+      const res = await model.create({ acct, password: pwa, userName, phone, createAt, state, roleList, columnList });
+      return { errmsg: '', errcode: 0, res };
+    } catch (error) {
+      throw new Error({ errcode: -2001, errmsg: '添加失败' });
+    }
+  }
+  async update({ userName, phone, id, roleList, state, columnList }) {
+    assert(id, 'id不存在');
+    const { AdminUser: model } = this.ctx.model;
+    try {
+      await model.findByIdAndUpdate(id, { userName, phone, roleList, state, columnList });
+      return { errmsg: '', errcode: 0 };
+    } catch (error) {
+      throw new Error({ errcode: -2001, errmsg: '修改失败' });
+    }
+  }
+  async pwdUpdate({ password, id, confirmPwd }) {
+    assert(id, 'id不存在');
+    const { AdminUser: model } = this.ctx.model;
+    const hash = crypto.createHmac('sha256', this.app.config.userSecret);
+    const cpwd = hash.update(confirmPwd).digest('hex');
+    try {
+      const res = await model.findById(id);
+      if (res.password !== cpwd) {
+        return { errmsg: '原密码错误', errcode: -2003 };
+      }
+      const hash = crypto.createHmac('sha256', this.app.config.userSecret);
+      const pwd = hash.update(password).digest('hex');
+      await model.findByIdAndUpdate(id, { password: pwd });
+      return { errmsg: '', errcode: 0 };
+    } catch (error) {
+      throw new Error({ errcode: -2001, errmsg: '修改失败' });
+    }
+  }
+  async del({ id }) {
+    assert(id, 'id不存在');
+    const { AdminUser: model } = this.ctx.model;
+    try {
+      await model.findOneAndDelete(id);
+      return { errmsg: '', errcode: 0 };
+    } catch (error) {
+      throw new Error({ errcode: -2001, errmsg: '删除失败' });
+    }
+  }
+  async query({ skip, limit, filter }) {
+    const { AdminUser: model } = this.ctx.model;
+    try {
+      let res;
+      if (skip && limit) {
+        res = await model.find({ ...filter, password: false }).skip(skip * limit).limit(limit);
+      } else {
+        res = await model.find(filter);
+      }
+      return { errmsg: '', errcode: 0, data: res };
+    } catch (error) {
+      throw new Error({ errcode: -2001, errmsg: '查询失败' });
+    }
+  }
+}
+
+module.exports = adminUserService;

app/service/bannner.js

@@ -0,0 +1,69 @@
+'use strict';
+
+const Service = require('egg').Service;
+const assert = require('assert');
+const moment = require('moment');
+class ContentService extends Service {
+  async create({ title, shortTitle, slug, path, annex, content, istop, columnList }) {
+    assert(title, '标题不存在');
+    assert(shortTitle, '短标题不存在');
+    assert(slug, '摘要不存在');
+    assert(path, '缩略图不存在');
+    assert(istop, '置顶不存在');
+    assert(content, '内容不存在');
+    const { Content: model } = this.ctx.model;
+    const createAt = moment().format('x');
+    try {
+      await model.create({ title, shortTitle, slug, path, annex, content, istop, columnList, createAt });
+      return { errmsg: '', errcode: 0 };
+    } catch (error) {
+      throw new Error({ errcode: -2001, errmsg: '添加失败' });
+    }
+  }
+  async update({ title, shortTitle, slug, path, annex, content, istop, columnList, id }) {
+    assert(id, 'id不存在');
+    const { Content: model } = this.ctx.model;
+    try {
+      await model.findByIdAndUpdate(id, { title, shortTitle, slug, path, annex, content, istop, columnList });
+      return { errmsg: '', errcode: 0 };
+    } catch (error) {
+      throw new Error({ errcode: -2001, errmsg: '修改失败' });
+    }
+  }
+  async del({ id }) {
+    assert(id, 'id不存在');
+    const { Content: model } = this.ctx.model;
+    try {
+      await model.findByIdAndDelete(id);
+      return { errmsg: '', errcode: 0 };
+    } catch (error) {
+      throw new Error({ errcode: -2001, errmsg: '删除失败' });
+    }
+  }
+  async details({ id }) {
+    assert(id, 'id不存在');
+    const { Content: model } = this.ctx.model;
+    try {
+      const res = await model.findById(id);
+      return { errmsg: '', errcode: 0, data: res };
+    } catch (error) {
+      throw new Error({ errcode: -2001, errmsg: '删除失败' });
+    }
+  }
+  async query({ skip, limit }) {
+    const { Content: model } = this.ctx.model;
+    try {
+      let res;
+      if (skip && limit) {
+        res = await model.find({ content: false }).skip(skip * limit).limit(limit);
+      } else {
+        res = await model.find({ content: false });
+      }
+      return { errmsg: '', errcode: 0, data: res };
+    } catch (error) {
+      throw new Error({ errcode: -2001, errmsg: '查询失败' });
+    }
+  }
+}
+
+module.exports = ContentService;

app/service/column.js

@@ -0,0 +1,83 @@
+'use strict';
+
+const Service = require('egg').Service;
+const assert = require('assert');
+const moment = require('moment');
+// const _ = require('lodash');
+class ColumnService extends Service {
+  async create({ name, code, menuList }) {
+    assert(name, '名称不存在');
+    assert(code, '编码不存在');
+    const { Column: model } = this.ctx.model;
+    const createAt = moment().format('x');
+    try {
+      await model.create({ name, code, menuList, createAt });
+      return { errmsg: '', errcode: 0 };
+    } catch (error) {
+      throw new Error({ errcode: -2001, errmsg: '添加失败' });
+    }
+  }
+  async update({ name, code, id, menuList }) {
+    assert(id, 'id不存在');
+    const { Column: model } = this.ctx.model;
+    try {
+      await model.findByIdAndUpdate(id, { name, code, menuList });
+      return { errmsg: '', errcode: 0 };
+    } catch (error) {
+      throw new Error({ errcode: -2001, errmsg: '修改失败' });
+    }
+  }
+  async del({ id }) {
+    assert(id, 'id不存在');
+    const { Column: model } = this.ctx.model;
+    const { Content: Contentmodel } = this.ctx.model;
+    try {
+      // 当前数据
+      const res = await model.findById(id);
+      // 复杂查询文章数据
+      const contentList = await Contentmodel.where('columnList').in(res.code);
+      contentList.filter(async p => {
+        const columnList = p.columnList.filter(e => e !== res.code);
+        await Contentmodel.findByIdAndUpdate(p._id, { columnList });
+      });
+      await model.findByIdAndDelete(id);
+      return { errmsg: '', errcode: 0 };
+    } catch (error) {
+      throw new Error({ errcode: -2001, errmsg: '删除失败' });
+    }
+  }
+  // async query() {
+  //   const { Column: model } = this.ctx.model;
+  //   const { adminUser: usermodel } = this.ctx.model;
+  //   const jwt = this.app.middleware.jwt(this.app.config.jwt);
+
+  //   try {
+  //     const userInfo = await usermodel.findById(jwt.userId);
+  //     const menus = [];
+  //     userInfo.roleList.forEach(async e => {
+  //       const res = await model.where('roleLise').in(e);
+  //       menus.push(...res);
+  //     });
+  //     const list = _.uniqWith(menus, _.isEqual);
+  //     return { errmsg: '', errcode: 0, data: list };
+  //   } catch (error) {
+  //     throw new Error({ errcode: -2001, errmsg: '查询失败' });
+  //   }
+  // }
+  async query({ skip, limit, filter }) {
+    const { Column: model } = this.ctx.model;
+    try {
+      let res;
+      if (skip && limit) {
+        res = await model.find(filter).skip(skip * limit).limit(limit);
+      } else {
+        res = await model.find(filter);
+      }
+      return { errmsg: '', errcode: 0, data: res };
+    } catch (error) {
+      throw new Error({ errcode: -2001, errmsg: '查询失败' });
+    }
+  }
+}
+
+module.exports = ColumnService;

app/service/configuration.js

@@ -0,0 +1,38 @@
+'use strict';
+
+const Service = require('egg').Service;
+const assert = require('assert');
+const moment = require('moment');
+class ConfigurationService extends Service {
+  async create({ name, describe, company, phone, address, mail, postcode, record }) {
+    const { Configuration: model } = this.ctx.model;
+    const createAt = moment().format('x');
+    try {
+      await model.create({ name, describe, company, phone, address, mail, postcode, record, createAt });
+      return { errmsg: '', errcode: 0 };
+    } catch (error) {
+      throw new Error({ errcode: -2001, errmsg: '添加失败' });
+    }
+  }
+  async update({ name, describe, company, phone, address, mail, postcode, record, id }) {
+    assert(id, 'id不存在');
+    const { Configuration: model } = this.ctx.model;
+    try {
+      await model.findByIdAndUpdate(id, { name, describe, company, phone, address, mail, postcode, record });
+      return { errmsg: '', errcode: 0 };
+    } catch (error) {
+      throw new Error({ errcode: -2001, errmsg: '修改失败' });
+    }
+  }
+  async query() {
+    const { Configuration: model } = this.ctx.model;
+    try {
+      const res = await model.find();
+      return { errmsg: '', errcode: 0, data: res };
+    } catch (error) {
+      throw new Error({ errcode: -2001, errmsg: '查询失败' });
+    }
+  }
+}
+
+module.exports = ConfigurationService;

app/service/content.js

@@ -0,0 +1,69 @@
+'use strict';
+
+const Service = require('egg').Service;
+const assert = require('assert');
+const moment = require('moment');
+class ContentService extends Service {
+  async create({ title, shortTitle, slug, thumbnail, annex, content, istop, columnList }) {
+    assert(title, '标题不存在');
+    assert(shortTitle, '短标题不存在');
+    assert(slug, '摘要不存在');
+    assert(thumbnail, '缩略图不存在');
+    assert(istop, '置顶不存在');
+    assert(content, '内容不存在');
+    const { Content: model } = this.ctx.model;
+    const createAt = moment().format('x');
+    try {
+      await model.create({ title, shortTitle, slug, thumbnail, annex, content, istop, columnList, createAt });
+      return { errmsg: '', errcode: 0 };
+    } catch (error) {
+      throw new Error({ errcode: -2001, errmsg: '添加失败' });
+    }
+  }
+  async update({ title, shortTitle, slug, thumbnail, annex, content, istop, columnList, id }) {
+    assert(id, 'id不存在');
+    const { Content: model } = this.ctx.model;
+    try {
+      await model.findByIdAndUpdate(id, { title, shortTitle, slug, thumbnail, annex, content, istop, columnList });
+      return { errmsg: '', errcode: 0 };
+    } catch (error) {
+      throw new Error({ errcode: -2001, errmsg: '修改失败' });
+    }
+  }
+  async del({ id }) {
+    assert(id, 'id不存在');
+    const { Content: model } = this.ctx.model;
+    try {
+      await model.findByIdAndDelete(id);
+      return { errmsg: '', errcode: 0 };
+    } catch (error) {
+      throw new Error({ errcode: -2001, errmsg: '删除失败' });
+    }
+  }
+  async details({ id }) {
+    assert(id, 'id不存在');
+    const { Content: model } = this.ctx.model;
+    try {
+      const res = await model.findById(id);
+      return { errmsg: '', errcode: 0, data: res };
+    } catch (error) {
+      throw new Error({ errcode: -2001, errmsg: '删除失败' });
+    }
+  }
+  async query({ skip, limit }) {
+    const { Content: model } = this.ctx.model;
+    try {
+      let res;
+      if (skip && limit) {
+        res = await model.find({ content: false }).skip(skip * limit).limit(limit);
+      } else {
+        res = await model.find({ content: false });
+      }
+      return { errmsg: '', errcode: 0, data: res };
+    } catch (error) {
+      throw new Error({ errcode: -2001, errmsg: '查询失败' });
+    }
+  }
+}
+
+module.exports = ContentService;

app/service/files.js

@@ -0,0 +1,81 @@
+'use strict';
+
+const Service = require('egg').Service;
+const assert = require('assert');
+const moment = require('moment');
+const { v1: uuidv1 } = require('uuid');
+const fs = require('fs');
+const path = require('path');
+const fsPromises = fs.promises;
+class FilesService extends Service {
+  async create({ name, path }) {
+    assert(name, '名称不存在');
+    assert(path, '路径不存在');
+    const { Files: model } = this.ctx.model;
+    const createAt = moment().format('x');
+    try {
+      await model.create({ name, path, createAt });
+      return { errmsg: '', errcode: 0 };
+    } catch (error) {
+      throw new Error({ errcode: -2001, errmsg: '添加失败' });
+    }
+  }
+  async update({ name, path, id }) {
+    assert(id, 'id不存在');
+    const { Files: model } = this.ctx.model;
+    try {
+      await model.findByIdAndUpdate(id, { name, path });
+      return { errmsg: '', errcode: 0 };
+    } catch (error) {
+      throw new Error({ errcode: -2001, errmsg: '修改失败' });
+    }
+  }
+  async del({ id }) {
+    assert(id, 'id不存在');
+    const { Files: model } = this.ctx.model;
+    try {
+      // 获取文件路径
+      const files = await model.findById(id);
+      const filepath = `${files.path}`;
+      // 开始删除文件
+      await fsPromises.rmdir(filepath);
+      await model.findOneAndDelete(id);
+      return { errmsg: '', errcode: 0 };
+    } catch (error) {
+      throw new Error({ errcode: -2001, errmsg: '删除失败' });
+    }
+  }
+  async query({ skip, limit, filter }) {
+    const { Files: model } = this.ctx.model;
+    try {
+      let res;
+      if (skip && limit) {
+        res = await model.find(filter).skip(skip * limit).limit(limit);
+      } else {
+        res = await model.find(filter);
+      }
+      return { errmsg: '', errcode: 0, data: res };
+    } catch (error) {
+      throw new Error({ errcode: -2001, errmsg: '查询失败' });
+    }
+  }
+  async upload({ type }) {
+    try {
+      const stream = await this.ctx.getFileStream();
+      // 创建文件存储名称
+      const filename = stream.filename;
+      const index = filename.indexOf('.');
+      const fileType = filename.slice(index, filename.length);
+      const uuid = uuidv1();
+      const paths = path.join(this.app.baseDir, `/app/public/${type === 'files' ? 'files' : 'resource'}/${uuid}${fileType}`);
+      // 存储
+      const remoteFileStream = fs.createWriteStream(paths);
+      stream.pipe(remoteFileStream);
+      return { errmsg: '', errcode: 0, data: { name: filename, path: paths } };
+    } catch (error) {
+      throw new Error({ errcode: -2001, errmsg: '上传失败' });
+    }
+  }
+}
+
+module.exports = FilesService;

app/service/link.js

@@ -0,0 +1,63 @@
+'use strict';
+
+const Service = require('egg').Service;
+const assert = require('assert');
+const moment = require('moment');
+const fs = require('fs');
+const fsPromises = fs.promises;
+class LinkService extends Service {
+  async create({ name, path, links }) {
+    assert(name, '名称不存在');
+    assert(path, '路径不存在');
+    assert(links, '链接不存在');
+    const { Link: model } = this.ctx.model;
+    const createAt = moment().format('x');
+    try {
+      await model.create({ name, path, links, createAt });
+      return { errmsg: '', errcode: 0 };
+    } catch (error) {
+      throw new Error({ errcode: -2001, errmsg: '添加失败' });
+    }
+  }
+  async update({ name, path, id, links }) {
+    assert(id, 'id不存在');
+    const { Link: model } = this.ctx.model;
+    try {
+      await model.findByIdAndUpdate(id, { name, path, links });
+      return { errmsg: '', errcode: 0 };
+    } catch (error) {
+      throw new Error({ errcode: -2001, errmsg: '修改失败' });
+    }
+  }
+  async del({ id }) {
+    assert(id, 'id不存在');
+    const { Link: model } = this.ctx.model;
+    try {
+      // 获取文件路径
+      const files = await model.findById(id);
+      const filepath = `${files.path}`;
+      // 开始删除文件
+      await fsPromises.rmdir(filepath);
+      await model.findOneAndDelete(id);
+      return { errmsg: '', errcode: 0 };
+    } catch (error) {
+      throw new Error({ errcode: -2001, errmsg: '删除失败' });
+    }
+  }
+  async query({ skip, limit, filter }) {
+    const { Link: model } = this.ctx.model;
+    try {
+      let res;
+      if (skip && limit) {
+        res = await model.find(filter).skip(skip * limit).limit(limit);
+      } else {
+        res = await model.find(filter);
+      }
+      return { errmsg: '', errcode: 0, data: res };
+    } catch (error) {
+      throw new Error({ errcode: -2001, errmsg: '查询失败' });
+    }
+  }
+}
+
+module.exports = LinkService;

app/service/menu.js

@@ -0,0 +1,96 @@
+'use strict';
+
+const Service = require('egg').Service;
+const assert = require('assert');
+const moment = require('moment');
+class MenuService extends Service {
+  async create({ name, code, state, type }) {
+    assert(name, '名称不存在');
+    assert(code, '编码不存在');
+    assert(state, '状态不存在');
+    assert(type, '类型不存在');
+    const { Menu: model } = this.ctx.model;
+    const createAt = moment().format('x');
+    try {
+      await model.create({ name, code, createAt, state, type });
+      return { errmsg: '', errcode: 0 };
+    } catch (error) {
+      throw new Error({ errcode: -2001, errmsg: '添加失败' });
+    }
+  }
+  async update({ name, state, id }) {
+    assert(id, 'id不存在');
+    const { Menu: model } = this.ctx.model;
+    try {
+      await model.findByIdAndUpdate(id, { name, state });
+      return { errmsg: '', errcode: 0 };
+    } catch (error) {
+      throw new Error({ errcode: -2001, errmsg: '修改失败' });
+    }
+  }
+  async del({ id }) {
+    assert(id, 'id不存在');
+    const { Menu: model } = this.ctx.model;
+    const { Role: Rolemodel } = this.ctx.model;
+    const { Page: Pagemodel } = this.ctx.model;
+    const { Column: Columnmodel } = this.ctx.model;
+    try {
+      const menu = await model.findById(id);
+      const roleList = await Rolemodel.where('adminMenuList').in(menu.code);
+      switch (menu.type) {
+        case 0: {
+          // 栏目
+          const menuList = await Columnmodel.where('menuList').in(menu.code);
+          menuList.filter(async p => {
+            const menuList = p.menuList.filter(p => p !== menu.code);
+            await Columnmodel.findByIdAndUpdate(p._id, { menuList });
+          });
+          break;
+        }
+        case 2: {
+          // 单页
+          const pageList = await Pagemodel.find({ menu: menu.code });
+          pageList.filter(async p => {
+            await Pagemodel.findByIdAndUpdate(p._id, { menu: null });
+          });
+          break;
+        }
+        case 3: {
+          // 父级
+          const pmenu = await model.find({ pid: menu.code });
+          if (pmenu.length > 0) {
+            return { errmsg: '存在子级菜单，请先删除子级菜单', errcode: -1001 };
+          }
+          break;
+        }
+        default: {
+          break;
+        }
+      }
+      await model.findOneAndDelete(id);
+      roleList.forEach(async e => {
+        const adminMenuList = e.adminMenuList.filter(p => p !== menu.code);
+        await Rolemodel.findByIdAndUpdate(e._id, { adminMenuList });
+      });
+      return { errmsg: '', errcode: 0 };
+    } catch (error) {
+      throw new Error({ errcode: -2001, errmsg: '删除失败' });
+    }
+  }
+  async query({ skip, limit, filter }) {
+    const { Menu: model } = this.ctx.model;
+    try {
+      let res;
+      if (skip && limit) {
+        res = await model.find(filter).skip(skip * limit).limit(limit);
+      } else {
+        res = await model.find(filter);
+      }
+      return { errmsg: '', errcode: 0, data: res };
+    } catch (error) {
+      throw new Error({ errcode: -2001, errmsg: '查询失败' });
+    }
+  }
+}
+
+module.exports = MenuService;

app/service/page.js

@@ -0,0 +1,69 @@
+'use strict';
+
+const Service = require('egg').Service;
+const assert = require('assert');
+const moment = require('moment');
+class PageService extends Service {
+  async create({ title, shortTitle, slug, thumbnail, annex, content, istop, menu }) {
+    assert(title, '标题不存在');
+    assert(shortTitle, '短标题不存在');
+    assert(slug, '摘要不存在');
+    assert(thumbnail, '缩略图不存在');
+    assert(istop, '置顶不存在');
+    assert(content, '内容不存在');
+    const { Page: model } = this.ctx.model;
+    const createAt = moment().format('x');
+    try {
+      await model.create({ title, shortTitle, slug, thumbnail, annex, content, istop, menu, createAt });
+      return { errmsg: '', errcode: 0 };
+    } catch (error) {
+      throw new Error({ errcode: -2001, errmsg: '添加失败' });
+    }
+  }
+  async update({ title, shortTitle, slug, thumbnail, annex, content, istop, menu, id }) {
+    assert(id, 'id不存在');
+    const { Page: model } = this.ctx.model;
+    try {
+      await model.findByIdAndUpdate(id, { title, shortTitle, slug, thumbnail, annex, content, istop, menu });
+      return { errmsg: '', errcode: 0 };
+    } catch (error) {
+      throw new Error({ errcode: -2001, errmsg: '修改失败' });
+    }
+  }
+  async del({ id }) {
+    assert(id, 'id不存在');
+    const { Page: model } = this.ctx.model;
+    try {
+      await model.findByIdAndDelete(id);
+      return { errmsg: '', errcode: 0 };
+    } catch (error) {
+      throw new Error({ errcode: -2001, errmsg: '删除失败' });
+    }
+  }
+  async details({ id }) {
+    assert(id, 'id不存在');
+    const { Page: model } = this.ctx.model;
+    try {
+      const res = await model.findById(id);
+      return { errmsg: '', errcode: 0, data: res };
+    } catch (error) {
+      throw new Error({ errcode: -2001, errmsg: '删除失败' });
+    }
+  }
+  async query({ skip, limit }) {
+    const { Page: model } = this.ctx.model;
+    try {
+      let res;
+      if (skip && limit) {
+        res = await model.find({ content: false }).skip(skip * limit).limit(limit);
+      } else {
+        res = await model.find({ content: false });
+      }
+      return { errmsg: '', errcode: 0, data: res };
+    } catch (error) {
+      throw new Error({ errcode: -2001, errmsg: '查询失败' });
+    }
+  }
+}
+
+module.exports = PageService;

app/service/power.js

@@ -0,0 +1,29 @@
+'use strict';
+
+const Service = require('egg').Service;
+const assert = require('assert');
+const crypto = require('crypto');
+class UserService extends Service {
+  async login({ acct, password }) {
+    assert(acct, '帐号不存在');
+    assert(password, '密码不存在');
+    const { AdminUser: model } = this.ctx.model;
+    const hash = crypto.createHmac('sha256', this.app.config.userSecret);
+    const pwd = hash.update(password).digest('hex');
+    try {
+      const res = await model.find({ acct });
+      if (res.state !== 0) {
+        return { errmsg: '用户状态异常', errcode: -2003 };
+      }
+      if (res.password !== pwd) {
+        return { errmsg: '密码错误', errcode: -2003 };
+      }
+      const token = this.app.jwt.sign(res, this.app.config.jwt.secret);
+      return { errmsg: '', errcode: 0, token };
+    } catch (error) {
+      throw new Error({ errcode: -2001, errmsg: '登录失败' });
+    }
+  }
+}
+
+module.exports = UserService;

app/service/resource.js

@@ -0,0 +1,63 @@
+
+'use strict';
+
+const Service = require('egg').Service;
+const assert = require('assert');
+const moment = require('moment');
+const fs = require('fs');
+const fsPromises = fs.promises;
+class ResourceService extends Service {
+  async create({ name, path }) {
+    assert(name, '名称不存在');
+    assert(path, '路径不存在');
+    const { Resource: model } = this.ctx.model;
+    const createAt = moment().format('x');
+    try {
+      await model.create({ name, path, createAt });
+      return { errmsg: '', errcode: 0 };
+    } catch (error) {
+      throw new Error({ errcode: -2001, errmsg: '添加失败' });
+    }
+  }
+  async update({ name, path, id }) {
+    assert(id, 'id不存在');
+    const { Resource: model } = this.ctx.model;
+    try {
+      await model.findByIdAndUpdate(id, { name, path });
+      return { errmsg: '', errcode: 0 };
+    } catch (error) {
+      throw new Error({ errcode: -2001, errmsg: '修改失败' });
+    }
+  }
+  async del({ id }) {
+    assert(id, 'id不存在');
+    const { Resource: model } = this.ctx.model;
+    try {
+      // 获取文件路径
+      const files = await model.findById(id);
+      const filepath = `${files.path}`;
+      // 开始删除文件
+      await fsPromises.rmdir(filepath);
+      await model.findOneAndDelete(id);
+      return { errmsg: '', errcode: 0 };
+    } catch (error) {
+      throw new Error({ errcode: -2001, errmsg: '删除失败' });
+    }
+  }
+  async query({ skip, limit, filter }) {
+    const { Resource: model } = this.ctx.model;
+    try {
+      let res;
+      if (skip && limit) {
+        res = await model.find(filter).skip(skip * limit).limit(limit);
+      } else {
+        res = await model.find(filter);
+      }
+      return { errmsg: '', errcode: 0, data: res };
+    } catch (error) {
+      throw new Error({ errcode: -2001, errmsg: '查询失败' });
+    }
+  }
+}
+
+module.exports = ResourceService;

app/service/role.js

@@ -0,0 +1,62 @@
+'use strict';
+
+const Service = require('egg').Service;
+const assert = require('assert');
+const moment = require('moment');
+class RoleService extends Service {
+  async create({ name, code, state }) {
+    assert(name, '名称不存在');
+    assert(code, '编码不存在');
+    const { Role: model } = this.ctx.model;
+    const createAt = moment().format('x');
+    try {
+      await model.create({ name, code, createAt, state });
+      return { errmsg: '', errcode: 0 };
+    } catch (error) {
+      throw new Error({ errcode: -2001, errmsg: '添加失败' });
+    }
+  }
+  async update({ name, state, id }) {
+    assert(id, 'id不存在');
+    const { Role: model } = this.ctx.model;
+    try {
+      await model.findByIdAndUpdate(id, { name, state });
+      return { errmsg: '', errcode: 0 };
+    } catch (error) {
+      throw new Error({ errcode: -2001, errmsg: '修改失败' });
+    }
+  }
+  async del({ id }) {
+    assert(id, 'id不存在');
+    const { Role: model } = this.ctx.model;
+    const { adminUser: usermodel } = this.ctx.model;
+    try {
+      const role = await model.findById(id);
+      const userList = await usermodel.where('roleLise').in(role.code);
+      await model.findOneAndDelete(id);
+      userList.forEach(async e => {
+        const roleList = e.roleList.filter(p => p !== role.code);
+        await usermodel.findByIdAndUpdate(e._id, { roleList });
+      });
+      return { errmsg: '', errcode: 0 };
+    } catch (error) {
+      throw new Error({ errcode: -2001, errmsg: '删除失败' });
+    }
+  }
+  async query({ skip, limit, filter }) {
+    const { Role: model } = this.ctx.model;
+    try {
+      let res;
+      if (skip && limit) {
+        res = await model.find(filter).skip(skip * limit).limit(limit);
+      } else {
+        res = await model.find(filter);
+      }
+      return { errmsg: '', errcode: 0, data: res };
+    } catch (error) {
+      throw new Error({ errcode: -2001, errmsg: '查询失败' });
+    }
+  }
+}
+
+module.exports = RoleService;

appveyor.yml

@@ -0,0 +1,14 @@
+environment:
+  matrix:
+    - nodejs_version: '10'
+
+install:
+  - ps: Install-Product node $env:nodejs_version
+  - npm i npminstall && node_modules\.bin\npminstall
+
+test_script:
+  - node --version
+  - npm --version
+  - npm run test
+
+build: off

config/config.default.js

@@ -0,0 +1,59 @@
+/* eslint valid-jsdoc: "off" */
+
+'use strict';
+
+/**
+ * @param {Egg.EggAppInfo} appInfo app info
+ */
+module.exports = appInfo => {
+  /**
+   * built-in config
+   * @type {Egg.EggAppConfig}
+   **/
+  const config = exports = {};
+
+  // use for cookie sign key, should change to your own and keep security
+  config.keys = appInfo.name + '_1618984590142_9986';
+
+  // add your middleware config here
+  config.middleware = [];
+  // 关闭安全防范
+  config.security = {
+    csrf: {
+      enable: false,
+      ignoreJSON: true,
+    },
+  };
+  config.cors = {
+    origin: '*',
+    allowMethods: 'GET,HEAD,PUT,POST,DELETE,PATCH,OPTIONS',
+  };
+  // add your user config here
+  const userConfig = {
+    // myAppName: 'egg',
+  };
+  // 解除文件上传大小限制
+  config.bodyParser = {
+    jsonLimit: '100mb',
+    formLimit: '100mb',
+  };
+  // jwt密钥
+  config.jwt = {
+    secret: '123456',
+  };
+  config.userSecret = '123456';
+  // 数据库配置
+  config.mongoose = {
+    url: 'mongodb://127.0.0.1/example',
+    options: {},
+  };
+  // 异常捕获
+  config.middleware = [ 'errorHandler' ];
+  config.errorHandler = {
+    match: '/api',
+  };
+  return {
+    ...config,
+    ...userConfig,
+  };
+};

config/plugin.js

@@ -0,0 +1,17 @@
+'use strict';
+
+/** @type Egg.EggPlugin */
+module.exports = {
+  mongoose: {
+    enable: true,
+    package: 'egg-mongoose',
+  },
+  jwt: {
+    enable: true,
+    package: 'egg-jwt',
+  },
+  cors: {
+    enable: true,
+    package: 'egg-cors',
+  },
+};

jsconfig.json

@@ -0,0 +1,5 @@
+{
+  "include": [
+    "**/*"
+  ]
+}

package.json

@@ -0,0 +1,52 @@
+{
+  "name": "cms-service",
+  "version": "1.0.0",
+  "description": "",
+  "private": true,
+  "egg": {
+    "declarations": true
+  },
+  "dependencies": {
+    "egg": "^2.15.1",
+    "egg-cors": "^2.2.3",
+    "egg-jwt": "^3.1.7",
+    "egg-mongoose": "^3.3.1",
+    "egg-scripts": "^2.11.0",
+    "lodash": "^4.17.21",
+    "moment": "^2.29.1",
+    "uuid": "^8.3.2"
+  },
+  "devDependencies": {
+    "autod": "^3.0.1",
+    "autod-egg": "^1.1.0",
+    "egg-bin": "^4.11.0",
+    "egg-ci": "^1.11.0",
+    "egg-mock": "^3.21.0",
+    "eslint": "^5.13.0",
+    "eslint-config-egg": "^7.1.0"
+  },
+  "engines": {
+    "node": ">=10.0.0"
+  },
+  "scripts": {
+    "start": "egg-scripts start --daemon --title=egg-server-cms-service",
+    "stop": "egg-scripts stop --title=egg-server-cms-service",
+    "dev": "egg-bin dev",
+    "debug": "egg-bin debug",
+    "test": "npm run lint -- --fix && npm run test-local",
+    "test-local": "egg-bin test",
+    "cov": "egg-bin cov",
+    "lint": "eslint .",
+    "ci": "npm run lint && npm run cov",
+    "autod": "autod"
+  },
+  "ci": {
+    "version": "10"
+  },
+  "repository": {
+    "type": "git",
+    "url": ""
+  },
+  "author": "",
+  "license": "MIT"
+}

test/app/controller/home.test.js

@@ -0,0 +1,20 @@
+'use strict';
+
+const { app, assert } = require('egg-mock/bootstrap');
+
+describe('test/app/controller/home.test.js', () => {
+  it('should assert', () => {
+    const pkg = require('../../../package.json');
+    assert(app.config.keys.startsWith(pkg.name));
+
+    // const ctx = app.mockContext({});
+    // yield ctx.service.xx();
+  });
+
+  it('should GET /', () => {
+    return app.httpRequest()
+      .get('/')
+      .expect('hi, egg')
+      .expect(200);
+  });
+});