app/controller/column.js

@@ -23,9 +23,9 @@ class ColumnController extends Controller {
     const res = await ctx.service.column.query(ctx.query);
     ctx.body = res;
   }
-  async menuquery() {
+  async usercolumnquery() {
     const { ctx } = this;
-    const res = await ctx.service.column.menuquery(ctx.query);
+    const res = await ctx.service.column.usercolumnquery(ctx.query);
     ctx.body = res;
   }
 }

app/controller/configuration.js

@@ -5,17 +5,17 @@ const Controller = require('egg').Controller;
 class ConfigurationController extends Controller {
   async create() {
     const { ctx } = this;
-    const res = await ctx.service.contentType.create(ctx.request.body);
+    const res = await ctx.service.configuration.create(ctx.request.body);
     ctx.body = res;
   }
   async update() {
     const { ctx } = this;
-    const res = await ctx.service.contentType.update(ctx.request.body);
+    const res = await ctx.service.configuration.update(ctx.request.body);
     ctx.body = res;
   }
   async query() {
     const { ctx } = this;
-    const res = await ctx.service.contentType.query(ctx.query);
+    const res = await ctx.service.configuration.query(ctx.query);
     ctx.body = res;
   }
 }

app/controller/power.js

@@ -8,6 +8,11 @@ class LoginController extends Controller {
     const res = await ctx.service.power.login(ctx.request.body);
     ctx.body = res;
   }
+  async getUserMenu() {
+    const { ctx } = this;
+    const res = await ctx.service.power.getUserMenu();
+    ctx.body = res;
+  }
 }
 
 module.exports = LoginController;

app/middleware/error_handler.js

@@ -4,12 +4,15 @@ module.exports = () => {
     try {
       await next();
     } catch (err) {
-      console.log(err);
-      // console.log(err.code);
       const { message } = err;
-      const json = JSON.parse(message);
-      console.log(json);
-      // ctx.body = json;
+      let json = {
+        errcode: -1001,
+        errmsg: message,
+      };
+      if (err.code !== 'ERR_ASSERTION') {
+        json = JSON.parse(message);
+      }
+      ctx.body = json;
       ctx.status = 400;
     }
   };

app/middleware/jwt.js

