437 lines
21 KiB
TypeScript
437 lines
21 KiB
TypeScript
import { Application, BackendSession, pinus } from 'pinus';
|
||
import { resResult } from '../../../pubUtils/util';
|
||
import { STATUS } from '../../../consts/statusCode';
|
||
import { getRoleOnlineInfo, redisClient, updateUserInfo } from '../../../services/redisService';
|
||
import { addItems } from '../../../services/role/rewardService';
|
||
import { RewardInter } from '../../../pubUtils/interface';
|
||
import { gameData, getExpByLv, getHeroExpByLv, getHeroLvByExp, getLvByExp, getEquipByJobClassAndEPlace } from '../../../pubUtils/data';
|
||
import { RoleModel, RoleType, WarStar } from '../../../db/Role';
|
||
import { BLOCK_TYPE, DEFAULT_HEROES, GUILD_AUTH, GUILD_DISMISS_WAY, GUILD_JOB, GUILD_MASTER_CHANGE_WAY, GUILD_STATUS, GUILD_STRUCTURE, HERO_SYSTEM_TYPE, ITEM_CHANGE_REASON, MAIL_TYPE, MEMORY_LOG_TYPE, PUSH_ROUTE, REDIS_KEY, TA_EVENT, WAR_TYPE } from '../../../consts';
|
||
import { GuildFormParam, SetHeroParam } from '../../../domain/backEndField/params';
|
||
import { GuildModel, GuildUpdateParam } from '../../../db/Guild';
|
||
import { Rank } from '../../../services/rankService';
|
||
import { UserGuildModel } from '../../../db/UserGuild';
|
||
import { UserGuildApplyModel } from '../../../db/UserGuildApply';
|
||
import { reportTAEvent } from '../../../services/sdkService';
|
||
import { sendMailByContent } from '../../../services/mailService';
|
||
import { GuildLeader } from '../../../domain/rank';
|
||
import { HeroModel } from '../../../db/Hero';
|
||
import { SkinModel } from '../../../db/Skin';
|
||
import { PvpDefenseModel } from '../../../db/PvpDefense';
|
||
import { createHeroes } from '../../../services/role/createHero';
|
||
import { calculateCeWithHero, calculateCeWithRole } from '../../../services/playerCeService';
|
||
import { pushChangeGuildLeader, pushGuildDismiss, pushGuildInfoUpdate } from '../../../services/guildService';
|
||
import { sendMessageToUserWithSuc } from '../../../services/pushService';
|
||
import { RScriptRecordModel } from '../../../db/RScriptRecord';
|
||
import { DicWar } from '../../../pubUtils/dictionary/DicWar';
|
||
import { SchoolModel } from '../../../db/School';
|
||
import { JewelModel } from '../../../db/Jewel';
|
||
import { RoleCeModel } from '../../../db/RoleCe';
|
||
import { setTrainLv } from '../../../services/gmService';
|
||
import { ArtifactModel } from '../../../db/Artifact';
|
||
import { roleLeave } from '../../../services/redisService';
|
||
import { KeyName } from '../../../domain/rank';
|
||
import { LadderMatchModel } from '../../../db/LadderMatch';
|
||
|
||
let timer: NodeJS.Timer;
|
||
export default function (app: Application) {
|
||
return new GmRoleHandler(app);
|
||
}
|
||
|
||
export class GmRoleHandler {
|
||
constructor(private app: Application) {
|
||
}
|
||
|
||
async addItems(msg: { roleId: string, roleName: string, serverId: number, values: { reward: RewardInter[], heroes: number[], lv: number, expInc: number, fixedIpLocation: string }}, session: BackendSession) {
|
||
let { roleId, roleName, serverId, values } = msg;
|
||
|
||
let { reward, heroes, lv, expInc = 0, fixedIpLocation } = values;
|
||
let connect = await getRoleOnlineInfo(roleId);
|
||
let sid = connect.isOnline?connect.sid: null;
|
||
|
||
if(reward &&reward.length > 0) {
|
||
await addItems(roleId, roleName, sid, values.reward, ITEM_CHANGE_REASON.DEBUG);
|
||
}
|
||
if(heroes && heroes.length > 0) {
|
||
await createHeroes(roleId, roleName, sid, serverId, heroes.map(hid => { return { hid, count: 1 }}))
|
||
}
|
||
if(lv && lv > 0) {
|
||
let exp = getExpByLv(lv - 1)?.sum||0;
|
||
exp += expInc;
|
||
let newLv = getLvByExp(exp);
|
||
let role = await RoleModel.updateRoleInfo(roleId, { lv: newLv, exp })
|
||
let r = new Rank(REDIS_KEY.USER_LV, { serverId: serverId });
|
||
await r.setRankWithRoleInfo(roleId, newLv, Date.now(), role);
|
||
sendMessageToUserWithSuc(roleId, PUSH_ROUTE.PLAYER_EXP_CHANGE, {
|
||
isLvUp: false, lv: newLv, exp
|
||
}, sid);
|
||
}
|
||
if(fixedIpLocation != undefined) {
|
||
await RoleModel.updateRoleInfo(roleId, { fixedIpLocation })
|
||
}
|
||
return resResult(STATUS.SUCCESS);
|
||
}
|
||
|
||
async handleBlock(msg: { roleId: string, blockType: BLOCK_TYPE, blockReason: string }, session: BackendSession) {
|
||
let { roleId, blockType, blockReason } = msg;
|
||
if(roleId == undefined || blockType == undefined || blockReason == undefined) return resResult(STATUS.WRONG_PARMS);
|
||
let role = await RoleModel.updateRoleInfo(roleId, { blockType, blockReason });
|
||
if(!role) return resResult(STATUS.ROLE_NOT_FOUND);
|
||
let { isOnline, sid } = await getRoleOnlineInfo(roleId);
|
||
if(isOnline) {
|
||
await this.app.rpc.connector.connectorRemote.setOtherUserSession.toServer(sid,[{ roleId, blockType }]);
|
||
if(blockType == BLOCK_TYPE.BLOCK) { // 踢走
|
||
await this.app.rpc.connector.connectorRemote.remoteLogin.toServer(sid, roleId, STATUS.BLOCKED);
|
||
await roleLeave(roleId);
|
||
}
|
||
}
|
||
return resResult(STATUS.SUCCESS);
|
||
}
|
||
|
||
|
||
async setHero(msg: { roleId: string, hid: number, param: SetHeroParam }, session: BackendSession) {
|
||
let { roleId, hid } = msg;
|
||
let param = new SetHeroParam(msg.param);
|
||
if(!param.checkParams()) return resResult(STATUS.WRONG_PARMS);
|
||
let hero = await HeroModel.findByHidAndRole(hid, roleId);
|
||
if(!hero) return resResult(STATUS.HERO_NOT_FIND);
|
||
let { sid } = await getRoleOnlineInfo(roleId);
|
||
|
||
if(param.lv && param.lv > 0) {
|
||
let exp = getHeroExpByLv(param.lv - 1)||0;
|
||
exp += (param.expInc||0);
|
||
let newLv = getHeroLvByExp(exp);
|
||
param.lv = newLv;
|
||
param['exp'] = exp;
|
||
}
|
||
await calculateCeWithHero(HERO_SYSTEM_TYPE.INIT, roleId, hero.serverId, sid, hid, {...hero, ...param});
|
||
// if(param.job > 0) {
|
||
// await calculateCe(HERO_SYSTEM_TYPE.STAGEUP, roleId, hero.serverId, sid, param, {}, { hid });
|
||
|
||
// hero = await calPlayerCeAndSave(HERO_SYSTEM_TYPE.STAGEUP, sid, roleId, hero, { job: param.job, jobStage: 0 });
|
||
// }
|
||
|
||
// if (hero.star != param.star) {
|
||
// await calAllHeroCe(HERO_SYSTEM_TYPE.STAR, sid, roleId, {}, [hid, 1]); // 升星可能影响到百家学院全局加成
|
||
// }
|
||
return resResult(STATUS.SUCCESS);
|
||
}
|
||
|
||
/**
|
||
* 升级英雄装备至限制内的最高级
|
||
*
|
||
* @param {{ roleId: string, hid: number }} msg
|
||
* @param {BackendSession} session
|
||
* @return {*}
|
||
* @memberof GmRoleHandler
|
||
*/
|
||
async upgradeHeroEPlace(msg: { roleId: string, hid: number }, session: BackendSession) {
|
||
let { roleId, hid } = msg;
|
||
let hero = await HeroModel.findByHidAndRole(hid, roleId);
|
||
if (!hero) return resResult(STATUS.HERO_NOT_FIND);
|
||
/*
|
||
* 通过
|
||
* dic_zyz_equipQuality.json
|
||
* dic_zyz_equipStar.json
|
||
* dic_zyz_equipStrength.json
|
||
* dic_zyz_artifactQuality.json
|
||
* 配置文件得出:
|
||
* maxLevel: 100
|
||
* maxQuality: 5 (金)
|
||
* maxStar: 12
|
||
*
|
||
* 限制:
|
||
* 装备等级不能超过hero等级
|
||
* maxQuality限制等级最大值: 金 最大lv 100
|
||
*
|
||
* 装备信息:
|
||
* dic_zyz_equip.json
|
||
*/
|
||
const MAX_STAR = 12;
|
||
const MAX_QUALITY = 5;
|
||
// EPLACE_ID 分别代表4个部位
|
||
const EPLACE_IDS = [1, 2, 3, 4];
|
||
// 装备升级、升星、升品(注意升级限制)
|
||
// 装备未满 - 补全 - 并升至满级
|
||
let doNotGetEPlaceIds = new Set(EPLACE_IDS);
|
||
hero.ePlace.forEach((ePlaceItem) => {
|
||
doNotGetEPlaceIds.delete(ePlaceItem.id);
|
||
// 该装备已拥有 - 升级、品、星
|
||
// 升级 - 最大等级100
|
||
ePlaceItem.lv = hero.lv; // 英雄等级肯定小于MAX_LV
|
||
// 升品 - 金
|
||
ePlaceItem.quality = MAX_QUALITY;
|
||
ePlaceItem.qualityStage = 0;
|
||
// 生星 - 最高12
|
||
ePlaceItem.star = MAX_STAR;
|
||
ePlaceItem.starStage = 0;
|
||
});
|
||
// 装备补全
|
||
let dicHero = gameData.hero.get(hero.skinId);
|
||
doNotGetEPlaceIds.forEach((ePlaceId) => {
|
||
let dicEquip = getEquipByJobClassAndEPlace(dicHero?.jobClass, ePlaceId);
|
||
if (dicEquip) {
|
||
hero.ePlace.push({
|
||
lv: hero.lv,
|
||
quality: MAX_QUALITY,
|
||
qualityStage: 0,
|
||
star: MAX_STAR,
|
||
starStage: 0,
|
||
jewel: 0,
|
||
id: ePlaceId,
|
||
equipId: dicEquip.id,
|
||
stones: [
|
||
{
|
||
id: 1,
|
||
stone: 0
|
||
},
|
||
{
|
||
id: 2,
|
||
stone: 0
|
||
},
|
||
{
|
||
id: 3,
|
||
stone: 0
|
||
}
|
||
]
|
||
})
|
||
}
|
||
})
|
||
|
||
// 更新装备信息
|
||
await HeroModel.updateHeroInfo(roleId, hid, { ePlace: hero.ePlace });
|
||
// 获取战力重算需要的数据
|
||
let role = await RoleModel.findByRoleId(roleId);
|
||
let schools = await SchoolModel.findByRoleId(roleId);
|
||
let jewels = await JewelModel.findbyRole(roleId);
|
||
let heroes = await HeroModel.findByRole(roleId);
|
||
let skins = await SkinModel.findbyRole(roleId);
|
||
let artifacts = await ArtifactModel.findbyRole(roleId);
|
||
// 所有战力重算
|
||
await calculateCeWithRole(HERO_SYSTEM_TYPE.RE_CAL, roleId, role.serverId, null, {}, { role, schools, jewels, heroes, skins, artifacts });
|
||
// 获取更新装备的英雄
|
||
hero = await HeroModel.findByHidAndRole(hid, roleId);
|
||
|
||
// 返回强化，升星，升品后的hero数据
|
||
return resResult(STATUS.SUCCESS, { curHero: hero });
|
||
}
|
||
|
||
async deleteHero(msg: { roleId: string, hid: number }, session: BackendSession) {
|
||
let { roleId, hid } = msg;
|
||
|
||
let hero = await HeroModel.findByHidAndRole(hid, roleId);
|
||
if (!hero) return resResult(STATUS.HERO_NOT_FIND);
|
||
|
||
await HeroModel.deleteHero(roleId, hid);
|
||
await SkinModel.deleteByHero(roleId, hid);
|
||
let role = await RoleModel.findByRoleId(roleId);
|
||
await PvpDefenseModel.deleteHero(roleId, hid);
|
||
await RoleCeModel.deleteHero(roleId, hid);
|
||
await RoleModel.updateRoleInfo(roleId, { topLineup: role.topLineup.filter(cur => cur.hid != hid), topLineupCe: role.topLineupCe - hero.ce, ce: role.ce - hero.ce });
|
||
await JewelModel.updateMany({ hid }, { $set: { hid: 0}});
|
||
|
||
return resResult(STATUS.SUCCESS);
|
||
}
|
||
|
||
|
||
async updateGuild(msg: GuildFormParam, session: BackendSession ) {
|
||
const uid = session.get('uid');
|
||
let params = new GuildFormParam(msg);
|
||
if(!params.checkParams()) return resResult(STATUS.WRONG_PARMS);
|
||
|
||
let guild = await GuildModel.findByCode(params.code, null, '+members');
|
||
let structure = guild.structure||[];
|
||
|
||
let updateParams: GuildUpdateParam = { code: params.code };
|
||
if(params.name && guild.name != params.name) updateParams.name = params.name;
|
||
if(params.fund != undefined && guild.fund != params.fund) updateParams.fund = params.fund;
|
||
if(params.notice && guild.notice != params.notice) updateParams.notice = params.notice;
|
||
if(params.lv && guild.lv != params.lv) updateParams.lv = params.lv;
|
||
for(let id = GUILD_STRUCTURE.START; id < GUILD_STRUCTURE.END; id ++) {
|
||
let curStructure = structure.find(cur => cur.id == id);
|
||
let lv = params.lv;
|
||
switch(id) {
|
||
case GUILD_STRUCTURE.ARMY_CENTER:
|
||
lv = params.lv; break;
|
||
case GUILD_STRUCTURE.EQUIP_PRODUCE:
|
||
lv = params.equipProduce; break;
|
||
case GUILD_STRUCTURE.BOSS:
|
||
lv = params.boss; break;
|
||
case GUILD_STRUCTURE.TRAIN:
|
||
lv = params.train; break;
|
||
case GUILD_STRUCTURE.DONATE:
|
||
lv = params.donate; break;
|
||
case GUILD_STRUCTURE.WISH_POOL:
|
||
lv = params.wishPool; break;
|
||
case GUILD_STRUCTURE.STORE:
|
||
lv = params.store; break;
|
||
}
|
||
if(curStructure) {
|
||
curStructure.lv = lv;
|
||
} else {
|
||
structure.push({ id, lv });
|
||
}
|
||
}
|
||
updateParams.structure = structure;
|
||
await pushGuildInfoUpdate(params.code, updateParams);
|
||
// 设置玩家名
|
||
if(updateParams.name != undefined || updateParams.lv != undefined) {
|
||
let arr = [];
|
||
if(updateParams.name != undefined) {
|
||
arr.push({ field: 'name', value: updateParams.name });
|
||
for(let roleId of guild.members) {
|
||
await updateUserInfo(REDIS_KEY.USER_INFO, roleId, [{ field: 'guildName', value: updateParams.name }]);
|
||
}
|
||
}
|
||
if(updateParams.lv != undefined) arr.push({ field: 'lv', value: updateParams.lv });
|
||
await updateUserInfo(REDIS_KEY.GUILD_INFO, params.code, arr);
|
||
}
|
||
if (updateParams.lv != undefined) {
|
||
let r = new Rank(REDIS_KEY.GUILD_LV_RANK, { serverId: guild.serverId });
|
||
await r.setRankWithGuildInfo2(guild.code, updateParams.lv, guild.activeWeekly, guild.lvUpdateTime, guild);
|
||
}
|
||
|
||
guild = await GuildModel.updateInfo(params.code, updateParams);
|
||
|
||
if(params.trainLv) {
|
||
await setTrainLv(params.code, params.trainLv);
|
||
}
|
||
|
||
return resResult(STATUS.SUCCESS);
|
||
}
|
||
async dismissGuild(msg: { code: string }, session: BackendSession) {
|
||
|
||
const { code } = msg;
|
||
|
||
let guild = await GuildModel.findByCode(code, null, '+serverId');
|
||
if(!guild) return resResult(STATUS.GUILD_NOT_FOUND);
|
||
if(guild.status == GUILD_STATUS.DISMISSED) return resResult(STATUS.GUILD_DELETE_ERROR);
|
||
|
||
let serverId = guild.serverId;
|
||
guild = await GuildModel.dismiss(code, serverId);
|
||
if (!guild) return resResult(STATUS.GUILD_DELETE_ERROR);
|
||
|
||
await UserGuildModel.dismiss(code);
|
||
const { members } = guild;
|
||
await RoleModel.dissmissGuild(members);
|
||
await UserGuildApplyModel.deleteApplyByGuild(code);
|
||
|
||
await this.app.rpc.connector.connectorRemote.setOtherUserGuildSession.broadcast(members.map(roleId => { return { roleId, userGuild: null } })); // 更新session
|
||
|
||
// 删除channel
|
||
await pushGuildDismiss(code);
|
||
let r = new Rank(REDIS_KEY.GUILD_ACTIVE_RANK, { serverId });
|
||
await r.removeFromRank({ guildCode: code });
|
||
let r2 = new Rank(REDIS_KEY.GUILD_LV_RANK, { serverId });
|
||
await r2.removeFromRank({ guildCode: code });
|
||
let leader = <RoleType>guild.leader;
|
||
reportTAEvent(leader.roleId, TA_EVENT.GUILD_DISMISS, { name: guild.name, way: GUILD_DISMISS_WAY.BACKEND });
|
||
|
||
return resResult(STATUS.SUCCESS, { code, status: guild.status });
|
||
}
|
||
|
||
async setGuildLeader(msg: { code: string, roleId: string }, session: BackendSession) {
|
||
|
||
const { code, roleId } = msg;
|
||
let guild = await GuildModel.findByCode(code, null, '+serverId');
|
||
if(!guild) return resResult(STATUS.GUILD_NOT_FOUND);
|
||
if(guild.status == GUILD_STATUS.DISMISSED) return resResult(STATUS.GUILD_DELETE_ERROR);
|
||
|
||
let role = await RoleModel.findByRoleId(roleId);
|
||
if(!role) return resResult(STATUS.ROLE_NOT_FOUND);
|
||
|
||
let userGuild = await UserGuildModel.getMyGuild(roleId);
|
||
if(!userGuild || userGuild.guildCode != code) return resResult(STATUS.GUILD_KICK_ERROR);
|
||
if(userGuild.auth == GUILD_AUTH.LEADER) return resResult(STATUS.GUILD_USER_IS_LEADER);
|
||
|
||
let leader = <RoleType>guild.leader;
|
||
// 交换
|
||
let oldLeaderUserGuild = await UserGuildModel.updateInfo(leader.roleId, { auth: GUILD_AUTH.MEMBER, job: GUILD_JOB.SHIBING }, {}, 'auth'); // 团长撤
|
||
await this.app.rpc.connector.connectorRemote.setOtherUserGuildSession.broadcast([{ roleId: leader.roleId, userGuild: oldLeaderUserGuild }]); // 更新session
|
||
|
||
let newLeaderUserGuild = await UserGuildModel.updateInfo(roleId, { auth: GUILD_AUTH.LEADER, job: GUILD_JOB.DAJIANGJUN }, {}, 'auth'); // 最高功勋人升
|
||
await this.app.rpc.connector.connectorRemote.setOtherUserGuildSession.broadcast([{ roleId: roleId, userGuild: newLeaderUserGuild }]); // 更新session
|
||
|
||
let managerCntInc = userGuild.auth == GUILD_AUTH.MANAGER ? -1 : 0; // 管理人数
|
||
|
||
guild = await GuildModel.updateInfo(code, { leader: role._id }, { managerCnt: managerCntInc }, 'managerCnt name'); // 如果有转让团长设置leader
|
||
|
||
// 添加动态
|
||
await pushChangeGuildLeader(code, guild.managerCnt, role, leader.roleId);
|
||
await sendMailByContent(MAIL_TYPE.GUILD_BE_IMPEACH, leader.roleId, { params: [guild.name] });
|
||
await sendMailByContent(MAIL_TYPE.GUILD_BE_SET_LEADER, roleId, { params: [guild.name] });
|
||
|
||
await updateUserInfo(REDIS_KEY.GUILD_INFO, code, [{ field: 'leader', value: new GuildLeader(role) }]);
|
||
reportTAEvent(roleId, TA_EVENT.GUILD_MASTER_CHANGE, { way: GUILD_MASTER_CHANGE_WAY.BACKEND, change_id_after: roleId })
|
||
|
||
return resResult(STATUS.SUCCESS, { code });
|
||
}
|
||
|
||
async skipEpilogue(msg: { roleId: string, roleName: string }, session: BackendSession) {
|
||
|
||
const { roleId, roleName } = msg;
|
||
let role = await RoleModel.findByRoleId(roleId);
|
||
if(!role) return resResult(STATUS.ROLE_NOT_FOUND);
|
||
if(role.hasInit) return resResult(STATUS.ROLE_HAS_INIT);
|
||
|
||
let checkName = await RoleModel.checkName(roleName, role.serverId);
|
||
if (checkName) return resResult(STATUS.NAME_HAS_USED);
|
||
|
||
let warStars: WarStar[] = [];
|
||
let insertParams: DicWar[] = [];
|
||
let exp = 0;
|
||
for(let i = 101; i <= 103; i++) {
|
||
let dicWar = gameData.war.get(i);
|
||
insertParams.push(dicWar);
|
||
warStars.push({ id: dicWar.war_id, warType: dicWar.warType, star: 0, stars: [] });
|
||
exp += dicWar.kingExp;
|
||
}
|
||
let lv = getLvByExp(exp);
|
||
|
||
await RScriptRecordModel.deleteByWarType(roleId, WAR_TYPE.NORMAL);
|
||
await RScriptRecordModel.insertScripts(roleId, insertParams);
|
||
|
||
let onlineUser = await getRoleOnlineInfo(roleId);
|
||
await createHeroes(roleId, roleName, onlineUser?.sid, role.serverId, DEFAULT_HEROES.map(hid => ({hid, count: 1})), { roleName, hasInit: true, title: role.title, teraphs: role.teraphs, lv, exp, warStar: warStars });
|
||
|
||
return resResult(STATUS.SUCCESS);
|
||
}
|
||
|
||
async reCalCe(msg: { roleId: string }, session: BackendSession) {
|
||
const { roleId } = msg;
|
||
let role = await RoleModel.findByRoleId(roleId);
|
||
let schools = await SchoolModel.findByRoleId(roleId);
|
||
let jewels = await JewelModel.findbyRole(roleId);
|
||
let heroes = await HeroModel.findByRole(roleId);
|
||
let skins = await SkinModel.findbyRole(roleId);
|
||
let artifacts = await ArtifactModel.findbyRole(roleId);
|
||
|
||
await calculateCeWithRole(HERO_SYSTEM_TYPE.RE_CAL, roleId, role.serverId, null, {}, { role, schools, jewels, heroes, skins, artifacts });
|
||
return resResult(STATUS.SUCCESS);
|
||
}
|
||
|
||
|
||
async clearRank(msg: { roleId: string }, session: BackendSession) {
|
||
let { roleId } = msg;
|
||
let role = await RoleModel.findByRoleId(roleId);
|
||
if(!role) return resResult(STATUS.WRONG_PARMS);
|
||
if(role.blockType != 2) return resResult(STATUS.GM_CANNOT_CLEAR_RANK)
|
||
let { serverId } = role;
|
||
|
||
await redisClient().zremAsync(new KeyName(REDIS_KEY.TOWER_RANK, { serverId }).getName(), roleId);
|
||
await redisClient().zremAsync(new KeyName(REDIS_KEY.LADDER, { serverId }).getName(), roleId);
|
||
await LadderMatchModel.updateByRoleId(roleId, { rank: 0 });
|
||
await redisClient().zremAsync(new KeyName(REDIS_KEY.TOP_LINEUP_RANK, { serverId }).getName(), roleId);
|
||
await redisClient().zremAsync(new KeyName(REDIS_KEY.TOP_HERO_RANK, { serverId }).getName(), roleId);
|
||
await redisClient().zremAsync(new KeyName(REDIS_KEY.HERO_NUM_RANK, { serverId }).getName(), roleId);
|
||
await redisClient().zremAsync(new KeyName(REDIS_KEY.SUM_CE_RANK, { serverId }).getName(), roleId);
|
||
await redisClient().zremAsync(new KeyName(REDIS_KEY.USER_LV, { serverId }).getName(), roleId);
|
||
await redisClient().zremAsync(new KeyName(REDIS_KEY.MAIN_RANK, { serverId }).getName(), roleId);
|
||
await redisClient().zremAsync(new KeyName(REDIS_KEY.MAIN_ELITE_RANK, { serverId }).getName(), roleId);
|
||
|
||
let keys = await redisClient().keysAsync(REDIS_KEY.PVP_RANK);
|
||
for(let key of keys) await redisClient().zremAsync(key, roleId);
|
||
|
||
return resResult(STATUS.SUCCESS);
|
||
}
|
||
} |