409 lines
14 KiB
TypeScript
409 lines
14 KiB
TypeScript
import { UserModel } from '@db/User';
|
|
import { RoleModel } from '@db/Role';
|
|
import Hero, { HeroModel } from '@db/Hero';
|
|
import { EquipModel } from '@db/Equip';
|
|
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, HERO_SYSTEM_TYPE } from '@consts';
|
|
import { ITID, COUNTER } from '@consts';
|
|
import Actor from '@pubUtils/actor';
|
|
import { ItemModel } from '@db/Item';
|
|
import { gameData } from '@pubUtils/data';
|
|
import { calPlayerCeAndSave } from '@pubUtils/playerCe';
|
|
|
|
/**
|
|
* 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(COUNTER.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 = await ItemModel.count({roleId: role.roleId}).lean();
|
|
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 hlv = parseInt(_hlv);
|
|
if( isNaN(hlv)) return ctx.service.utils.resResult(STATUS.WRONG_PARMS);
|
|
let hids = (_hid as string).split('&').map(cur => parseInt(cur));
|
|
for(let hid of hids) {
|
|
if(isNaN(hid)) return ctx.service.utils.resResult(STATUS.WRONG_PARMS);
|
|
}
|
|
|
|
let heroInfos = new Array();
|
|
for(let roleId of uids) {
|
|
let role = await RoleModel.findByRoleId(roleId);
|
|
if(role) {
|
|
for(let hid of hids) {
|
|
let hero = await HeroModel.findByHidAndRole(hid, roleId);
|
|
if(hero) continue;
|
|
let dicHero = ctx.service.utils.getHeroById(hid);
|
|
if(!dicHero) continue;
|
|
let {quality, initialStars: star, jobid: job, name: hName, initialSkin} = dicHero;
|
|
const heroInfo = {
|
|
roleId, roleName: role.roleName, hid, hName, star, quality, job, serverId: role.serverId,
|
|
lv: hlv,
|
|
skins:[{id: initialSkin, enable: true}],
|
|
}
|
|
heroInfos.push(heroInfo);
|
|
}
|
|
} else {
|
|
return ctx.service.utils.resResult(STATUS.GM_CREATE_ERROR, null, '未找到角色' + roleId)
|
|
}
|
|
}
|
|
|
|
try {
|
|
for(let heroInfo of heroInfos) {
|
|
let hero = await HeroModel.createHero(heroInfo);
|
|
await calPlayerCeAndSave(heroInfo.roleId, [hero], HERO_SYSTEM_TYPE.INIT);
|
|
}
|
|
return ctx.service.utils.resResult(STATUS.SUCCESS, { uids });
|
|
} catch(e) {
|
|
console.error(e.stack)
|
|
}
|
|
}
|
|
|
|
public async createEquip(uids: Array<string>, _eid: string, _ecount: string, _ehid: string) {
|
|
const {ctx} = this;
|
|
console.log('gm createEquip', uids, _eid, _ecount, _ehid);
|
|
let eid = parseInt(_eid);
|
|
let ecount = parseInt(_ecount);
|
|
let ehid = parseInt(_ehid);
|
|
if(isNaN(eid) || 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 = gameData.goods.get(eid);
|
|
if(!dicEquip) {
|
|
flag = 1, msg = "未找到装备" + eid;
|
|
break;
|
|
}
|
|
await ctx.service.utils.addEquips(roleId, role.roleName, {id: eid, ...dicEquip, hid: ehid});
|
|
}
|
|
} 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 = gameData.goods.get(itemid);
|
|
let itidObj = ITID.get(dicGoods.itid);
|
|
|
|
let flag = 0, msg = '创建失败';
|
|
if(!dicGoods) {
|
|
flag = 1, msg = "未找到道具" + itemid;
|
|
} else if(!itidObj){
|
|
flag = 1, msg = "未找到道具" + itemid;
|
|
} else {
|
|
for(let roleId of uids) {
|
|
let role = await RoleModel.findByRoleId(roleId);
|
|
if(role) {
|
|
await ctx.service.utils.addBags(roleId, role.roleName, {id: itemid, itemName: dicGoods.name, count: itemcount, type: itidObj.type, hid: 0});
|
|
} 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 addGold(uids: Array<string>, _count: string) {
|
|
const {ctx} = this;
|
|
console.log('gm addGold', uids, _count);
|
|
let count = parseInt(_count);
|
|
if(isNaN(count)) return ctx.service.utils.resResult(STATUS.WRONG_PARMS);
|
|
for(let roleId of uids) {
|
|
await RoleModel.addGoldFree(roleId, count);
|
|
}
|
|
|
|
return ctx.service.utils.resResult(STATUS.SUCCESS, { uids });
|
|
}
|
|
|
|
public async addSkins(uids: Array<string>, _id: string) {
|
|
const {ctx} = this;
|
|
console.log('gm addSkin', uids, _id);
|
|
let id = parseInt(_id);
|
|
if(isNaN(id)) return ctx.service.utils.resResult(STATUS.WRONG_PARMS);
|
|
for(let roleId of uids) {
|
|
await ctx.service.utils.addSkins(roleId, id);
|
|
}
|
|
|
|
return ctx.service.utils.resResult(STATUS.SUCCESS, { uids });
|
|
}
|
|
|
|
public async levelUp(uids: Array<string>, _lv: string) {
|
|
const {ctx} = this;
|
|
console.log('gm levelUp', uids, _lv);
|
|
let lv = parseInt(_lv);
|
|
if(isNaN(lv)) return ctx.service.utils.resResult(STATUS.WRONG_PARMS);
|
|
for(let roleId of uids) {
|
|
let exp = ctx.service.utils.getExpByLv(lv);
|
|
await RoleModel.levelup(roleId, lv, exp?exp.sum:0);
|
|
}
|
|
|
|
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 actor = new Actor();
|
|
actor.initHero(hero);
|
|
let ce = actor.calculateCE();
|
|
let attribute = actor.getAttributeJson();
|
|
let heroInfo = {
|
|
actorId: dicHero.heroId,
|
|
actorName: dicHero.name,
|
|
attribute, 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
|
|
});
|
|
}
|
|
}
|