@@ -1,15 +1,15 @@
 'use strict';
 module.exports = options => {
   return async function jwt(ctx, next) {
-    const token = ctx.request.header.authorization;
+    const str = ctx.request.header.authorization;
     let decode;
-    if (token) {
+    if (str) {
       try {
+        const token = str.substring(7);
         // 解码token
         decode = ctx.app.jwt.verify(token, options.secret);
-        await next();
-        return decode;
       } catch (error) {
+        console.log(error, 11111);
         ctx.status = 401;
         ctx.body = {
           errmsg: error.message,
@@ -17,6 +17,10 @@ module.exports = options => {
         };
         return;
       }
+      if (decode) {
+        await next();
+        return decode;
+      }
     } else {
       ctx.status = 401;
       ctx.body = {

app/model/AdminUser.js

@@ -33,7 +33,7 @@ module.exports = app => {
     },
     // 用户状态
     state: {
-      type: Number,
+      type: String,
     },
     // 用户id
     id: {

app/model/Menu.js

@@ -13,10 +13,10 @@ module.exports = app => {
       type: String,
     },
     state: {
-      type: Number,
+      type: String,
     },
     type: {
-      type: Number,
+      type: String,
     },
     uri: {
       type: String,

app/model/Role.js

@@ -17,7 +17,7 @@ module.exports = app => {
     },
     // 角色状态
     state: {
-      type: Number,
+      type: String,
     },
     // 角色绑定系统菜单组
     adminMenuList: {

app/public/adminMenu.js

@@ -25,17 +25,25 @@ module.exports = [
     module: '@gaf',
   },
   {
-    title: '权限管理',
-    path: '/gaf/power',
+    title: '用户授权',
+    path: '/gaf/userpower',
     id: '1-3',
     icons: 'el-icon-user-solid',
     parentId: '1',
     module: '@gaf',
   },
+  {
+    title: '角色授权',
+    path: '/gaf/rolepower',
+    id: '1-4',
+    icons: 'el-icon-user-solid',
+    parentId: '1',
+    module: '@gaf',
+  },
   {
     title: '日志审计',
     path: '/gaf/log',
-    id: '1-4',
+    id: '1-5',
     icons: 'el-icon-user-solid',
     parentId: '1',
     module: '@gaf',
@@ -107,7 +115,7 @@ module.exports = [
   {
     title: '单页管理',
     path: '/wokes/pages',
-    id: '3-3',
+    id: '3-4',
     icons: 'el-icon-user-solid',
     parentId: '3',
     module: '@wokes',
@@ -115,7 +123,7 @@ module.exports = [
   {
     title: '文件管理',
     path: '/wokes/files',
-    id: '3-4',
+    id: '3-5',
     icons: 'el-icon-user-solid',
     parentId: '3',
     module: '@wokes',
@@ -123,7 +131,7 @@ module.exports = [
   {
     title: '资源管理',
     path: '/wokes/resource',
-    id: '3-5',
+    id: '3-6',
     icons: 'el-icon-user-solid',
     parentId: '3',
     module: '@wokes',

app/router.js

@@ -5,66 +5,67 @@
  */
 module.exports = app => {
   const { router, controller } = app;
-  // const jwt = app.middleware.jwt(app.config.jwt);
+  const jwt = app.middleware.jwt(app.config.jwt);
   // 系统用户
-  router.post('/api/adminUser/create', controller.adminUser.create);
-  router.post('/api/adminUser/update', controller.adminUser.update);
-  router.delete('/api/adminUser/delete/:id', controller.adminUser.del);
+  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', controller.adminUser.query);
   // 角色
-  router.post('/api/role/create', controller.role.create);
-  router.post('/api/role/update', controller.role.update);
-  router.delete('/api/role/delete/:id', controller.role.del);
+  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', controller.role.query);
   // 菜单
-  router.post('/api/menu/create', controller.menu.create);
-  router.post('/api/menu/update', controller.menu.update);
-  router.delete('/api/menu/delete/:id', controller.menu.del);
+  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', 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', controller.column.del);
+  router.post('/api/column/create', jwt, controller.column.create);
+  router.post('/api/column/update', jwt, controller.column.update);
+  router.delete('/api/column/delete/:id', jwt, controller.column.del);
   router.get('/api/column/query', controller.column.query);
-  router.get('/api/column/menuquery', controller.column.menuquery);
+  router.get('/api/column/usercolumnquery', controller.column.usercolumnquery);
   // 登录
   router.post('/api/power/login', controller.power.login);
+  router.get('/api/power/getUserMenu', controller.power.getUserMenu);
   // 内容
-  router.post('/api/content/create', controller.content.create);
-  router.post('/api/content/update', controller.content.update);
-  router.delete('/api/content/delete/:id', controller.content.del);
+  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', controller.content.query);
   router.get('/api/content/details', controller.content.details);
   // 单页
-  router.post('/api/page/create', controller.page.create);
-  router.post('/api/page/update', controller.page.update);
-  router.delete('/api/page/delete/:id', controller.page.del);
+  router.post('/api/page/create', jwt, controller.page.create);
+  router.post('/api/page/update', jwt, controller.page.update);
+  router.delete('/api/page/delete/:id', jwt, controller.page.del);
   router.get('/api/page/query', controller.page.query);
   router.get('/api/page/details', controller.page.details);
   // 文件
-  router.post('/api/files/create', controller.files.create);
-  router.post('/api/files/update', controller.files.update);
-  router.delete('/api/files/delete/:id', controller.files.del);
+  router.post('/api/files/create', jwt, controller.files.create);
+  router.post('/api/files/update', jwt, controller.files.update);
+  router.delete('/api/files/delete/:id', jwt, controller.files.del);
+  router.post('/api/files/upload', jwt, controller.files.upload);
   router.get('/api/files/query', controller.files.query);
-  router.post('/api/files/upload', controller.files.upload);
   // 资源
-  router.post('/api/resource/create', controller.resource.create);
-  router.post('/api/resource/update', controller.resource.update);
-  router.delete('/api/resource/delete/:id', controller.resource.del);
+  router.post('/api/resource/create', jwt, controller.resource.create);
+  router.post('/api/resource/update', jwt, controller.resource.update);
+  router.delete('/api/resource/delete/:id', jwt, controller.resource.del);
   router.get('/api/resource/query', controller.resource.query);
   // 友情链接
-  router.post('/api/links/create', controller.links.create);
-  router.post('/api/links/update', controller.links.update);
-  router.delete('/api/links/delete/:id', controller.links.del);
+  router.post('/api/links/create', jwt, controller.links.create);
+  router.post('/api/links/update', jwt, controller.links.update);
+  router.delete('/api/links/delete/:id', jwt, controller.links.del);
   router.get('/api/links/query', controller.links.query);
   // banner
-  router.post('/api/banner/create', controller.banner.create);
-  router.post('/api/banner/update', controller.banner.update);
-  router.delete('/api/banner/delete/:id', controller.banner.del);
+  router.post('/api/banner/create', jwt, controller.banner.create);
+  router.post('/api/banner/update', jwt, controller.banner.update);
+  router.delete('/api/banner/delete/:id', jwt, controller.banner.del);
   router.get('/api/banner/query', controller.banner.query);
   // 站点配置
-  router.post('/api/configuration/create', controller.configuration.create);
-  router.post('/api/configuration/update', controller.configuration.update);
+  router.post('/api/configuration/create', jwt, controller.configuration.create);
+  router.post('/api/configuration/update', jwt, controller.configuration.update);
   router.get('/api/configuration/query', controller.configuration.query);
   // 系统菜单
   router.get('/api/adminmenu/query', controller.adminnenu.query);

app/service/adminUser.js

@@ -9,9 +9,10 @@ class adminUserService extends Service {
     assert(acct, '帐号不存在');
     assert(password, '密码不存在');
     assert(userName, '用户名不存在');
-    assert(phone, '手机号不存在');
     assert(state, '状态不存在');
     const { AdminUser: model } = this.ctx.model;
+    const user = await model.find({ acct });
+    if (user.length > 0) return { errmsg: '帐号已存在', errcode: -2001 };
     const createAt = moment().format('x');
     const hash = crypto.createHmac('sha256', this.app.config.userSecret);
     const pwa = hash.update(password).digest('hex');
@@ -19,32 +20,34 @@ class adminUserService extends Service {
       const res = await model.create({ acct, password: pwa, userName, phone, createAt, state, roleList, columnList });
       return { errmsg: '', errcode: 0, res };
     } catch (error) {
+      console.log(error);
       throw new Error({ errcode: -2001, errmsg: '添加失败' });
     }
   }
-  async update({ userName, phone, id, roleList, state, columnList }) {
-    assert(id, 'id不存在');
+  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 });
+      await model.findById(_id).update({ userName, phone, roleList, state, columnList });
       return { errmsg: '', errcode: 0 };
     } catch (error) {
+      console.log(error);
       throw new Error({ errcode: -2001, errmsg: '修改失败' });
     }
   }
-  async pwdUpdate({ password, id, confirmPwd }) {
-    assert(id, 'id不存在');
+  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);
+      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 });
+      await model.findByIdAndUpdate(_id, { password: pwd });
       return { errmsg: '', errcode: 0 };
     } catch (error) {
       throw new Error({ errcode: -2001, errmsg: '修改失败' });
@@ -54,22 +57,27 @@ class adminUserService extends Service {
     assert(id, 'id不存在');
     const { AdminUser: model } = this.ctx.model;
     try {
-      await model.findOneAndDelete(id);
+      await model.findById(id).remove();
       return { errmsg: '', errcode: 0 };
     } catch (error) {
       throw new Error({ errcode: -2001, errmsg: '删除失败' });
     }
   }
-  async query({ skip, limit, filter }) {
+  async query({ skip, limit, userName, state, acct }) {
     const { AdminUser: model } = this.ctx.model;
+    const filter = {};
+    if (userName) filter.userName = userName;
+    if (state) filter.state = state;
+    if (acct) filter.acct = acct;
     try {
       let res;
+      const total = await model.find();
       if (skip && limit) {
-        res = await model.find({ ...filter, password: false }).skip(skip * limit).limit(limit);
+        res = await model.find({ ...filter }, { password: false }).skip(Number(skip) * Number(limit)).limit(Number(limit));
       } else {
-        res = await model.find(filter);
+        res = await model.find({ ...filter }, { password: false });
       }
-      return { errmsg: '', errcode: 0, data: res };
+      return { errmsg: '', errcode: 0, data: res, total: total.length };
     } catch (error) {
       throw new Error({ errcode: -2001, errmsg: '查询失败' });
     }

app/service/column.js

@@ -17,11 +17,11 @@ class ColumnService extends Service {
       throw new Error({ errcode: -2001, errmsg: '添加失败' });
     }
   }
-  async update({ name, code, id, menuList }) {
-    assert(id, 'id不存在');
+  async update({ name, code, _id, menuList }) {
+    assert(_id, 'id不存在');
     const { Column: model } = this.ctx.model;
     try {
-      await model.findByIdAndUpdate(id, { name, code, menuList });
+      await model.findById(_id).update({ name, code, menuList });
       return { errmsg: '', errcode: 0 };
     } catch (error) {
       throw new Error({ errcode: -2001, errmsg: '修改失败' });
@@ -46,26 +46,43 @@ class ColumnService extends Service {
       throw new Error({ errcode: -2001, errmsg: '删除失败' });
     }
   }
-  async menuquery({ code }) {
+  async usercolumnquery() {
     const { Column: model } = this.ctx.model;
-
+    const { AdminUser: Usermodel } = this.ctx.model;
     try {
-      const res = await model.where('menuList').in(code);
-      return { errmsg: '', errcode: 0, data: res };
+      const str = this.ctx.request.header.authorization;
+      const token = str.substring(7);
+      const decode = this.ctx.app.jwt.verify(token, this.app.config.jwt.secret);
+      const columnList = [];
+      const res = await Usermodel.find({ acct: decode.acct });
+      if (res.length > 0) {
+        const usercolumnList = res[0].columnList;
+        if (usercolumnList.length > 0) {
+          for (let i = 0; i < usercolumnList.length; i++) {
+            const item = await model.find({ code: usercolumnList[i] });
+            columnList.push(item[0]);
+          }
+        }
+      }
+      return { errmsg: '', errcode: 0, data: columnList };
     } catch (error) {
       throw new Error({ errcode: -2001, errmsg: '查询失败' });
     }
   }
-  async query({ skip, limit }) {
+  async query({ skip, limit, name, code }) {
     const { Column: model } = this.ctx.model;
+    const filter = {};
+    if (name) filter.name = name;
+    if (code) filter.code = code;
     try {
       let res;
+      const total = await model.find();
       if (skip && limit) {
-        res = await model.find().skip(skip * limit).limit(limit);
+        res = await model.find({ ...filter }).skip(Number(skip) * Number(limit)).limit(Number(limit));
       } else {
-        res = await model.find();
+        res = await model.find({ ...filter });
       }
-      return { errmsg: '', errcode: 0, data: res };
+      return { errmsg: '', errcode: 0, data: res, total: total.length };
     } catch (error) {
       console.log(error, 111);
       throw new Error({ errcode: -2001, errmsg: '查询失败' });

app/service/configuration.js

@@ -14,11 +14,11 @@ class ConfigurationService extends Service {
       throw new Error({ errcode: -2001, errmsg: '添加失败' });
     }
   }
-  async update({ name, describe, company, phone, address, mail, postcode, record, id }) {
-    assert(id, 'id不存在');
+  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 });
+      await model.findById(_id).update({ name, describe, company, phone, address, mail, postcode, record });
       return { errmsg: '', errcode: 0 };
     } catch (error) {
       throw new Error({ errcode: -2001, errmsg: '修改失败' });
@@ -28,7 +28,7 @@ class ConfigurationService extends Service {
     const { Configuration: model } = this.ctx.model;
     try {
       const res = await model.find();
-      return { errmsg: '', errcode: 0, data: res };
+      return { errmsg: '', errcode: 0, data: res[0] };
     } catch (error) {
       throw new Error({ errcode: -2001, errmsg: '查询失败' });
     }

app/service/menu.js

@@ -4,25 +4,26 @@ const Service = require('egg').Service;
 const assert = require('assert');
 const moment = require('moment');
 class MenuService extends Service {
-  async create({ name, code, state, type, uri }) {
+  async create({ name, code, state, type, uri, en }) {
     assert(name, '名称不存在');
     assert(code, '编码不存在');
     assert(state, '状态不存在');
     assert(type, '类型不存在');
+    assert(en, '英文缩写不存在');
     const { Menu: model } = this.ctx.model;
     const createAt = moment().format('x');
     try {
-      await model.create({ name, code, createAt, state, type, uri });
+      await model.create({ name, code, createAt, state, type, uri, en });
       return { errmsg: '', errcode: 0 };
     } catch (error) {
       throw new Error({ errcode: -2001, errmsg: '添加失败' });
     }
   }
-  async update({ name, state, id }) {
-    assert(id, 'id不存在');
+  async update({ name, state, _id, uri, en }) {
+    assert(_id, 'id不存在');
     const { Menu: model } = this.ctx.model;
     try {
-      await model.findByIdAndUpdate(id, { name, state });
+      await model.findById(_id).update({ name, state, uri, en });
       return { errmsg: '', errcode: 0 };
     } catch (error) {
       throw new Error({ errcode: -2001, errmsg: '修改失败' });
@@ -37,13 +38,17 @@ class MenuService extends Service {
     try {
       const menu = await model.findById(id);
       const roleList = await Rolemodel.where('adminMenuList').in(menu.code);
+      roleList.forEach(async e => {
+        const adminMenuList = e.adminMenuList.filter(p => p !== menu.code);
+        await Rolemodel.findById(e._id).update({ adminMenuList });
+      });
       switch (menu.type) {
         case 0: {
           // 栏目
-          const menuList = await Columnmodel.where('menuList').in(menu.code);
+          const menuList = await Columnmodel.find({ menuList: { $in: [ menu.code ] } });
           menuList.filter(async p => {
             const menuList = p.menuList.filter(p => p !== menu.code);
-            await Columnmodel.findByIdAndUpdate(p._id, { menuList });
+            await Columnmodel.findById(p._id).update({ menuList });
           });
           break;
         }
@@ -51,7 +56,7 @@ class MenuService extends Service {
           // 单页
           const pageList = await Pagemodel.find({ menu: menu.code });
           pageList.filter(async p => {
-            await Pagemodel.findByIdAndUpdate(p._id, { menu: null });
+            await Pagemodel.findById(p._id).update({ menu: null });
           });
           break;
         }
@@ -67,26 +72,26 @@ class MenuService extends Service {
           break;
         }
       }
-      await model.findOneAndDelete(id);
-      roleList.forEach(async e => {
-        const adminMenuList = e.adminMenuList.filter(p => p !== menu.code);
-        await Rolemodel.findByIdAndUpdate(e._id, { adminMenuList });
-      });
+      await model.findById(id).remove();
       return { errmsg: '', errcode: 0 };
     } catch (error) {
       throw new Error({ errcode: -2001, errmsg: '删除失败' });
     }
   }
-  async query({ skip, limit }) {
+  async query({ skip, limit, name, code }) {
     const { Menu: model } = this.ctx.model;
     try {
+      const total = await model.find();
+      const filter = {};
+      if (name) filter.name = name;
+      if (code) filter.code = code;
       let res;
       if (skip !== undefined && limit !== undefined) {
-        res = await model.find().skip(skip * limit).limit(limit);
+        res = await model.find({ ...filter }).skip(Number(skip) * Number(limit)).limit(Number(limit));
       } else {
-        res = await model.find();
+        res = await model.find({ ...filter });
       }
-      return { errmsg: '', errcode: 0, data: res };
+      return { errmsg: '', errcode: 0, data: res, total: total.length };
     } catch (error) {
       console.log(error);
       throw new Error({ errcode: -2001, errmsg: '查询失败' });

app/service/power.js

@@ -3,6 +3,7 @@
 const Service = require('egg').Service;
 const assert = require('assert');
 const crypto = require('crypto');
+const menu = require('../public/adminMenu');
 class UserService extends Service {
   async login({ acct, password }) {
     assert(acct, '帐号不存在');
@@ -12,14 +13,46 @@ class UserService extends Service {
     const pwd = hash.update(password).digest('hex');
     try {
       const res = await model.find({ acct });
-      if (res.state !== 0) {
+      const userInfo = res[0];
+      if (userInfo.state !== 0) {
         return { errmsg: '用户状态异常', errcode: -2003 };
       }
-      if (res.password !== pwd) {
+      if (userInfo.password !== pwd) {
         return { errmsg: '密码错误', errcode: -2003 };
       }
-      const token = this.app.jwt.sign(res, this.app.config.jwt.secret);
-      return { errmsg: '', errcode: 0, token };
+      const token = this.app.jwt.sign({ acct: userInfo.acct, userName: userInfo.userName, id: userInfo._id }, this.app.config.jwt.secret);
+      return { errmsg: '', errcode: 0, token, userInfo: { acct: userInfo.acct, userName: userInfo.userName, id: userInfo._id } };
+    } catch (error) {
+      throw new Error({ errcode: -2001, errmsg: '登录失败' });
+    }
+  }
+  async getUserMenu() {
+    const { AdminUser: model } = this.ctx.model;
+    const { Role: rolemodel } = this.ctx.model;
+    try {
+      const str = this.ctx.request.header.authorization;
+      const token = str.substring(7);
+      const decode = this.ctx.app.jwt.verify(token, this.app.config.jwt.secret);
+      const menulist = [];
+      const res = await model.find({ acct: decode.acct });
+      if (res.length > 0) {
+        const userRoleList = res[0].roleList;
+        if (userRoleList && userRoleList.length > 0) {
+          for (let e = 0; e < userRoleList.length; e++) {
+            const role = await rolemodel.find({ code: userRoleList[e], state: '0' });
+            if (role.length > 0) {
+              const adminMenuList = role[0].adminMenuList;
+              for (let i = 0; i < adminMenuList.length; i++) {
+                if (!menulist.includes(adminMenuList[i])) {
+                  menulist.push(menu.filter(j => adminMenuList[i] === j.id)[0]);
+                }
+              }
+            }
+          }
+        }
+      }
+
+      return { errcode: 0, errmsg: '', data: menulist };
     } catch (error) {
       throw new Error({ errcode: -2001, errmsg: '登录失败' });
     }

app/service/role.js

@@ -7,20 +7,25 @@ class RoleService extends Service {
   async create({ name, code, state }) {
     assert(name, '名称不存在');
     assert(code, '编码不存在');
+    assert(state, '状态不存在');
     const { Role: model } = this.ctx.model;
     const createAt = moment().format('x');
     try {
+      const isrole = await model.find({ code });
+      if (isrole.length > 0) {
+        return { errcode: -2001, errmsg: '编码已存在' };
+      }
       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不存在');
+  async update({ name, state, _id, adminMenuList }) {
+    assert(_id, 'id不存在');
     const { Role: model } = this.ctx.model;
     try {
-      await model.findByIdAndUpdate(id, { name, state });
+      await model.findById(_id).update({ name, state, adminMenuList });
       return { errmsg: '', errcode: 0 };
     } catch (error) {
       throw new Error({ errcode: -2001, errmsg: '修改失败' });
@@ -29,31 +34,40 @@ class RoleService extends Service {
   async del({ id }) {
     assert(id, 'id不存在');
     const { Role: model } = this.ctx.model;
-    const { adminUser: usermodel } = 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);
+      // 关联删除 数组查询
+      const userList = await usermodel.find({ roleList: { $in: [ role.code ] } });
+      // 轮询
       userList.forEach(async e => {
         const roleList = e.roleList.filter(p => p !== role.code);
-        await usermodel.findByIdAndUpdate(e._id, { roleList });
+        await usermodel.findById(e._id).update({ roleList });
       });
+      // 结束
+      await model.findById(id).remove();
       return { errmsg: '', errcode: 0 };
     } catch (error) {
       throw new Error({ errcode: -2001, errmsg: '删除失败' });
     }
   }
-  async query({ skip, limit, filter }) {
+  async query({ skip, limit, name, code, state }) {
     const { Role: model } = this.ctx.model;
+    const filter = {};
+    if (name) filter.userName = name;
+    if (code) filter.state = code;
+    if (state) filter.acct = state;
     try {
+      const total = await model.find();
       let res;
       if (skip && limit) {
-        res = await model.find(filter).skip(skip * limit).limit(limit);
+        res = await model.find({ ...filter }).skip(Number(skip) * Number(limit)).limit(Number(limit));
       } else {
-        res = await model.find(filter);
+        res = await model.find({ ...filter });
       }
-      return { errmsg: '', errcode: 0, data: res };
+      return { errmsg: '', errcode: 0, data: res, total: total.length };
     } catch (error) {
+      console.log(error);
       throw new Error({ errcode: -2001, errmsg: '查询失败' });
     }
   }

config/config.default.js

@@ -43,16 +43,20 @@ module.exports = appInfo => {
   };
   config.userSecret = '123456';
   // 数据库配置
+  // config.mongoose = {
+  //   url: 'mongodb://172.17.116.7:27018/example',
+  //   options: {
+  //     user: 'root',
+  //     pass: 'cms@cc-lotus',
+  //     authSource: 'admin',
+  //     useNewUrlParser: true,
+  //     useCreateIndex: true,
+  //     useUnifiedTopology: true,
+  //   },
+  // };
   config.mongoose = {
-    url: 'mongodb://172.17.116.7:27018/example',
-    options: {
-      user: 'root',
-      pass: 'cms@cc-lotus',
-      authSource: 'admin',
-      useNewUrlParser: true,
-      useCreateIndex: true,
-      useUnifiedTopology: true,
-    },
+    url: 'mongodb://127.0.0.1:27017/example',
+    options: {},
   };
   // 异常捕获
   config.middleware = [ 'errorHandler' ];