后台添加权限管理

gm-server/app/controller/gmaccount.ts

@@ -0,0 +1,49 @@
+import { Controller } from 'egg';
+
+export default class GmController extends Controller {
+    
+    public async getGmList() {
+        const { ctx } = this;
+        ctx.body = await ctx.service.gmUser.getGmList();
+    }
+
+    public async createGmAccount() {
+        const { ctx } = this;
+        const {password, name, username} = ctx.request.body;
+        ctx.body = await ctx.service.gmUser.createGmAccount(name, username, password);
+    }
+
+    public async getApiList() {
+        const { ctx } = this;
+        ctx.body = await ctx.service.gmUser.getApiList();
+    }
+
+    public async saveApi() {
+        const { ctx } = this;
+        const {api, name} = ctx.request.body;
+        ctx.body = await ctx.service.gmUser.saveApi(api, name);
+    }
+
+    public async getGroupList() {
+        const { ctx } = this;
+        ctx.body = await ctx.service.gmUser.getGroupList();
+    }
+
+    public async createGmGroup() {
+        const { ctx } = this;
+        const {group, name, desc} = ctx.request.body;
+        ctx.body = await ctx.service.gmUser.createGmGroup(group, name, desc);
+    }
+
+    public async saveGmApiToGroup() {
+        const { ctx } = this;
+        const {id, apis} = ctx.request.body;
+        ctx.body = await ctx.service.gmUser.saveGmApiToGroup(id, apis);
+    }
+
+    public async saveGmGroupToUser() {
+        const { ctx } = this;
+        const {uid, groups} = ctx.request.body;
+        ctx.body = await ctx.service.gmUser.saveGmGroupToUser(uid, groups);
+    }
+}

gm-server/app/controller/login.ts

@@ -15,10 +15,29 @@ export default class LoginController extends Controller {
       "data": ctx.user
     };
   }
-
-  public async createGmAccount() {
+  
+  public async getMenu() {
     const { ctx } = this;
-    const {password, name, username, group} = ctx.request.body;
-    ctx.body = await ctx.service.gmUser.createGmAccount(name, username, password, group);
+    ctx.body = {
+      "status": "ok",
+      "data": [
+          {
+            path: '/test',
+            authority: ['admin'],
+            routes: [
+              {
+                path: '/test/create-role',
+                authority: ['admin'],
+              },
+              {
+                path: '/test/create-data',
+                authority: ['admin'],
+              }
+            ],
+          }
+        ]
+    }
+    
   }
+
 }

gm-server/app/middleware/tokenParser.ts

@@ -1,8 +1,11 @@
 import { GMUserModel } from '@db/GMUser';
