209 lines
8.5 KiB
TypeScript
209 lines
8.5 KiB
TypeScript
import { Application, BackendSession, HandlerService, } from "pinus";
|
|
import { resResult } from "../../../pubUtils/util";
|
|
import { STATUS, RANK_TYPE_TO_KEY, ROLE_SELECT, RANK_TYPE, HERO_SELECT, GUILD_SELECT, RANK_FIRST_REWARD_STATUS } from "../../../consts";
|
|
import { RoleModel } from "../../../db/Role";
|
|
import { UserGuildModel } from "../../../db/UserGuild";
|
|
import { GuildModel } from "../../../db/Guild";
|
|
import { Rank, getGeneralRank, getRankFirstReward } from "../../../services/rankService";
|
|
import { nowSeconds } from "../../../pubUtils/timeUtil";
|
|
import { gameData } from "../../../pubUtils/data";
|
|
import { addItems } from "../../../services/rewardService";
|
|
import { HeroModel, HeroUpdate } from "../../../db/Hero";
|
|
import { RewardInter } from "../../../pubUtils/interface";
|
|
import { GuildRankInfo, RoleAndGuildRankInfo, RoleRankInfo } from "../../../domain/rank";
|
|
|
|
export default function (app: Application) {
|
|
new HandlerService(app, {});
|
|
return new RoleHandler(app);
|
|
}
|
|
|
|
export class RoleHandler {
|
|
constructor(private app: Application) {
|
|
}
|
|
|
|
async getGeneralRank(msg: {}, session: BackendSession) {
|
|
let roleId = session.get('roleId');
|
|
let roleName = session.get('roleName');
|
|
let serverId = session.get('serverId');
|
|
|
|
let role = await RoleModel.findByRoleId(roleId, 'rankReceived');
|
|
if (!role) return resResult(STATUS.WRONG_PARMS);
|
|
|
|
let ranks = await getGeneralRank(role, serverId);
|
|
|
|
return resResult(STATUS.SUCCESS, { ranks });
|
|
}
|
|
|
|
|
|
async getRankReward(msg: {}, session: BackendSession) {
|
|
let roleId = session.get('roleId');
|
|
let roleName = session.get('roleName');
|
|
let serverId = session.get('serverId');
|
|
|
|
let role = await RoleModel.findByRoleId(roleId, 'rankReceived');
|
|
if (!role) return resResult(STATUS.WRONG_PARMS);
|
|
|
|
let ranks = await getRankFirstReward(role, serverId);
|
|
|
|
return resResult(STATUS.SUCCESS, { ranks });
|
|
}
|
|
|
|
async getRank(msg: { type: number }, session: BackendSession) {
|
|
let roleId = session.get('roleId');
|
|
let serverId = session.get('serverId');
|
|
let guildCode = session.get('guildCode');
|
|
|
|
let { type } = msg;
|
|
let redisKey = RANK_TYPE_TO_KEY.get(type);
|
|
if (!redisKey) return resResult(STATUS.WRONG_PARMS);
|
|
let r = new Rank(redisKey, { serverId });
|
|
r.setGenerFieldsFun((obj => {
|
|
let result = new RoleAndGuildRankInfo(obj.rank, obj.num);
|
|
if(obj instanceof GuildRankInfo) {
|
|
result.setGuildInfo(obj);
|
|
}
|
|
if(obj instanceof RoleRankInfo) {
|
|
result.setUserInfo(obj);
|
|
}
|
|
return result
|
|
}));
|
|
|
|
let { ranks, myRank } = await r.getRankListWithMyRank({ roleId, guildCode });
|
|
if (!myRank) {
|
|
let role = await RoleModel.findByRoleId(roleId, ROLE_SELECT.RANK, true);
|
|
if (type == RANK_TYPE.TOP_LINTUP) {
|
|
myRank = await r.generMyRankWithRole(roleId, role.topLineupCe, 0, role);
|
|
} else if (type == RANK_TYPE.TOP_HERO) {
|
|
let hero = await HeroModel.getMyTopHero(roleId, HERO_SELECT.RANK_LINEUP);
|
|
myRank = await r.generMyRankWithHero(roleId, hero.hid, hero.ce, 0, hero, role);
|
|
} else if (type == RANK_TYPE.HERO_NUM) {
|
|
myRank = await r.generMyRankWithRole(roleId, role.heroNum, role.heroNumUpdatedAt, role);
|
|
} else if (type == RANK_TYPE.USER_LV) {
|
|
myRank = await r.generMyRankWithRole(roleId, role.lv, role.updatedAt.getTime(), role);
|
|
} else if (type == RANK_TYPE.SUM_CE) {
|
|
myRank = await r.generMyRankWithRole(roleId, role.ce, role.updatedAt.getTime(), role);
|
|
} else if (type == RANK_TYPE.TOWER) {
|
|
myRank = await r.generMyRankWithRole(roleId, role.towerLv - 1, role.towerUpTime?.getTime() || 0, role);
|
|
// } else if (type == RANK_TYPE.DUNGEON) {
|
|
// myRank = await r.generMyRankWithRole(roleId, role.dungeonWarId, role.dungeonUpdatedAt, role);
|
|
} else if (type == RANK_TYPE.MAIN) {
|
|
myRank = await r.generMyRankWithRole(roleId, role.mainWarId, role.mainUpdatedAt, role);
|
|
} else if (type == RANK_TYPE.MAIN_ELITE) {
|
|
myRank = await r.generMyRankWithRole(roleId, role.mainEliteWarId, role.mainEliteUpdatedAt, role);
|
|
} else if (type == RANK_TYPE.GUILD_LV) {
|
|
if(role.hasGuild) {
|
|
let guild = await GuildModel.findByCode(guildCode, serverId);
|
|
myRank = await r.generMyRankWithGuild2(roleId, guild.lv, guild.activeWeekly, guild.lvUpdateTime, guild);
|
|
}
|
|
}
|
|
}
|
|
|
|
return resResult(STATUS.SUCCESS, { type, ranks, myRank });
|
|
}
|
|
|
|
// 查看活跃排行榜
|
|
async getGuildRank(msg: { type: number }, session: BackendSession) {
|
|
|
|
let roleId = session.get('roleId');
|
|
let serverId = session.get('serverId')
|
|
|
|
let { type } = msg;
|
|
|
|
let redisKey = RANK_TYPE_TO_KEY.get(type);
|
|
if (!redisKey) return resResult(STATUS.WRONG_PARMS);
|
|
|
|
let r = new Rank(redisKey, { serverId });
|
|
const myUserGuild = await UserGuildModel.getMyGuild(roleId, 'auth guildCode');
|
|
let { ranks, myRank } = await r.getRankListWithMyRank({ guildCode: myUserGuild?.guildCode || '' });
|
|
if (!myRank) {
|
|
let guild = await GuildModel.findByCode(myUserGuild.guildCode, serverId, GUILD_SELECT.RANK);
|
|
if (type == RANK_TYPE.GUILD_LV) {
|
|
myRank = await r.generMyRankWithGuild(guild.code, guild.lv, guild.lvUpdateTime, guild);
|
|
} else if (type == RANK_TYPE.GUILD_ACTIVE) {
|
|
myRank = await r.generMyRankWithGuild(guild.code, guild.activeWeekly, guild.activeUpdateTime, guild);
|
|
}
|
|
}
|
|
|
|
return resResult(STATUS.SUCCESS, { type, ranks, myRank });
|
|
}
|
|
|
|
// 查看单个武将排行榜
|
|
async getHeroRank(msg: { type: number, hid: number }, session: BackendSession) {
|
|
|
|
let serverId = session.get('serverId')
|
|
|
|
let { type, hid } = msg;
|
|
let redisKey = RANK_TYPE_TO_KEY.get(type);
|
|
if (!redisKey) return resResult(STATUS.WRONG_PARMS);
|
|
|
|
let r = new Rank(redisKey, { serverId, hid });
|
|
let ranks = await r.getRankByRange();
|
|
|
|
return resResult(STATUS.SUCCESS, {
|
|
type, hid, ranks
|
|
});
|
|
}
|
|
|
|
async receiveReward(msg: { type: number, id: number }, session: BackendSession) {
|
|
let roleId = session.get('roleId');
|
|
let serverId = session.get('serverId');
|
|
let roleName = session.get('roleName');
|
|
let sid = session.get('sid');
|
|
|
|
let { type, id } = msg;
|
|
|
|
let ids: number[] = [];
|
|
if (id == 0) {
|
|
gameData.generalRankReward.forEach((dic, id) => {
|
|
if (dic.rankId == type) {
|
|
ids.push(id);
|
|
}
|
|
});
|
|
} else {
|
|
ids.push(id);
|
|
}
|
|
let rewards: RewardInter[] = [];
|
|
let canReceiveId: number[] = [];
|
|
let role = await RoleModel.findByRoleId(roleId, 'rankReceived');
|
|
|
|
for (let id of ids) {
|
|
let dicReward = gameData.generalRankReward.get(id);
|
|
if (!dicReward || dicReward.rankId != type) continue;
|
|
|
|
let redisKey = RANK_TYPE_TO_KEY.get(type);
|
|
let r = new Rank(redisKey, { serverId }, false, 1);
|
|
let ranks = await r.getRankByRange();
|
|
let num = ranks.length > 0 ? ranks[0].num : 0;
|
|
if (num < dicReward.condition) continue;
|
|
|
|
if (role.rankReceived.includes(id)) continue;
|
|
|
|
let reward = dicReward.reward;
|
|
rewards = rewards.concat(reward);
|
|
canReceiveId.push(id);
|
|
}
|
|
|
|
role = await RoleModel.receiveRankReward(roleId, canReceiveId);
|
|
if (canReceiveId.length <= 0) return resResult(STATUS.REWARD_CONDITION_NOT_REACH);
|
|
|
|
let rewardStatus = canReceiveId.map(id => {
|
|
return { id, type, status: RANK_FIRST_REWARD_STATUS.RECEIVED }
|
|
})
|
|
|
|
let goods = await addItems(roleId, roleName, sid, rewards);
|
|
|
|
return resResult(STATUS.SUCCESS, {
|
|
rewards: rewardStatus,
|
|
goods
|
|
})
|
|
}
|
|
|
|
async test(msg: {}, session: BackendSession) {
|
|
let roles = await RoleModel.find({}).lean();
|
|
for (let role of roles) {
|
|
let heroes = await HeroModel.find({ roleId: role.roleId }).lean();
|
|
await RoleModel.updateRoleInfo(role.roleId, { heroNum: heroes.length, heroNumUpdatedAt: nowSeconds() });
|
|
|
|
}
|
|
}
|
|
} |