添加后台连接用的后端

gm-server/app/consts

@@ -0,0 +1 @@
+../../shared/consts

gm-server/app/controller/home.ts

@@ -0,0 +1,8 @@
+import { Controller } from 'egg';
+
+export default class HomeController extends Controller {
+  public async index() {
+    const { ctx } = this;
+    ctx.body = await ctx.service.test.sayHi('egg');
+  }
+}

gm-server/app/controller/login.ts

@@ -0,0 +1,24 @@
+import { Controller } from 'egg';
+
+export default class LoginController extends Controller {
+
+  public async login() {
+    const { ctx } = this;
+    const {username, password} = ctx.request.body;
+    ctx.body = await ctx.service.gmUser.login(username, password);
+  }
+
+  public async currentUser() {
+    const { ctx } = this;
+    ctx.body = {
+      "status": "ok",
+      "data": ctx.user
+    };
+  }
+
+  public async createGmAccount() {
+    const { ctx } = this;
+    const {password, name, username, group} = ctx.request.body;
+    ctx.body = await ctx.service.gmUser.createGmAccount(name, username, password, group);
+  }
+}

gm-server/app/controller/users.ts

@@ -0,0 +1,41 @@
+import { Controller } from 'egg';
+
+export default class UserController extends Controller {
+
+  public async getuserlist() {
+    const { ctx } = this;
+    const { field, value } = ctx.request.body;
+    ctx.body = await ctx.service.users.getuserlist(field, value);
+  }
+
+  public async createRole() {
+    const { ctx } = this;
+    const { uid, roleName } = ctx.request.body;
+    const serverId = 1;
+    ctx.body = await ctx.service.users.createRole(uid, serverId, roleName);
+  }
+  
+  public async getrolelist() {
+    const { ctx } = this;
+    const { field, value } = ctx.request.body;
+    ctx.body = await ctx.service.users.getrolelist(field, value);
+  }
+
+  public async createRoleData() {
+    const { ctx } = this;
+    console.log(ctx.request.body)
+    const { hid, hlv, eid, elv, ecount, ehid, itemid, itemcount, selectedRowKeys: uids, optType } = ctx.request.body;
+    if(optType == 'hero') {
+      ctx.body = await ctx.service.users.createHero(uids, hid, hlv);
+    } else if(optType == 'equip') {
+      ctx.body = await ctx.service.users.createEquip(uids, eid, elv, ecount, ehid);
+    } else if (optType == 'item') {
+      ctx.body = await ctx.service.users.createItem(uids, itemid, itemcount);
+    } else {
+      ctx.body = {
+        status: 'error',
+        data: '参数错误'
+      }
+    }
+  }
+}

gm-server/app/db

@@ -0,0 +1 @@
+../../shared/db

gm-server/app/middleware/tokenParser.ts

@@ -0,0 +1,27 @@
+import { GMUserModel } from '@db/GMUser';
+
+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 = {
+        "status": "error",
+        "data": "账号未登录"
+      };
+      return;
+    }
+    const user = await GMUserModel.getGmAccountByToken(ctx.request.headers.token);
+    if (!user) {
+      console.error('token invalid');
+      ctx.body = {
+        "status": "error",
+        "data": "账号未登录"
+      };
+      return;
+    }
+    ctx.user = user;
+    await next();
+  };
+};
+

gm-server/app/resource

@@ -0,0 +1 @@
+../../shared/resource

gm-server/app/router.ts

@@ -0,0 +1,17 @@
+import { Application } from 'egg';
+
+export default (app: Application) => {
+  const { controller, router } = app;
+  const tokenParser = app.middleware.tokenParser();
+
+  router.get('/', controller.home.index);
+  router.post('/api/login/account', controller.login.login);
+  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);
+
+  
+};

gm-server/app/service/GmUser.ts