+import { GMUserGroupModel } from '@db/GMUserGroup'
+import { GMGroupModel } from '@db/GMGroup'
+import { ApiModel } from '@db/Api';
 
 module.exports = () => {
   return async function tokenParser(ctx, next) {
-    console.log(ctx.request.headers)
+
     if (!ctx.request.headers || !ctx.request.headers.token) {
       console.error('token not found');
       ctx.body = {
@@ -20,6 +23,34 @@ module.exports = () => {
       };
       return;
     }
+    const url = ctx.request.url;
+    let apiResult = await ApiModel.getApi(url);
+    if(!apiResult) {
+      ctx.body = {
+        "status": "error",
+        "data": "未找到该接口"
+      };
+      return;
+    }
+    let userGroups = await GMUserGroupModel.getUserGroupByUid(user.uid, 1);
+    let flag = 0;
+    for(let userGroup of userGroups) {
+      let { groupId } = userGroup;
+      let group = await GMGroupModel.getGroupById(groupId);
+      if(group) {
+        if(group.apis.includes(apiResult.apiId)) {
+          flag = 1; break;
+        }
+      }
+    }
+    if(flag != 1) {
+      ctx.body = {
+        "status": "error",
+        "data": "您没有权限访问该接口"
+      };
+      return;
+    }
+    console.log(user.uid, ctx.request.url, new Date());
     ctx.user = user;
     await next();
   };

gm-server/app/router.ts

@@ -4,14 +4,25 @@ export default (app: Application) => {
   const { controller, router } = app;
   const tokenParser = app.middleware.tokenParser();
 
-  router.get('/', controller.home.index);
+  router.get('/api', controller.home.index);
   router.post('/api/login/account', controller.login.login);
+  router.post('/api/get_route', controller.login.getMenu);
   router.get('/api/currentUser', tokenParser, controller.login.currentUser);
-  router.post('/api/gmaccount/createaccount', controller.login.createGmAccount);
-  router.post('/api/users/getuserlist', controller.users.getuserlist);
-  router.post('/api/users/createrole', controller.users.createRole);
-  router.post('/api/users/getrolelist', controller.users.getrolelist);
-  router.post('/api/users/createroledata', controller.users.createRoleData);
+  
+  router.post('/api/gmaccount/getgmlist', tokenParser, controller.gmaccount.getGmList);
+  router.post('/api/gmaccount/createaccount',tokenParser, controller.gmaccount.createGmAccount);
+  router.post('/api/gmaccount/savegmgrouptouser',tokenParser, controller.gmaccount.saveGmGroupToUser);
+  router.post('/api/gmaccount/getgrouplist',tokenParser, controller.gmaccount.getGroupList);
+  router.post('/api/gmaccount/getapilist',tokenParser, controller.gmaccount.getApiList);
+  router.post('/api/gmaccount/saveapi',tokenParser, controller.gmaccount.saveApi);
+  router.post('/api/gmaccount/creategmgroup',tokenParser, controller.gmaccount.createGmGroup);
+  router.post('/api/gmaccount/saveapitogroup',tokenParser, controller.gmaccount.saveGmApiToGroup);
+  
+  
+  router.post('/api/users/getuserlist',tokenParser, controller.users.getuserlist);
+  router.post('/api/users/createrole',tokenParser, controller.users.createRole);
+  router.post('/api/users/getrolelist',tokenParser, controller.users.getrolelist);
+  router.post('/api/users/createroledata',tokenParser, controller.users.createRoleData);
 
   
 };

gm-server/app/service/GmUser.ts

@@ -1,4 +1,7 @@
 import { GMUserModel } from '@db/GMUser';
+import { GMGroupModel } from '@db/GMGroup';
+import { GMUserGroupModel } from '@db/GMUserGroup';
+import { ApiModel } from '@db/Api';
 import { Service } from 'egg';
 
 /**
@@ -14,9 +17,16 @@ export default class GMUsers extends Service {
     let user = await GMUserModel.login(username, password);
 
     if(user) {
+      let userGroups = await GMUserGroupModel.getUserGroupByUid(user.uid, 1);
+      let group = new Array();
+      for(let userGroup of userGroups) {
+        let g = await GMGroupModel.getGroupById(userGroup.groupId);
+        if(g) group.push(g.group);
+      }
+
       return {
         "status": "ok",
-        "data": user
+        "data": {...user, group}
       }
     } else {
       return {
@@ -26,10 +36,45 @@ export default class GMUsers extends Service {
     }
   }
 
+  /**
+   * 后台账号列表
+   */
+  public async getGmList() {
+    // const {ctx} = this;
+    let list = await GMUserModel.getGmAccountList();
+    if(list) {
+      let result = new Array();
+      for(let user of list) {
+        let uid = user.uid;
+        let userGroupList = await GMUserGroupModel.getUserGroupByUid(uid, 1);
+        let groupArr = new Array(), groupStrArr = new Array();
+        for(let userGroup of userGroupList) {
+          let group = await GMGroupModel.getGroupById(userGroup.groupId);
+          console.log(userGroup.groupId, group);
+          if(group) {
+            groupArr.push(userGroup.groupId);
+            groupStrArr.push(group.name);
+          }
+        }
+        result.push({...user, group:groupArr,  groupStr: groupStrArr.length?groupStrArr.join():'暂无'});
+      }
+
+      return {
+        "status": "ok",
+        "data": result
+      }
+    
+    } else {
+      return {
+        "status": "error",
+        "data": "获取失败"
+      }
+    }
+  }
   /**
    * 创建后台账号
    */
-  public async createGmAccount(name: string, username: string, password: string, group: string) {
+  public async createGmAccount(name: string, username: string, password: string) {
     const {ctx} = this;
     let token = ctx.service.utils.genCode(256);
 
@@ -40,11 +85,164 @@ export default class GMUsers extends Service {
         "data": "该账号已使用"
       }
     } else {
-      user = await GMUserModel.createGmAccount(username, password, name, token, group);
+      user = await GMUserModel.createGmAccount(username, password, name, token);
       return {
         "status": "ok",
-        "data": user
+        "data": "创建成功"
       };
     }
   }
+
+  /**
+   * 后台Api列表
+   */
+  public async getApiList() {
+    // const {ctx} = this;
+    let list = await ApiModel.getAllApi();
+
+    if(list) {
+      return {
+        "status": "ok",
+        "data": list
+      }
+    } else {
+      return {
+        "status": "error",
+        "data": "获取失败"
+      }
+    }
+  }
+
+  /**
+   * 创建Api
+   */
+  public async saveApi(api:string, name:string) {
+    // const {ctx} = this;
+    let result = await ApiModel.getApi(api);
+    if(result) {
+      return {
+        "status": "error",
+        "data": "该接口已存在"
+      }
+    } else {
+      let result = await ApiModel.createApi(api, name);
+      if(result) {
+        return {
+          "status": "ok",
+          "data": "创建成功"
+        }
+      } else {
+        return {
+          "status": "error",
+          "data": "创建失败"
+        }
+      }
+    }
+  }
+
+
+  /**
+   * 后台用户组列表
+   */
+  public async getGroupList() {
+    // const {ctx} = this;
+    let list = await GMGroupModel.getAllGroup();
+
+    if(list) {
+      return {
+        "status": "ok",
+        "data": list
+      }
+    } else {
+      return {
+        "status": "error",
+        "data": "获取失败"
+      }
+    }
+  }
+
+  /**
+   * 创建用户组
+   */
+  public async createGmGroup(group:string, name:string, desc: string) {
+    // const {ctx} = this;
+    let result = await GMGroupModel.getGroup(group);
+    if(result) {
+      return {
+        "status": "error",
+        "data": "该用户组已存在"
+      }
+    } else {
+      let result = await GMGroupModel.createGroup(group, name, desc);
+      if(result) {
+        return {
+          "status": "ok",
+          "data": "创建成功"
+        }
+      } else {
+        return {
+          "status": "error",
+          "data": "创建失败"
+        }
+      }
+    }
+  }
+
+  /**
+   * 用户组添加接口
+   */
+  public async saveGmApiToGroup(apiId: number, apis: Array<number>) {
+    // const {ctx} = this;
+    let result = await GMGroupModel.saveApiToGroup(apiId, apis);
+    if(result) {
+      return {
+        "status": "ok",
+        "data": "保存成功"
+      }
+    } else {
+      return {
+        "status": "error",
+        "data": "保存失败"
+      }
+    }
+  }
+
+  /**
+   * 用户组添加接口
+   */
+  public async saveGmGroupToUser(uid: number, groups: Array<number>) {
+    let allUserGroup = await GMUserGroupModel.getUserGroupByUid(uid, 1);
+
+    let removeArr = allUserGroup.filter(userGroup => {
+      let gid = userGroup.groupId;
+      return groups.indexOf(gid) == -1;
+    }).map(cur => cur.groupId);
+
+    let flag = 0;
+    let result = await GMUserGroupModel.removeUserGroup(uid, 1, removeArr);
+    if(!result) {
+      flag = 1; 
+    }
+
+    if(!flag) {
+      for(let group of groups) {
+        let result = await GMUserGroupModel.addUserGroup(uid, 1, group);
+        if(!result) {
+          flag = 1; break;
+        } 
+      }
+    }
+
+    if(flag) {
+      return {
+        "status": "error",
+        "data": "保存失败"
+      }
+    }
+    return {
+      "status": "ok",
+      "data": "保存成功"
+    }
+
+  }
 }

gm-server/typings/app/controller/index.d.ts

@@ -2,12 +2,14 @@
 // Do not modify this file!!!!!!!!!
 
 import 'egg';
+import ExportGmaccount from '../../../app/controller/gmaccount';
 import ExportHome from '../../../app/controller/home';
 import ExportLogin from '../../../app/controller/login';
 import ExportUsers from '../../../app/controller/users';
 
 declare module 'egg' {
   interface IController {
+    gmaccount: ExportGmaccount;
     home: ExportHome;
     login: ExportLogin;
     users: ExportUsers;

shared/consts/consts.ts

@@ -9,5 +9,7 @@ export const AUTH_SMS_CNT_PER_DAY = 8;
 
 export const COUNTER = {
   UID: 'uid',
-  GMUID: 'gmuid'
+  GMUID: 'gmuid',
+  API: 'api',
+  GM_GROUP: 'gmgroup'
 };

shared/db/Api.ts

@@ -0,0 +1,41 @@
+import BaseModel from './BaseModel';
+import { index, getModelForClass, prop } from '@typegoose/typegoose';
+import { COUNTER } from './../consts/consts';
+import { CounterModel } from './Counter';
+
+/**
+  * 接口字段接口
+*/
+@index({ apiId: 1 })
+@index({ api: 1 })
+
+export default class Api extends BaseModel {
+
+  @prop({ required: true })
+  apiId: number;
+
+  @prop({ required: true })
+  api: string;
+
+  @prop({ required: true })
+  name: string;
+
+  public static async getApi(api: string, lean = true) {
+    let result = await ApiModel.findOne({api}).select('apiId api name').lean(lean);
+    return result;
+  }
+
+  public static async getAllApi(lean = true) {
+    const api = await ApiModel.find().sort({apiId: 1}).lean(lean);
+    return api;
+  }
+
+  public static async createApi(api:string, name: string, lean = true) {
+    const apiId = await CounterModel.getNewCounter(COUNTER.API);
+    const result = await ApiModel.findOneAndUpdate({apiId}, {$set:{api, name}}, {upsert: true, new: true}).lean(lean);
+    return result;
+  }
+  
+}
+
+export const ApiModel = getModelForClass(Api);

shared/db/BattleRecord.ts

@@ -1,9 +1,11 @@
 import BaseModel from './BaseModel';
 import { index, getModelForClass, prop } from '@typegoose/typegoose';
 
-
-@index({ roleId: 1, hid: 1, eid: 1 })
-@index({ seqId: 1 })
+/**
+  * 战斗记录接口
+  */
+@index({ roleId: 1, battleId: 1 })
+@index({ battleCode: 1 })
 
 export default class BattleRecord extends BaseModel {
   @prop({ required: true })

shared/db/GMGroup.ts

@@ -0,0 +1,72 @@
+import { COUNTER } from './../consts/consts';
+import { CounterModel } from './Counter';
+import BaseModel from './BaseModel';
+import { index, getModelForClass, prop } from '@typegoose/typegoose';
+
+/**
+  * GM用户组接口
+*/
+@index({ id: 1 })
+@index({ group: 1 })
+
+export default class GMGroup extends BaseModel {
+  @prop({ required: true })
+  id: number;
+
+  @prop({ required: true })
+  group: string;
+
+  @prop({ required: true })
+  name: string;
+
+  @prop({ required: true })
+  desc: string;
+
+  @prop({ required: true })
+  apis: Array<number>;
+
+   
+  public static async createGroup(group: string, name: string, desc: string, lean = true) {
+    const id = await CounterModel.getNewCounter(COUNTER.GM_GROUP);
+    const result = await GMGroupModel.findOneAndUpdate({id}, {group, desc, name, apis: []}, {upsert: true, new: true}).select('uid username name').lean(lean);
+    return result;
+  }
+
+  public static async getAllGroup(lean = true) {
+    const list = await GMGroupModel.find().lean(lean);
+    return list;
+  }
+
+  public static async getGroup(group: string, lean = true) {
+    const result = await GMGroupModel.findOne({ group }).lean(lean);
+    return result;
+  }
+  
+  public static async getGroupById(id: number, lean = true) {
+    const result = await GMGroupModel.findOne({ id }).lean(lean);
+    return result;
+  }
+
+  public static async saveApiToGroup(id: number, apis: Array<number>, lean = true) {
+    let group = await GMGroupModel.getGroupById(id);
+    if(group) {
+      let originApi = group.apis||[];
+      let addArr = new Array(), removeArr = new Array();
+      for(let i = 0; i < apis.length; i++) {
+        let api = apis[i];
+        if(originApi.indexOf(api) == -1) addArr.push(api);
+      }
+      for(let i = 0; i < originApi.length; i++) {
+        let api = originApi[i];
+        if(apis.indexOf(api) == -1) removeArr.push(api);
+      }
+      await GMGroupModel.findOneAndUpdate({ id }, { $push: {apis: {$each: addArr}} }).lean(lean);
+      const result = await GMGroupModel.findOneAndUpdate({ id }, { $pull: {apis: {$in: removeArr}} }).lean(lean);
+      return result;
+    }
+  }
+  
+  
+}
+
+export const GMGroupModel = getModelForClass(GMGroup);

shared/db/GMUser.ts

@@ -7,9 +7,8 @@ const SALT_WORK_FACTOR = 5
 
 
 /**
-  * 用户字段接口
+  * GM账号字段接口
 */
-@index({ tel: 1 })
 @index({ uid: 1 })
 
 export default class GMUser extends BaseModel {
@@ -31,9 +30,6 @@ export default class GMUser extends BaseModel {
   @prop({ required: true })
   token: string;
 
-  @prop({ required: true, default: '' })
-  group: string;
-
   private static async encryptPass(password: string, salt?: string) {
     console.log(salt)
     if(!salt) {
@@ -44,18 +40,23 @@ export default class GMUser extends BaseModel {
     return {npassword, salt};
   }
   
+  public static async getGmAccountList(lean = true) {
+    const user = await GMUserModel.find().select('uid username name token').lean(lean);
+    return user;
+  }
+
   public static async getGmAccountByToken(token: string, lean = true) {
-    const user = await GMUserModel.findOne({token}).select('uid username name token group').lean(lean);
+    const user = await GMUserModel.findOne({token}).select('uid username name token').lean(lean);
     return user;
   }
 
   public static async getGmAccountByUid(uid: number, lean = true) {
-    const user = await GMUserModel.findOne({uid}).select('uid username name token group').lean(lean);
+    const user = await GMUserModel.findOne({uid}).select('uid username name token').lean(lean);
     return user;
   }
 
   public static async getGmAccountByUsername(username: string, lean = true) {
-    const user = await GMUserModel.findOne({username}).select('uid username name token group').lean(lean);
+    const user = await GMUserModel.findOne({username}).select('uid username name token').lean(lean);
     return user;
   }
 
@@ -66,17 +67,17 @@ export default class GMUser extends BaseModel {
       console.log(salt)
       let { npassword } = await this.encryptPass(password, salt);
       console.log(username, npassword)
-      const checkUser = await GMUserModel.findOne({username, password: npassword}).select('uid username name token group').lean(lean);
+      const checkUser = await GMUserModel.findOne({username, password: npassword}).select('uid username name token').lean(lean);
       return checkUser;
     } else {
       return null
     }
   }
 
-  public static async createGmAccount(username: string, password: string, name: string, token: string, group: string, lean = true) {
+  public static async createGmAccount(username: string, password: string, name: string, token: string, lean = true) {
     const uid = await CounterModel.getNewCounter(COUNTER.GMUID);
     let r = await this.encryptPass(password);
-    const user = await GMUserModel.findOneAndUpdate({username}, {uid, password: r.npassword, salt: r.salt, name, token, group}, {upsert: true, new: true}).select('uid username name group').lean(lean);
+    const user = await GMUserModel.findOneAndUpdate({username}, {uid, password: r.npassword, salt: r.salt, name, token}, {upsert: true, new: true}).select('uid username name').lean(lean);
     return user;
   }
 

shared/db/GMUserGroup.ts

@@ -0,0 +1,35 @@
+import BaseModel from './BaseModel';
+import { index, getModelForClass, prop } from '@typegoose/typegoose';
+
+/**
+  * GM账号和用户组关系接口
+*/
+@index({ uid: 1, serverId: 1, groupId: 1 })
+
+export default class GMUserGroup extends BaseModel {
+  @prop({ required: true })
+  uid: number;
+
+  @prop({ required: true })
+  serverId: number;
+
+  @prop({ required: true })
+  groupId: number;
+
+  public static async getUserGroupByUid(uid: number, serverId: number, lean = true) {
+    const user = await GMUserGroupModel.find({uid, serverId}).lean(lean);
+    return user;
+  }
+
+  public static async removeUserGroup(uid: number, serverId: number, groups: Array<number>, lean = true) {
+    const user = await GMUserGroupModel.deleteMany({uid, serverId, groupId: {$in: groups}}).lean(lean);
+    return user;
+  }
+
+  public static async addUserGroup(uid: number, serverId: number, groupId: number, lean = true) {
+    const result = await GMUserGroupModel.findOneAndUpdate({uid, serverId, groupId}, {}, {new:true, upsert:true}).lean(lean);
+    return result;
+  }
+}
+
+export const GMUserGroupModel = getModelForClass(GMUserGroup);

shared/db/Item.ts

@@ -2,7 +2,7 @@ import BaseModel from './BaseModel';
 import { index, getModelForClass, prop } from '@typegoose/typegoose';
 
 
-@index({ roleId: 1, hid: 1, eid: 1 })
+@index({ roleId: 1, hid: 1, itemid: 1 })
 @index({ seqId: 1 })
 export default class Item extends BaseModel {
   @prop({ required: true })