1009 lines
41 KiB
TypeScript
1009 lines
41 KiB
TypeScript
import { UserModel } from '@db/User';
|
|
import { CeAttrDataRole, RoleModel } from '@db/Role';
|
|
import { 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 { ItemModel } from '@db/Item';
|
|
import { gameData, getExpByLv } from '@pubUtils/data';
|
|
import { calPlayerCeAndSave, calculatetopLineup, calEquipSeids } from '@pubUtils/playerCe';
|
|
import { SchoolModel } from '@db/School';
|
|
import { AttributeCal } from '@domain/roleField/attribute';
|
|
import { smsModel } from '@db/Sms';
|
|
import { isString } from 'underscore';
|
|
import { FriendShipModel } from '@db/FriendShip';
|
|
import { FriendApplyModel } from '@db/FriendApply';
|
|
import { FriendRelationModel } from '@db/FriendRelation';
|
|
import { addSkin, addEquips, addBags } from '@pubUtils/itemUtils';
|
|
import { GiftCodeModel } from '@db/GiftCode';
|
|
import { GiftCodeDetailModel } from '@db/GiftCodeDetail';
|
|
import { CreateHeroes } from '@pubUtils/roleUtil';
|
|
import { ActivityBuyRecordsModel } from '@db/ActivityBuyRecords';
|
|
import { ActivityDailyChallengesModel } from '@db/ActivityDailyChallenges';
|
|
import { ActivityDailyCoinModel } from '@db/ActivityDailyCoin';
|
|
import { ActivityDailyGiftsModel } from '@db/ActivityDailyGifts';
|
|
import { ActivityDailyGKModel } from '@db/ActivityDailyGK';
|
|
import { ActivityDailyMealModel } from '@db/ActivityDailyMeal';
|
|
import { ActivityDailyRMBGiftsModel } from '@db/ActivityDailyRMBGifts';
|
|
import { ActivityFirstGiftModel } from '@db/ActivityFirstGift';
|
|
import { ActivityGrowthFundModel } from '@db/ActivityGrowthFund';
|
|
import { ActivityGrowthModel } from '@db/ActivityGrowth';
|
|
import { ActivityGrowthPointModel } from '@db/ActivityGrowthPoint';
|
|
import { ActivityMonopolyModel } from '@db/ActivityMonopoly';
|
|
import { ActivityMonopolyLandModel } from '@db/ActivityMonopolyLand';
|
|
import { ActivityMonthlyTicketModel } from '@db/ActivityMonthlyTicket';
|
|
import { ActivityNewHeroGachaModel } from '@db/ActivityNewHeroGacha';
|
|
import { ActivityNewHeroGiftModel } from '@db/ActivityNewHeroGift';
|
|
import { ActivityNewHeroGKModel } from '@db/ActivityNewHeroGK';
|
|
import { ActivityPopUpShopModel } from '@db/ActivityPopUpShop';
|
|
import { ActivityPopUpShopRecordModel } from '@db/ActivityPopUpShopRecord';
|
|
import { ActivityRechargeMoneyModel } from '@db/ActivityRechargeMoney';
|
|
import { ActivityRefreshShopModel } from '@db/ActivityRefreshShop';
|
|
import { ActivityRefreshTaskModel } from '@db/ActivityRefreshTask';
|
|
import { ActivityRefreshTaskPointModel } from '@db/ActivityRefreshTaskPoint';
|
|
import { ActivitySelfServiceGoodsModel } from '@db/ActivitySelfServiceGoods';
|
|
import { ActivitySelfServiceModel } from '@db/ActivitySelfService';
|
|
import { ActivitySelfServiceShopModel } from '@db/ActivitySelfServiceShop';
|
|
import { ActivityShopModel } from '@db/ActivityShop';
|
|
import { ActivitySignInModel } from '@db/ActivitySignIn';
|
|
import { ActivityTaskPointModel } from '@db/ActivityTaskPoint';
|
|
import { ActivityThirtyDaysModel } from '@db/ActivityThirtyDays';
|
|
import { ActivityThirtyDaysPointRewardModel } from '@db/ActivityThirtyDaysPointReward';
|
|
import { ActivityTreasureHuntFirstPageModel } from '@db/ActivityTreasureHuntFirstPage';
|
|
import { ActivityTreasureHuntShopModel } from '@db/ActivityTreasureHuntShop';
|
|
import { ActivityTreasureHuntTaskModel } from '@db/ActivityTreasureHuntTask';
|
|
import { ActivityTreasureHuntTreasureShopModel } from '@db/ActivityTreasureHuntTreasureShop';
|
|
import { ActivityVipRechargeMoneyModel } from '@db/ActivityVipRechargeMoney';
|
|
import { BattleBlueprtDropModel } from '@db/BattleBlueprtDrop';
|
|
import { ChatInfoModel } from '@db/ChatInfo';
|
|
import { DungeonFirstModel } from '@db/DungeonFirst';
|
|
import { EquipPrintDropModel } from '@db/EquipPrintDrop';
|
|
import { FriendPointModel } from '@db/FriendPoint';
|
|
import { FriendPresentLogModel } from '@db/FriendPresentLog';
|
|
import { GroupMailModel } from '@db/GroupMail';
|
|
import { GuildModel } from '@db/Guild';
|
|
import { UserGuildModel } from '@db/UserGuild';
|
|
import { UserGuildApplyModel } from '@db/UserGuildApply';
|
|
import { GuildRecModel } from '@db/GuildRec';
|
|
import { MailModel } from '@db/Mail';
|
|
import { MessageModel } from '@db/Message';
|
|
import { PrivateMessageModel } from '@db/PrivateMessage';
|
|
import { RScriptRecordModel } from '@db/RScriptRecord';
|
|
import { ScriptBarrageModel } from '@db/ScriptBarrage';
|
|
import { ServerMailModel } from '@db/ServerMail';
|
|
import { SkinModel } from '@db/Skin';
|
|
import { UserGachaModel } from '@db/UserGacha';
|
|
import { UserGachaRecModel } from '@db/UserGachaRec';
|
|
import { UserGiftCodeModel } from '@db/UserGiftCode';
|
|
import { UserGuildActivityRecModel } from '@db/UserGuildActivityRec';
|
|
import { UserOrderModel } from '@db/UserOrder';
|
|
import { UserShopModel } from '@db/UserShop';
|
|
import { UserTaskModel } from '@db/UserTask';
|
|
import { UserTaskHistoryModel } from '@db/UserTaskHistory';
|
|
import { UserTaskRecModel } from '@db/UserTaskRec';
|
|
import { WishPoolReportModel } from '@db/WishPoolReport';
|
|
import { DicWar } from '@pubUtils/dictionary/DicWar';
|
|
|
|
// import { resResult } from '@pubUtils/util';
|
|
|
|
// import * as fs from 'fs';
|
|
|
|
/**
|
|
* Test Service
|
|
*/
|
|
export default class GMUsers extends Service {
|
|
|
|
/**
|
|
* 根据类型等搜索玩家
|
|
*/
|
|
public async getuserlist(field: string = 'all', value: string = '') {
|
|
const { ctx } = this;
|
|
|
|
let arr = new Array(), flag = 0;
|
|
if (value == '') field = 'all';
|
|
let valueArr = value.split(',');
|
|
for (let i of valueArr) {
|
|
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, valueArr);
|
|
|
|
if (users) {
|
|
let list = new Array();
|
|
for (let user of users) {
|
|
let role = await RoleModel.findAllByUid(user.uid);
|
|
let sms = await smsModel.findByTel(user.tel);
|
|
|
|
list.push({ ...user, role, isFixed: sms ? sms.isFixed : false, code: sms ? sms.code : "" });
|
|
}
|
|
|
|
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 addAuth(uid: number, auth: number) {
|
|
console.log('enter Auth addAuth');
|
|
const ctx = this.ctx;
|
|
|
|
const user = await UserModel.addAuth(uid, auth);
|
|
if (user) {
|
|
return ctx.service.utils.resResult(STATUS.SUCCESS);
|
|
} else {
|
|
console.error('add auth error');
|
|
return ctx.service.utils.resResult(STATUS.INTERNAL_ERR);
|
|
}
|
|
}
|
|
|
|
public checkTelNo(telNo: string) {
|
|
if (!isString(telNo)) {
|
|
return { status: 1, data: '参数类型错误' };
|
|
}
|
|
if (telNo.length !== 11) {
|
|
return { status: 1, data: '手机号长度错误' };
|
|
}
|
|
return { status: 0, data: '手机号合法' };
|
|
}
|
|
|
|
public async fixSms(tel: string) {
|
|
console.log('enter Auth fix sms');
|
|
const ctx = this.ctx;
|
|
const checkTel = this.checkTelNo(tel);
|
|
if (checkTel.status == 1) {
|
|
return ctx.service.utils.resResult(STATUS.INTERNAL_ERR, checkTel.data);
|
|
}
|
|
const sms = await smsModel.fixSms(tel);
|
|
if (sms) {
|
|
return ctx.service.utils.resResult(STATUS.SUCCESS);
|
|
} else {
|
|
console.error('fix sms error');
|
|
return ctx.service.utils.resResult(STATUS.INTERNAL_ERR);
|
|
}
|
|
}
|
|
|
|
public async deleteRole(roleId: string) {
|
|
console.log('enter Auth deleteRole');
|
|
const ctx = this.ctx;
|
|
let role = await RoleModel.findByRoleId(roleId);
|
|
if(!role) return ctx.service.utils.resResult(STATUS.WRONG_PARMS);
|
|
await ActionPointModel.deleteMany({roleId});
|
|
await ActivityBuyRecordsModel.deleteMany({ roleId });
|
|
await ActivityDailyChallengesModel.deleteMany({ roleId });
|
|
await ActivityDailyCoinModel.deleteMany({ roleId });
|
|
await ActivityDailyGiftsModel.deleteMany({ roleId });
|
|
await ActivityDailyGKModel.deleteMany({ roleId });
|
|
await ActivityDailyMealModel.deleteMany({ roleId });
|
|
await ActivityDailyRMBGiftsModel.deleteMany({ roleId });
|
|
await ActivityFirstGiftModel.deleteMany({ roleId });
|
|
await ActivityGrowthModel.deleteMany({ roleId });
|
|
await ActivityGrowthPointModel.deleteMany({ roleId });
|
|
await ActivityGrowthFundModel.deleteMany({ roleId });
|
|
await ActivityMonopolyModel.deleteMany({ roleId });
|
|
await ActivityMonopolyLandModel.deleteMany({ roleId });
|
|
await ActivityMonthlyTicketModel.deleteMany({ roleId });
|
|
await ActivityNewHeroGachaModel.deleteMany({ roleId });
|
|
await ActivityNewHeroGiftModel.deleteMany({ roleId });
|
|
await ActivityNewHeroGKModel.deleteMany({ roleId });
|
|
await ActivityPopUpShopModel.deleteMany({ roleId });
|
|
await ActivityPopUpShopRecordModel.deleteMany({ roleId });
|
|
await ActivityRechargeMoneyModel.deleteMany({ roleId });
|
|
await ActivityRefreshShopModel.deleteMany({ roleId });
|
|
await ActivityRefreshTaskModel.deleteMany({ roleId });
|
|
await ActivityRefreshTaskPointModel.deleteMany({ roleId });
|
|
await ActivitySelfServiceModel.deleteMany({ roleId });
|
|
await ActivitySelfServiceGoodsModel.deleteMany({ roleId });
|
|
await ActivitySelfServiceShopModel.deleteMany({ roleId });
|
|
await ActivityShopModel.deleteMany({ roleId });
|
|
await ActivitySignInModel.deleteMany({ roleId });
|
|
await ActivityTaskPointModel.deleteMany({ roleId });
|
|
await ActivityThirtyDaysModel.deleteMany({ roleId });
|
|
await ActivityThirtyDaysPointRewardModel.deleteMany({ roleId });
|
|
await ActivityTreasureHuntFirstPageModel.deleteMany({ roleId });
|
|
await ActivityTreasureHuntShopModel.deleteMany({ roleId });
|
|
await ActivityTreasureHuntTaskModel.deleteMany({ roleId });
|
|
await ActivityTreasureHuntTreasureShopModel.deleteMany({ roleId });
|
|
await ActivityVipRechargeMoneyModel.deleteMany({ roleId });
|
|
await BattleBlueprtDropModel.deleteMany({ roleId });
|
|
await BattleDropModel.deleteMany({ roleId });
|
|
await BattleRecordModel.deleteMany({ roleId });
|
|
await BattleSweepRecordModel.deleteMany({ roleId });
|
|
await ChatInfoModel.deleteMany({ roleId });
|
|
await ChatInfoModel.updateMany({ 'recentPrivateChats.targetRoleId': roleId }, { $pull: { recentPrivateChats: { targetRoleId: roleId } } });
|
|
await DailyRecordModel.deleteMany({ roleId });
|
|
await DungeonFirstModel.deleteMany({ roleId });
|
|
await EquipModel.deleteMany({ roleId });
|
|
await EquipPrintDropModel.deleteMany({ roleId });
|
|
await EventRecordModel.deleteMany({ roleId });
|
|
await ExpeditionPointModel.deleteMany({ roleId });
|
|
await ExpeditionRecordModel.deleteMany({ roleId });
|
|
await ExpeditionWarRecordModel.deleteMany({ roleId });
|
|
await FriendApplyModel.deleteMany({ roleId });
|
|
await FriendApplyModel.deleteMany({ frdRoleId: roleId });
|
|
await FriendPointModel.deleteMany({ roleId });
|
|
await FriendPresentLogModel.deleteMany({ roleId });
|
|
await FriendPresentLogModel.deleteMany({ hisRoleId: roleId });
|
|
await FriendRelationModel.deleteMany({ roleId });
|
|
await FriendRelationModel.updateMany({ 'friends.roleId': roleId }, { $pull: { friends: { roleId }} });
|
|
await FriendRelationModel.updateMany({ 'blacklist.roleId': roleId }, { $pull: { blacklist: { roleId }} });
|
|
await FriendShipModel.deleteMany({ roleIdA: roleId });
|
|
await FriendShipModel.deleteMany({ roleIdB: roleId });
|
|
await GroupMailModel.updateMany({ 'roleStatus.roleId': roleId }, { $pull: { roleStatus: { roleId } } });
|
|
await GroupMailModel.deleteMany({ roleId });
|
|
await GroupMailModel.deleteMany({ targetRoleId: roleId });
|
|
let userGuild = await UserGuildModel.getMyGuild(roleId);
|
|
if(userGuild) {
|
|
if(userGuild.auth == 1) {
|
|
const guild = await GuildModel.dismiss(userGuild.guildCode, role.serverId);
|
|
await UserGuildModel.dismiss(userGuild.guildCode);
|
|
const { members } = guild;
|
|
await RoleModel.dissmissGuild(members);
|
|
await UserGuildApplyModel.deleteApplyByGuild(userGuild.guildCode);
|
|
|
|
} else {
|
|
await GuildModel.update({ members: { $in: [roleId] } }, { $pull: { members: roleId }, $inc: { memberCnt: -1, managerCnt: userGuild.auth == 2? -1: 0, guildCe: -role.ce }, $set: { isMemberMax: false } })
|
|
}
|
|
}
|
|
await GuildModel.updateMany({ invitedMembers: { $in: [roleId] } }, { $pull: { invitedMembers: roleId } });
|
|
await GuildRecModel.deleteMany({ roleId });
|
|
await HangUpSpdUpRecModel.deleteMany({ roleId });
|
|
await HangUpRecordModel.deleteMany({ roleId });
|
|
await HeroModel.deleteMany({ roleId });
|
|
await ItemModel.deleteMany({ roleId });
|
|
await MailModel.deleteMany({ roleId });
|
|
await MessageModel.deleteMany({ roleId });
|
|
await MessageModel.deleteMany({ targetRoleId: roleId });
|
|
await PrivateMessageModel.deleteMany({ roleId });
|
|
await PrivateMessageModel.deleteMany({ targetRoleId: roleId });
|
|
await PvpDefenseModel.deleteMany({ roleId });
|
|
await RScriptRecordModel.deleteMany({ roleId });
|
|
await SchoolModel.deleteMany({ roleId });
|
|
await ScriptBarrageModel.deleteMany({ roleId });
|
|
await SearchRecordModel.deleteMany({ roleId });
|
|
await ServerMailModel.updateMany({ 'roleStatus.roleId': roleId }, { $pull: { roleStatus: { roleId } } });
|
|
await SkinModel.deleteMany({ roleId });
|
|
await TowerRecordModel.deleteMany({ roleId });
|
|
await TowerTaskRecModel.deleteMany({ roleId });
|
|
await UserGachaModel.deleteMany({ roleId });
|
|
await UserGachaRecModel.deleteMany({ roleId });
|
|
await UserGiftCodeModel.deleteMany({ roleId });
|
|
await UserGuildModel.deleteMany({ roleId });
|
|
await UserGuildActivityRecModel.deleteMany({ roleId });
|
|
await UserGuildApplyModel.deleteMany({ roleId });
|
|
await UserOrderModel.deleteMany({ roleId });
|
|
await UserShopModel.deleteMany({ roleId });
|
|
await UserTaskModel.deleteMany({ roleId });
|
|
await UserTaskHistoryModel.deleteMany({ roleId });
|
|
await UserTaskRecModel.deleteMany({ roleId });
|
|
await WishPoolReportModel.deleteMany({ wishRoleId: roleId});
|
|
await WishPoolReportModel.deleteMany({ dntRoleId: roleId});
|
|
|
|
await RoleModel.deleteMany({ roleId });
|
|
return ctx.service.utils.resResult(STATUS.SUCCESS);
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* 根据类型等搜索玩家
|
|
*/
|
|
public async getrolelist(field: string = 'all', value: string = '') {
|
|
const { ctx } = this;
|
|
|
|
let arr = new Array(), flag = 0;
|
|
let valueArr = value.split(',');
|
|
if (value == '') field = 'all';
|
|
for (let i of valueArr) {
|
|
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, valueArr);
|
|
|
|
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.defCe : 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);
|
|
}
|
|
|
|
for (let roleId of uids) {
|
|
let role = await RoleModel.findByRoleId(roleId);
|
|
if (role) {
|
|
let heroInfos = new Map();
|
|
for (let hid of hids) {
|
|
let heroInfo = ctx.service.utils.getInitHeroById(hid);
|
|
heroInfos.set(hid, {...heroInfo});
|
|
}
|
|
|
|
let createHero = new CreateHeroes(roleId, role.roleName, role.serverId);
|
|
await createHero.createWithHeroInfo(heroInfos);
|
|
|
|
} else {
|
|
return ctx.service.utils.resResult(STATUS.GM_CREATE_ERROR, null, '未找到角色' + roleId)
|
|
}
|
|
}
|
|
|
|
return ctx.service.utils.resResult(STATUS.SUCCESS, { uids });
|
|
}
|
|
|
|
public async createEquip(uids: Array<string>, _eid: string, _ecount: string, _ehid: string) {
|
|
const { ctx } = this;
|
|
console.log('gm createEquip', uids, _eid, _ecount, _ehid);
|
|
let eids = (_eid as string).split('&').map(cur => parseInt(cur));
|
|
let ecount = parseInt(_ecount);
|
|
let ehid = parseInt(_ehid);
|
|
if (isNaN(ecount) || isNaN(ehid)) return ctx.service.utils.resResult(STATUS.WRONG_PARMS);
|
|
for (let eid of eids) {
|
|
if (isNaN(eid)) 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 weapons: { id: number, hid?: number }[] = [];
|
|
for (let eid of eids) {
|
|
for (let i = 0; i < ecount; i++) {
|
|
|
|
let dicEquip = gameData.goods.get(eid);
|
|
if (!dicEquip) {
|
|
flag = 1, msg = "未找到装备" + eid;
|
|
break;
|
|
}
|
|
weapons.push({ id: eid, hid: ehid });
|
|
}
|
|
}
|
|
await addEquips(roleId, role.roleName, weapons);
|
|
} 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 itemids = (_itemid as string).split('&').map(cur => parseInt(cur));
|
|
for (let itemid of itemids) {
|
|
if (isNaN(itemid)) return ctx.service.utils.resResult(STATUS.WRONG_PARMS);
|
|
}
|
|
let itemcount = parseInt(_itemcount);
|
|
if (isNaN(itemcount)) return ctx.service.utils.resResult(STATUS.WRONG_PARMS);
|
|
|
|
let flag = 0, msg = '创建失败';
|
|
let datas: {id: number, count: number }[] = []
|
|
for (let itemid of itemids) {
|
|
let dicGoods = gameData.goods.get(itemid);
|
|
let itidObj = ITID.get(dicGoods.itid);
|
|
|
|
if (!dicGoods) {
|
|
flag = 1, msg = "未找到道具" + itemid;
|
|
} else if (!itidObj) {
|
|
flag = 1, msg = "未找到道具" + itemid;
|
|
} else {
|
|
datas.push({ id: itemid, count: itemcount });
|
|
}
|
|
}
|
|
if(flag == 0) {
|
|
for (let roleId of uids) {
|
|
let role = await RoleModel.findByRoleId(roleId);
|
|
if (role) {
|
|
await addBags(roleId, role.roleName, datas);
|
|
} 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 addCoin(uids: Array<string>, _count: string) {
|
|
const { ctx } = this;
|
|
console.log('gm addCoin', uids, _count);
|
|
let count = parseInt(_count);
|
|
if (isNaN(count)) return ctx.service.utils.resResult(STATUS.WRONG_PARMS);
|
|
for (let roleId of uids) {
|
|
await RoleModel.addCoin(roleId, count);
|
|
}
|
|
|
|
return ctx.service.utils.resResult(STATUS.SUCCESS, { uids });
|
|
}
|
|
public async addSkin(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) {
|
|
let role = await RoleModel.findByRoleId(roleId);
|
|
await addSkin(roleId, role.roleName, id, false);
|
|
}
|
|
|
|
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 = getExpByLv(lv - 1);
|
|
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);
|
|
let role = await RoleModel.findByRoleId(roleId);
|
|
if (!hero || !role) {
|
|
return ctx.service.utils.resResult(STATUS.GM_HERO_NOT_FOUND);
|
|
}
|
|
let { lv, ce, attr: heroAttrs } = hero;
|
|
let { attr: roleAttrs } = role;
|
|
|
|
|
|
let dicHero = gameData.hero.get(hid);
|
|
|
|
let attribute = new AttributeCal();
|
|
attribute.setByDbData(roleAttrs, heroAttrs);
|
|
|
|
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: [], defCe: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
|
|
});
|
|
}
|
|
|
|
/**
|
|
* 根据类型等搜索玩家
|
|
*/
|
|
public async getHeroList(field: string, value: (string | number)) {
|
|
const { ctx } = this;
|
|
|
|
let heroes = await HeroModel.findByField(field, value);
|
|
|
|
if (heroes) {
|
|
let roleMap = new Map<string, CeAttrDataRole[]>();
|
|
for(let { roleId } of heroes) {
|
|
if(!roleMap.has(roleId)) {
|
|
let role = await RoleModel.findByRoleId(roleId, 'attr');
|
|
roleMap.set(roleId, role.attr);
|
|
}
|
|
}
|
|
let list = heroes.map(cur => {
|
|
let cal = new AttributeCal();
|
|
cal.setByDbData(roleMap.get(cur.roleId), cur.attr);
|
|
return {...cur, calculatedAttr: cal.getReduceAttributesToArr()}
|
|
})
|
|
|
|
return ctx.service.utils.resResult(STATUS.SUCCESS, { list });
|
|
} else {
|
|
console.error('role list not found');
|
|
return ctx.service.utils.resResult(STATUS.INTERNAL_ERR);
|
|
}
|
|
}
|
|
|
|
|
|
public async deleteHero(roleIdAndHids: string[]) {
|
|
console.log('enter Auth deleteRole');
|
|
const ctx = this.ctx;
|
|
for (let roleIdAndHid of roleIdAndHids) {
|
|
let [roleId, hidStr] = roleIdAndHid.split('|');
|
|
if (isNaN(parseInt(hidStr))) return ctx.service.utils.resResult(STATUS.WRONG_PARMS);
|
|
|
|
let hid = parseInt(hidStr);
|
|
|
|
let hero = await HeroModel.findByHidAndRole(hid, roleId);
|
|
if (!hero) continue;
|
|
await HeroModel.deleteHero(roleId, hid);
|
|
let role = await RoleModel.findByRoleId(roleId);
|
|
await calculatetopLineup(role, hid, 0, null);
|
|
await PvpDefenseModel.deleteHero(roleId, hid);
|
|
await RoleModel.updateRoleInfo(roleId, { topLineup: role.topLineup, topLineupCe: role.topLineupCe, ce: role.ce - hero.ce });
|
|
}
|
|
|
|
return ctx.service.utils.resResult(STATUS.SUCCESS);
|
|
}
|
|
|
|
public async deleteEquip(roleIdAndSeqIds: string[]) {
|
|
console.log('enter Auth deleteEquip');
|
|
const ctx = this.ctx;
|
|
let seqIds = new Map<string, number[]>();
|
|
for (let roleIdAndSeqId of roleIdAndSeqIds) {
|
|
let [roleId, seqIdStr] = roleIdAndSeqId.split('|');
|
|
if (isNaN(parseInt(seqIdStr))) return ctx.service.utils.resResult(STATUS.WRONG_PARMS);
|
|
|
|
let seqId = parseInt(seqIdStr);
|
|
console.log(seqId);
|
|
let equip = await EquipModel.findbySeqId(seqId);
|
|
if (equip.hid > 0) {
|
|
let hero = await HeroModel.findByHidAndRole(equip.hid, roleId);
|
|
let index = hero.ePlace.findIndex(cur => cur.id == equip.ePlaceId);
|
|
if (index < 0) continue;
|
|
let args = calEquipSeids(hero);
|
|
hero.ePlace[index].equip = null;
|
|
await calPlayerCeAndSave(HERO_SYSTEM_TYPE.EQUIP, roleId, hero, {}, args);
|
|
}
|
|
if(!seqIds.has(roleId)) {
|
|
seqIds.set(roleId, []);
|
|
}
|
|
seqIds.get(roleId).push(seqId);
|
|
}
|
|
for(let [roleId, ids] of seqIds) {
|
|
await EquipModel.deleteEquips(roleId, ids);
|
|
}
|
|
|
|
return ctx.service.utils.resResult(STATUS.SUCCESS);
|
|
}
|
|
|
|
public async deleteItem(roleIdAndIds: string[]) {
|
|
console.log('enter Auth deleteItem');
|
|
const ctx = this.ctx;
|
|
let map = new Map<string, number[]>();
|
|
for (let roleIdAndId of roleIdAndIds) {
|
|
let [roleId, idStr] = roleIdAndId.split('|');
|
|
if (isNaN(parseInt(idStr))) return ctx.service.utils.resResult(STATUS.WRONG_PARMS);
|
|
|
|
let id = parseInt(idStr);
|
|
let cur = map.get(roleId);
|
|
if (!cur) {
|
|
cur = new Array<number>();
|
|
map.set(roleId, cur);
|
|
}
|
|
cur.push(id);
|
|
}
|
|
|
|
for (let [roleId, ids] of map) {
|
|
await ItemModel.deletebyRoleAndIds(roleId, ids);
|
|
}
|
|
|
|
return ctx.service.utils.resResult(STATUS.SUCCESS);
|
|
}
|
|
|
|
|
|
public async setItemCount(roleIdAndIds: string[], count: number) {
|
|
console.log('enter Auth setItemCount');
|
|
const ctx = this.ctx;
|
|
let map = new Map<string, number[]>();
|
|
for (let roleIdAndId of roleIdAndIds) {
|
|
let [roleId, idStr] = roleIdAndId.split('|');
|
|
if (isNaN(parseInt(idStr))) return ctx.service.utils.resResult(STATUS.WRONG_PARMS);
|
|
|
|
let id = parseInt(idStr);
|
|
let cur = map.get(roleId);
|
|
if (!cur) {
|
|
cur = new Array<number>();
|
|
map.set(roleId, cur);
|
|
}
|
|
cur.push(id);
|
|
}
|
|
|
|
for (let [roleId, ids] of map) {
|
|
await ItemModel.updateCountByRoleAndIds(roleId, ids, count);
|
|
}
|
|
|
|
return ctx.service.utils.resResult(STATUS.SUCCESS);
|
|
}
|
|
|
|
public async setHeroLv(roleIdAndHids: string[], _hlv: string) {
|
|
|
|
try {
|
|
console.log('gm setHeroLv', roleIdAndHids, _hlv);
|
|
const ctx = this.ctx;
|
|
let hlv = parseInt(_hlv);
|
|
if (isNaN(hlv)) return ctx.service.utils.resResult(STATUS.WRONG_PARMS);
|
|
|
|
for (let roleIdAndHid of roleIdAndHids) {
|
|
let [roleId, hidStr] = roleIdAndHid.split('|');
|
|
if (isNaN(parseInt(hidStr))) return ctx.service.utils.resResult(STATUS.WRONG_PARMS);
|
|
|
|
let hid = parseInt(hidStr);
|
|
|
|
let hero = await HeroModel.findByHidAndRole(hid, roleId);
|
|
console.log(hid, roleId, !!hero);
|
|
if (!hero) continue;
|
|
await calPlayerCeAndSave(HERO_SYSTEM_TYPE.LVUP, roleId, hero, { lv: hlv });
|
|
}
|
|
|
|
return ctx.service.utils.resResult(STATUS.SUCCESS);
|
|
} catch (e) {
|
|
console.error(e.stack)
|
|
}
|
|
}
|
|
|
|
public async setHeroParam(roleIdAndHids: string[], star: number, colorStar: number, quality: number) {
|
|
try {
|
|
const ctx = this.ctx;
|
|
if (typeof star != 'number'||typeof colorStar != 'number'||typeof quality != 'number') return ctx.service.utils.resResult(STATUS.WRONG_PARMS);
|
|
|
|
for (let roleIdAndHid of roleIdAndHids) {
|
|
let [roleId, hidStr] = roleIdAndHid.split('|');
|
|
if (isNaN(parseInt(hidStr))) return ctx.service.utils.resResult(STATUS.WRONG_PARMS);
|
|
|
|
let hid = parseInt(hidStr);
|
|
|
|
let hero = await HeroModel.findByHidAndRole(hid, roleId);
|
|
console.log(hid, roleId, !!hero);
|
|
if (!hero) continue;
|
|
await calPlayerCeAndSave(HERO_SYSTEM_TYPE.LVUP, roleId, hero, { star, colorStar, quality });
|
|
}
|
|
|
|
return ctx.service.utils.resResult(STATUS.SUCCESS);
|
|
} catch (e) {
|
|
console.error(e.stack)
|
|
}
|
|
}
|
|
|
|
|
|
public async setHeroJob(roleIdAndHids: string[], job: number) {
|
|
try {
|
|
const ctx = this.ctx;
|
|
if(!gameData.job.has(job)) return ctx.service.utils.resResult(STATUS.WRONG_PARMS);
|
|
|
|
for (let roleIdAndHid of roleIdAndHids) {
|
|
let [roleId, hidStr] = roleIdAndHid.split('|');
|
|
if (isNaN(parseInt(hidStr))) return ctx.service.utils.resResult(STATUS.WRONG_PARMS);
|
|
|
|
let hid = parseInt(hidStr);
|
|
|
|
let hero = await HeroModel.findByHidAndRole(hid, roleId);
|
|
console.log(hid, roleId, !!hero);
|
|
if (!hero) continue;
|
|
await calPlayerCeAndSave(HERO_SYSTEM_TYPE.STAGEUP, roleId, hero, { job });
|
|
}
|
|
|
|
return ctx.service.utils.resResult(STATUS.SUCCESS);
|
|
} catch (e) {
|
|
console.error(e.stack)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 根据类型等搜索装备
|
|
*/
|
|
public async getEquipList(field: string, value: (string | number)) {
|
|
const { ctx } = this;
|
|
|
|
let equips = await EquipModel.findByField(field, value);
|
|
|
|
if (equips) {
|
|
|
|
return ctx.service.utils.resResult(STATUS.SUCCESS, { list: equips });
|
|
} else {
|
|
console.error('role list not found');
|
|
return ctx.service.utils.resResult(STATUS.INTERNAL_ERR);
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* 根据类型等搜索道具
|
|
*/
|
|
public async getItemList(field: string, value: (string | number)) {
|
|
const { ctx } = this;
|
|
|
|
let items = await ItemModel.findByField(field, value);
|
|
|
|
if (items) {
|
|
|
|
return ctx.service.utils.resResult(STATUS.SUCCESS, { list: items });
|
|
} else {
|
|
console.error('role list not found');
|
|
return ctx.service.utils.resResult(STATUS.INTERNAL_ERR);
|
|
}
|
|
}
|
|
|
|
public async getGiftCodeList(page: number, pageSize: number, sortField: string, sortOrder: string, form: { name?: string, current?: boolean, } = {}) {
|
|
const { ctx } = this;
|
|
|
|
const list = await GiftCodeModel.findByCondition(page, pageSize, sortField, sortOrder, form);
|
|
const total = await GiftCodeModel.countByCondition( form )
|
|
return ctx.service.utils.resResult(STATUS.SUCCESS, {
|
|
list: list.map(cur => {
|
|
return { ...cur, beginTime: cur.beginTime.getTime(), endTime: cur.endTime.getTime() }
|
|
}), total
|
|
});
|
|
}
|
|
|
|
public async updateGiftCode(id: string|number, params: any) {
|
|
const { ctx } = this;
|
|
if(params.beginTime) params.beginTime = new Date(params.beginTime);
|
|
if(params.endTime) params.endTime = new Date(params.endTime);
|
|
|
|
try{
|
|
params.goods = JSON.parse(params.goods);
|
|
} catch(e) {
|
|
console.error(e);
|
|
return ctx.body = ctx.service.utils.resResult(STATUS.WRONG_PARMS);
|
|
}
|
|
const result = await GiftCodeModel.updateData(id, params, ctx.user?.uid);
|
|
if(!result) return ctx.service.utils.resResult(STATUS.INTERNAL_ERR);
|
|
return ctx.service.utils.resResult(STATUS.SUCCESS);
|
|
}
|
|
|
|
public async generateGiftCode(id: number, generateType: 1|2, code: string, generateNum: number, codeLen: number = 8) {
|
|
const { ctx } = this;
|
|
|
|
let giftCode = await GiftCodeModel.findData(id);
|
|
if(!giftCode) return ctx.service.utils.resResult(STATUS.WRONG_PARMS);
|
|
|
|
let length = 0, isLimit = false, count = 0, generateCode = '';
|
|
if(generateType == 1) {
|
|
let generateResult = await GiftCodeDetailModel.generateMany(giftCode, generateNum, codeLen, ctx.user?.uid);
|
|
length = generateResult.length;
|
|
isLimit = true;
|
|
count = 1;
|
|
} else if (generateType == 2) {
|
|
let generateResult = await GiftCodeDetailModel.generateOne(giftCode, code, ctx.user?.uid);
|
|
length = generateResult.length;
|
|
generateCode = code;
|
|
}
|
|
if(length <= 0) return ctx.service.utils.resResult(STATUS.INTERNAL_ERR);
|
|
giftCode = await GiftCodeModel.updateData(id, { generateCnt: giftCode.generateCnt + length, generateType, isLimit, count, generateCode }, ctx.user?.uid);
|
|
return ctx.service.utils.resResult(STATUS.SUCCESS, { giftCode })
|
|
}
|
|
|
|
public async getGiftCodeDetails(id: number) {
|
|
const { ctx } = this;
|
|
|
|
let giftCode = await GiftCodeModel.findData(id);
|
|
if(!giftCode) return ctx.service.utils.resResult(STATUS.WRONG_PARMS);
|
|
let { generateCnt } = giftCode;
|
|
let limit = 1000;
|
|
let n = Math.ceil(generateCnt / limit);
|
|
let codes: string[] = [];
|
|
for(let i = 0; i < n; i++) {
|
|
let giftCodeDetails = await GiftCodeDetailModel.findByGiftCode(giftCode);
|
|
for(let {code} of giftCodeDetails) {
|
|
codes.push(code);
|
|
}
|
|
}
|
|
console.log(id, codes.join())
|
|
|
|
ctx.set('Content-Type', 'application/octet-stream');
|
|
|
|
return Buffer.from(codes.join('\n'));
|
|
}
|
|
|
|
public async setWarRecord(roleIds: string[], _warId: string) {
|
|
const { ctx } = this;
|
|
let warId = parseInt(_warId);
|
|
if(warId < 104) return ctx.service.utils.resResult(STATUS.WRONG_PARMS, null, '不可跳到序章以前')
|
|
let dicWar = gameData.war.get(warId);
|
|
if(!dicWar) return ctx.service.utils.resResult(STATUS.WRONG_PARMS);
|
|
|
|
for(let roleId of roleIds) {
|
|
await this.setSingleWarRecord(roleId, dicWar);
|
|
}
|
|
return ctx.service.utils.resResult(STATUS.SUCCESS);
|
|
}
|
|
|
|
private async setSingleWarRecord(roleId: string, dicWar: DicWar) {
|
|
let { warStar } = await RoleModel.findByRoleId(roleId);
|
|
let deleteIds: number[] = [], myMaxWarId = 0, insertParams: DicWar[] = [];
|
|
for(let i = 0; i < warStar.length; i++) {
|
|
let { id, warType } = warStar[i];
|
|
if(warType == dicWar.warType) {
|
|
if(id >= dicWar.war_id) {
|
|
deleteIds.push(id);
|
|
}
|
|
if(id > myMaxWarId) {
|
|
myMaxWarId = id;
|
|
}
|
|
}
|
|
}
|
|
let newWarStar = warStar.filter(cur => {
|
|
return deleteIds.indexOf(cur.id) == -1;
|
|
});
|
|
if(myMaxWarId < dicWar.war_id) {
|
|
for(let id = myMaxWarId + 1; id < dicWar.war_id; id++) {
|
|
let _dicWar = gameData.war.get(id)
|
|
if(_dicWar && _dicWar.warType == dicWar.warType) {
|
|
newWarStar.push({ id, warType: _dicWar.warType, star: 0 });
|
|
insertParams.push(_dicWar);
|
|
}
|
|
}
|
|
}
|
|
let preGkIndex = newWarStar.findIndex(cur => cur.id == dicWar.previousGk);
|
|
console.log(dicWar.previousGk)
|
|
if(dicWar.previousGk && preGkIndex == -1) {
|
|
let _dicWar = gameData.war.get(dicWar.previousGk);
|
|
newWarStar.push({ id: _dicWar.war_id, warType: _dicWar.warType, star: 3 });
|
|
}
|
|
if(insertParams.length > 0) {
|
|
await RScriptRecordModel.insertScripts(roleId, insertParams);
|
|
}
|
|
if(deleteIds.length > 0) {
|
|
await RScriptRecordModel.deleteByWarId(roleId, deleteIds);
|
|
}
|
|
let role = await RoleModel.updateRoleInfo(roleId, { warStar: newWarStar });
|
|
return role;
|
|
}
|
|
}
|