@@ -0,0 +1,50 @@
+import { GMUserModel } from '@db/GMUser';
+import { Service } from 'egg';
+
+/**
+ * Test Service
+ */
+export default class GMUsers extends Service {
+
+  /**
+   * 后台账号登录
+   */
+  public async login(username: string, password: string) {
+    // const {ctx} = this;
+    let user = await GMUserModel.login(username, password);
+
+    if(user) {
+      return {
+        "status": "ok",
+        "data": user
+      }
+    } else {
+      return {
+        "status": "error",
+        "data": "账号或密码错误"
+      }
+    }
+  }
+
+  /**
+   * 创建后台账号
+   */
+  public async createGmAccount(name: string, username: string, password: string, group: string) {
+    const {ctx} = this;
+    let token = ctx.service.utils.genCode(256);
+
+    let user = await GMUserModel.getGmAccountByUsername(username);
+    if(user) {
+      return {
+        "status": "error",
+        "data": "该账号已使用"
+      }
+    } else {
+      user = await GMUserModel.createGmAccount(username, password, name, token, group);
+      return {
+        "status": "ok",
+        "data": user
+      };
+    }
+  }
+}

gm-server/app/service/Test.ts

@@ -0,0 +1,15 @@
+import { Service } from 'egg';
+
+/**
+ * Test Service
+ */
+export default class Test extends Service {
+
+  /**
+   * sayHi to you
+   * @param name - your name
+   */
+  public async sayHi(name: string) {
+    return `hi, ${name}`;
+  }
+}

gm-server/app/service/Utils.ts

@@ -0,0 +1,94 @@
+import { Service } from 'egg';
+const csprng = require('csprng');
+const fs = require('fs');
+const path = require('path');
+
+var gamedata = {};
+
+function initData () {
+    fs.readdirSync(__dirname + '/../resource')
+    .filter(function(file) {
+        return (file.indexOf(".") !== 0) && (file !== "index.js");
+    })
+    //筛选有文件名且不是index进行遍历
+    .forEach(function(file) {
+        var name = file.split('.')[0];
+        try {
+            gamedata[name] = JSON.parse(
+                fs.readFileSync(path.resolve(__dirname, "../resource/" + file))
+            );
+        } catch(e) {
+            console.error('【文件缺少】：' + file);
+            gamedata[name] = [];
+        }
+
+    });
+}
+initData();
+
+/**
+ * Utils Service
+ */
+export default class Utils extends Service {
+  /**
+   * 生成 len 长度的随机字符串
+   * @param len 长度
+   * @param radix 基数
+   */
+  public generateStr(len: number, radix = 36) {
+    return `${csprng(len, radix)}`;
+  }
+
+  public genCode(len) {
+    const chars = '123456789ABCDEFGHJKLMNPQRSTWXYZabcdefghijklmnopqrstuvwxyz';
+    const charArr = chars.split('');
+    let code = '';
+    for (let i = 0; i < len; i++) {
+      code += charArr[Math.floor(Math.random() * charArr.length)];
+    }
+    return code;
+  }
+
+  /**
+   * 生成指定长度的随机数
+   * @param len 随机数长度
+   */
+  public generateNum(len: number) {
+    let code = '';
+    for (let i = 0; i < len; i++) {
+      code += parseInt(`${Math.random() * 10}`);
+    }
+    return code;
+  }
+
+  public exceptionResult(status) {
+    const { code, simStr } = status;
+    return { status: code, data: simStr };
+  }
+
+  public getGamedata(key) {
+    return gamedata[key];
+  }
+
+  public getHeroById(hid) {
+    let heros = gamedata['dic_zyz_hero']||[];
+    return heros.find(cur => {
+        return cur.heroId == hid;
+    });
+  }
+  public getWarById(warid) {
+    let warInfo = gamedata['dic_zyz_gk']||[];
+    return warInfo.find(cur => {
+        return cur.war_id == warid
+    });
+  }
+
+  public getGoodById(gid) {
+    console.log(gid)
+    let goodsInfo = gamedata['goods']||[];
+    return goodsInfo.find(cur => {
+        return cur.good_id == gid
+    });
+  }
+
+}

