393 lines
13 KiB
TypeScript
393 lines
13 KiB
TypeScript
import { UserModel } from '@db/User';
|
|
import { RoleModel } from '@db/Role';
|
|
import Hero, { HeroModel } from '@db/Hero';
|
|
import { EquipModel } from '@db/Equip';
|
|
import { CounterModel } from '@db/Counter';
|
|
import { ActionPointModel } from '@db/ActionPoint';
|
|
import { BattleDropModel } from '@db/BattleDrop';
|
|
import { BattleRecordModel } from '@db/BattleRecord';
|
|
import { BattleSweepRecordModel } from '@db/BattleSweepRecord';
|
|
import { DailyRecordModel } from '@db/DailyRecord';
|
|
import { EventRecordModel } from '@db/EventRecord';
|
|
import { ExpeditionPointModel } from '@db/ExpeditionPoint';
|
|
import { ExpeditionRecordModel } from '@db/ExpeditionRecord';
|
|
import { ExpeditionWarRecordModel } from '@db/ExpeditionWarRecord';
|
|
import { HangUpRecordModel } from '@db/HangUpRecord';
|
|
import { HangUpSpdUpRecModel } from '@db/HangUpSpdUpRec';
|
|
import { SearchRecordModel } from '@db/SearchRecord';
|
|
import { TowerRecordModel } from '@db/TowerRecord';
|
|
import { TowerTaskRecModel } from '@db/TowerTaskRec';
|
|
import { PvpDefenseModel } from '@db/PvpDefense';
|
|
|
|
import { Service } from 'egg';
|
|
import Counter from '@db/Counter';
|
|
import { STATUS } from '@consts/statusCode';
|
|
import { getGoodById } from '@pubUtils/gamedata';
|
|
import { ITID } from '@consts/consts';
|
|
|
|
/**
|
|
* 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 ctx.service.utils.resResult(STATUS.WRONG_PARMS);
|
|
}
|
|
|
|
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 ctx.service.utils.resResult(STATUS.SUCCESS, {list})
|
|
} else {
|
|
console.error('userlist not found');
|
|
return ctx.service.utils.resResult(STATUS.INTERNAL_ERR);
|
|
}
|
|
}
|
|
|
|
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 ctx.service.utils.resResult(STATUS.SUCCESS);
|
|
} else {
|
|
console.error('create role error');
|
|
return ctx.service.utils.resResult(STATUS.INTERNAL_ERR);
|
|
}
|
|
}
|
|
|
|
public async deleteRole(roleId: string) {
|
|
console.log('enter Auth deleteRole');
|
|
const ctx = this.ctx;
|
|
await ActionPointModel.deleteAccount(roleId);
|
|
await BattleDropModel.deleteAccount(roleId);
|
|
await BattleRecordModel.deleteAccount(roleId);
|
|
await BattleSweepRecordModel.deleteAccount(roleId);
|
|
await DailyRecordModel.deleteAccount(roleId);
|
|
await EquipModel.deleteAccount(roleId);
|
|
await EventRecordModel.deleteAccount(roleId);
|
|
await ExpeditionPointModel.deleteAccount(roleId);
|
|
await ExpeditionRecordModel.deleteAccount(roleId);
|
|
await ExpeditionWarRecordModel.deleteAccount(roleId);
|
|
await HangUpSpdUpRecModel.deleteAccount(roleId);
|
|
await HangUpRecordModel.deleteAccount(roleId);
|
|
await HeroModel.deleteAccount(roleId);
|
|
await RoleModel.deleteAccount(roleId);
|
|
await SearchRecordModel.deleteAccount(roleId);
|
|
await TowerTaskRecModel.deleteAccount(roleId);
|
|
await TowerRecordModel.deleteAccount(roleId);
|
|
await PvpDefenseModel.deleteAccount(roleId);
|
|
|
|
return ctx.service.utils.resResult(STATUS.SUCCESS);
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* 根据类型等搜索玩家
|
|
*/
|
|
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 ctx.service.utils.resResult(STATUS.WRONG_PARMS);
|
|
}
|
|
|
|
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 = (role.consumeGoods?role.consumeGoods.length: 0) + (role.souls?role.souls.length:0);
|
|
let defense = await PvpDefenseModel.findByRoleId(role.roleId);
|
|
|
|
let {roleId, roleName, serverId, lv, vLv, gold, coin} = role;
|
|
let {uid, tel} = role.userInfo;
|
|
result.push({
|
|
key: roleId, roleId, roleName, serverId, lv, vLv, uid, tel, heroCount, equipCount, itemCount, gold, coin,
|
|
hasDefense: defense?'是':'否', defCe: defense?defense.ce:0
|
|
});
|
|
}
|
|
return ctx.service.utils.resResult(STATUS.SUCCESS, { list: result });
|
|
} else {
|
|
console.error('role list not found');
|
|
return ctx.service.utils.resResult(STATUS.INTERNAL_ERR);
|
|
}
|
|
}
|
|
|
|
public async createHero(uids: Array<string>, _hid: string, _hlv: string) {
|
|
const {ctx} = this;
|
|
console.log('gm createHero', uids, _hid, _hlv);
|
|
let hid = parseInt(_hid);
|
|
let hlv = parseInt(_hlv);
|
|
if(isNaN(hid) || isNaN(hlv)) return ctx.service.utils.resResult(STATUS.WRONG_PARMS);
|
|
|
|
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;
|
|
}
|
|
let ce = ctx.service.utils.calculateCE({hid: hid, lv: hlv});
|
|
|
|
const heroInfo = {
|
|
roleId,
|
|
roleName: role.roleName,
|
|
hid: hid,
|
|
hName: dicHero.name,
|
|
seqId,
|
|
lv: hlv,
|
|
ce
|
|
}
|
|
await HeroModel.createHero(heroInfo);
|
|
} else {
|
|
flag = 1, msg = '未找到角色' + roleId;
|
|
}
|
|
}
|
|
|
|
if (flag) {
|
|
return ctx.service.utils.resResult(STATUS.GM_CREATE_ERROR, null, msg);
|
|
} else {
|
|
return ctx.service.utils.resResult(STATUS.SUCCESS, { uids });
|
|
}
|
|
}
|
|
|
|
public async createEquip(uids: Array<string>, _eid: string, _elv: string, _ecount: string, _ehid: string) {
|
|
const {ctx} = this;
|
|
console.log('gm createEquip', uids, _eid, _elv, _ecount, _ehid);
|
|
let eid = parseInt(_eid);
|
|
let elv = parseInt(_elv);
|
|
let ecount = parseInt(_ecount);
|
|
let ehid = parseInt(_ehid);
|
|
if(isNaN(eid) || isNaN(elv) || isNaN(ecount) || isNaN(ehid)) return ctx.service.utils.resResult(STATUS.WRONG_PARMS);
|
|
|
|
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,
|
|
id: eid,
|
|
name: 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 ctx.service.utils.resResult(STATUS.GM_CREATE_ERROR, null, msg);
|
|
} else {
|
|
return ctx.service.utils.resResult(STATUS.SUCCESS, { uids });
|
|
}
|
|
}
|
|
|
|
public async createItem(uids: Array<string>, _itemid: string, _itemcount: string) {
|
|
const {ctx} = this;
|
|
console.log('gm createItem', uids, _itemid, _itemcount);
|
|
let itemid = parseInt(_itemid);
|
|
let itemcount = parseInt(_itemcount);
|
|
if(isNaN(itemid) || isNaN(itemcount)) return ctx.service.utils.resResult(STATUS.WRONG_PARMS);
|
|
let dicGoods = getGoodById(itemid);
|
|
let itidObj = ITID.get(dicGoods.itid);
|
|
|
|
let flag = 0;
|
|
for(let roleId of uids) {
|
|
await RoleModel.addItems(roleId, itidObj?itidObj.field||'':'', itemid, itemcount);
|
|
}
|
|
|
|
if (flag) {
|
|
return ctx.service.utils.resResult(STATUS.GM_CREATE_ERROR);
|
|
} else {
|
|
return ctx.service.utils.resResult(STATUS.SUCCESS, { uids });
|
|
}
|
|
}
|
|
|
|
public async getPvpDefense(roleId: string) {
|
|
const {ctx} = this;
|
|
let result = await PvpDefenseModel.findByRoleId(roleId);
|
|
return ctx.service.utils.resResult(STATUS.SUCCESS, {
|
|
hasDefense: !!result, defense: result
|
|
})
|
|
}
|
|
|
|
public async getHeroList(roleId: string) {
|
|
const {ctx} = this;
|
|
let herolist = await HeroModel.findByRole(roleId);
|
|
let defense = await PvpDefenseModel.findByRoleId(roleId);
|
|
|
|
let result = Array<Hero>();
|
|
for(let hero of herolist) {
|
|
if(defense) {
|
|
let {heroes = []} = defense;
|
|
let curHero = heroes.find(cur => cur.actorId == hero.hid);
|
|
if(!curHero) {
|
|
result.push(hero);
|
|
}
|
|
} else{
|
|
result.push(hero);
|
|
}
|
|
}
|
|
|
|
return ctx.service.utils.resResult(STATUS.SUCCESS, {
|
|
heroes: result
|
|
})
|
|
}
|
|
|
|
public async saveHeroToDefense(roleId: string, roleName: string, hid: number) {
|
|
const {ctx} = this;
|
|
let hero = await HeroModel.findByHidAndRole(hid, roleId);
|
|
if(!hero) {
|
|
return ctx.service.utils.resResult(STATUS.GM_HERO_NOT_FOUND);
|
|
}
|
|
let { lv } = hero;
|
|
|
|
let dicHero = ctx.service.utils.getHeroById(hid);
|
|
let { hp, hp_up, atk, atk_up, matk, matk_up, def, def_up, mdef, mdef_up } = dicHero;
|
|
|
|
let ce = ctx.service.utils.calculateCE({hid, lv});
|
|
let heroInfo = {
|
|
actorId: dicHero.heroId,
|
|
actorName: dicHero.name,
|
|
attribute: {
|
|
hp: hp + lv * hp_up,
|
|
atk: atk + lv * atk_up,
|
|
matk: matk + lv * matk_up,
|
|
def: def + lv * def_up,
|
|
mdef: mdef + lv * mdef_up,
|
|
agi: 0,
|
|
luk: 0,
|
|
speed: 0,
|
|
hit: 0,
|
|
cri: 0,
|
|
flee: 0,
|
|
antCri: 0,
|
|
damageIncrease: 0,
|
|
damageDecrease: 0,
|
|
defIgnore: 0,
|
|
bloodSuck: 0,
|
|
ap: 0
|
|
},
|
|
lv,
|
|
ce
|
|
};
|
|
|
|
let defense = await PvpDefenseModel.findByRoleId(roleId);
|
|
if(!defense) {
|
|
defense = await PvpDefenseModel.createPvpDefense({roleId, roleName, heroes: [heroInfo], ce});
|
|
} else {
|
|
defense = await PvpDefenseModel.addHeroToDefense(roleId, heroInfo, ce);
|
|
}
|
|
return ctx.service.utils.resResult(STATUS.SUCCESS, {
|
|
defense
|
|
});
|
|
}
|
|
|
|
|
|
public async removeHeroFromDefense(roleId: string, hid: number) {
|
|
const {ctx} = this;
|
|
|
|
let defense = await PvpDefenseModel.findByRoleId(roleId);
|
|
if(!defense) {
|
|
return ctx.service.utils.resResult(STATUS.GM_PVP_DEFENSE_NOT_FOUND);
|
|
}
|
|
let {heroes} = defense;
|
|
let curHero = heroes.find(cur => cur.actorId == hid);
|
|
if(!curHero) {
|
|
return ctx.service.utils.resResult(STATUS.GM_PVP_DEFENSE_HERO_NOT_FOUND);
|
|
}
|
|
defense = await PvpDefenseModel.removeHeroFromDefense(roleId, hid, curHero.ce);
|
|
|
|
return ctx.service.utils.resResult(STATUS.SUCCESS, {
|
|
defense
|
|
});
|
|
}
|
|
}
|