312 lines
10 KiB
TypeScript
312 lines
10 KiB
TypeScript
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 { 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 { HeroSoulModel } from '@db/HeroSoul';
|
|
import { ScriptItemModel } from '@db/ScriptItem';
|
|
import { SearchRecordModel } from '@db/SearchRecord';
|
|
import { TowerRecordModel } from '@db/TowerRecord';
|
|
import { TowerTaskRecModel } from '@db/TowerTaskRec';
|
|
|
|
import { Service } from 'egg';
|
|
import Counter from '@db/Counter';
|
|
import { STATUS } from '@consts/statusCode';
|
|
|
|
/**
|
|
* 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 HeroSoulModel.deleteAccount(roleId);
|
|
await ItemModel.deleteAccount(roleId);
|
|
await RoleModel.deleteAccount(roleId);
|
|
await ScriptItemModel.deleteAccount(roleId);
|
|
await SearchRecordModel.deleteAccount(roleId);
|
|
await TowerTaskRecModel.deleteAccount(roleId);
|
|
await TowerRecordModel.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 {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 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,
|
|
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 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);
|
|
|
|
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 ctx.service.utils.resResult(STATUS.GM_CREATE_ERROR);
|
|
} else {
|
|
return ctx.service.utils.resResult(STATUS.SUCCESS, { uids });
|
|
}
|
|
}
|
|
}
|