gm-server/app/service/users.ts

@@ -0,0 +1,285 @@
+import { UserModel } from '@db/User';
+import { RoleModel } from '@db/Role';
+import { HeroModel } from '@db/Hero';
+import { EquipModel } from '@db/Equip';
+import { ItemModel } from '@db/Item';
+import { CounterModel } from '@db/Counter';
+
+import { Service } from 'egg';
+import Counter from '@db/Counter';
+
+/**
+ * Test Service
+ */
+export default class GMUsers extends Service {
+
+  /**
+   * 根据类型等搜索玩家
+   */
+  public async getuserlist(field, value) {
+    // const {ctx} = this;
+
+    let arr = new Array(), flag = 0;
+    value = value.split(',');
+    for(let i of value) {
+        if(field == 'uid') {
+            let d = parseInt(i);
+            if(isNaN(d)) {
+                flag = 1; break;
+            } else {
+                arr.push(d);
+            }
+        } else if(field == 'username'||field == 'tel') {
+            arr.push(i);
+        } else if (field == 'all') {
+            break;
+        } else {
+            flag = 1; break;
+        }
+    }
+    
+    if(flag) {
+        return {
+            "status": "error",
+            "data": "参数错误"
+        }
+    }
+
+    let users = await UserModel.findUserByField(field, value);
+
+    if(users) {
+        let list = new Array();
+        for(let user of users) {
+            let role = await RoleModel.findByUid(user.uid, 1);
+            list.push({...user, hasRole: role?true: false, role});
+        }
+
+      return {
+        "status": "ok",
+        "data": list
+      }
+    } else {
+      return {
+        "status": "error",
+        "data": "未找到玩家"
+      }
+    }
+  }
+
+  public async createRole(uid:number, serverId: number, roleName: string) {
+    console.log('enter Auth createRole');
+    const ctx = this.ctx;
+
+    const roleId = ctx.service.utils.genCode(10);
+    const code = ctx.service.utils.genCode(6);
+    const seqId = await Counter.getNewCounter('role') || -1;
+    const role = await RoleModel.createRole(uid, serverId, { roleId, code, roleName, seqId });
+    if (role) {
+      return { status: "ok", data: { roleId: role.roleId } };
+    }
+    return {
+        "status": "error",
+        "data": "创建失败"
+    };
+  }
+
+
+  /**
+   * 根据类型等搜索玩家
+   */
+  public async getrolelist(field, value) {
+    // const {ctx} = this;
+
+    let arr = new Array(), flag = 0;
+    value = value.split(',');
+    for(let i of value) {
+        if(field == 'uid') {
+            let d = parseInt(i);
+            if(isNaN(d)) {
+                flag = 1; break;
+            } else {
+                arr.push(d);
+            }
+            field = 'userInfo.uid';
+        } else if(field == 'roleName') {
+            arr.push(i);
+        } else if (field == 'tel') {
+            arr.push(i);
+            field = 'userInfo.tel';
+        } else if (field == 'all') {
+            break;
+        } else {
+            flag = 1; break;
+        }
+    }
+    
+    if(flag) {
+        return {
+            "status": "error",
+            "data": "参数错误"
+        }
+    }
+
+    let roles = await RoleModel.findRoleByField(field, value);
+
+    if(roles) {
+
+        let result = new Array();
+        for(let role of roles) {
+            let heroCount = await HeroModel.count({roleId: role.roleId}).lean();
+            let equipCount = await EquipModel.count({roleId: role.roleId}).lean();
+            let itemCount = await ItemModel.count({roleId: role.roleId}).lean();
+            let {roleId, roleName, serverId, lv, vLv} = role;
+            let {uid, tel} = role.userInfo;
+            result.push({
+                key: roleId, roleId, roleName, serverId, lv, vLv, uid, tel, heroCount, equipCount, itemCount
+            });
+        }
+        return {
+            "status": "ok",
+            "data": result
+        }
+    } else {
+      return {
+        "status": "error",
+        "data": "未找到玩家"
+      }
+    }
+  }
+
+  public async createHero(uids: Array<string>, hid: number, hlv: number) {
+    const {ctx} = this;
+    console.log('gm createHero', uids, hid, hlv);
+
+    let flag = 0, msg = '创建失败';
+    for(let roleId of uids) {
+        let role = await RoleModel.findByRoleId(roleId);
+        if(role) {
+            let hero = await HeroModel.findByHidAndRole(hid, roleId);
+            if(hero) {
+                flag = 1, msg = "角色" + roleId + "已拥有武将" + hid;
+                break;
+            }
+            const seqId = await CounterModel.getNewCounter('hid')||-1;
+            let dicHero = ctx.service.utils.getHeroById(hid);
+            if(!dicHero) {
+                flag = 1, msg = "未找到武将" + hid;
+                break;
+            }
+
+            const heroInfo = {
+                roleId,
+                roleName: role.roleName,
+                hid: hid,
+                hName: dicHero.name,
+                seqId,
+                lv: hlv
+            }
+            await HeroModel.createHero(heroInfo);
+        } else {
+            flag = 1, msg = '未找到角色' + roleId;
+        }
+    }
+
+    if (flag) {
+        return {
+            "status": "error",
+            "data": msg
+        }
+    } else {
+        return {
+            "status": "ok",
+            "data": uids
+        };
+    }
+  }
+
+  public async createEquip(uids: Array<string>, eid: number, elv: number, ecount: number, ehid: number) {
+    const {ctx} = this;
+    console.log('gm createEquip');
+
+    let flag = 0, msg = '创建失败';
+    for(let roleId of uids) {
+        let role = await RoleModel.findByRoleId(roleId);
+        if(role) {
+            for(let i = 0; i <ecount; i++) {
+
+                let dicEquip = ctx.service.utils.getGoodById(eid);
+                if(!dicEquip) {
+                    flag = 1, msg = "未找到装备" + eid;
+                    break;
+                }
+                const seqId = await CounterModel.getNewCounter('eid')||-1;
+                const equipInfo = {
+                    roleId,
+                    roleName: role.roleName,
+                    eid,
+                    eName: dicEquip.name,
+                    seqId,
+                    type: 1,
+                    lv: elv
+                }
+                const equip = await EquipModel.createEquip(equipInfo);
+                if(ehid > 0 && equip) {
+                    await HeroModel.addEquip(roleId, ehid, equip._id);
+                }
+            }
+        } else {
+            flag = 1, msg = '未找到角色' + roleId;
+        }
+    }
+
+    if (flag) {
+        return {
+            "status": "error",
+            "data": msg
+        }
+    } else {
+        return {
+            "status": "ok",
+            "data": uids
+        };
+    }
+  }
+
+  public async createItem(uids: Array<string>, itemid: number, itemcount: number) {
+    console.log('gm createEquip');
+
+    let flag = 0;
+    for(let roleId of uids) {
+        let role = await RoleModel.findByRoleId(roleId);
+        if(role) {
+            let item = await ItemModel.findbyItemid(itemid, roleId);
+            if(item) {
+                await ItemModel.changeItemCount(item.seqId, itemcount);
+            } else {
+                const seqId = await CounterModel.getNewCounter('itemid')||-1;
+                const itemInfo = {
+                    roleId,
+                    roleName: role.roleName,
+                    itemid,
+                    itemName: '包子',
+                    seqId,
+                    type: 1,
+                    count: itemcount
+                }
+                await ItemModel.createItem(itemInfo);
+            }
+        } else {
+            flag = 1;
+        }
+    }
+
+    if (flag) {
+        return {
+            "status": "error",
+            "data": "创建失败"
+        }
+    } else {
+        return {
+            "status": "ok",
+            "data": uids
+        };
+    }
+  }
+}