✨ feat(限时排行榜): 修复限时排行榜奖励发放

game-server/app/servers/activity/handler/timeLimitRankHandler.ts

@@ -94,7 +94,7 @@ export class TimeLimitRankHandler {
         let serverTime = await getServerCreateTime(serverId);
         let playerData = new TimeLimitRankData(activityData, 0, serverTime);
         if(!playerData.needSnapshot) return resResult(STATUS.WRONG_PARMS);
-        await takeSnapshot(playerData, activityData.groupId);
+        await takeSnapshot(playerData, serverId);
         return resResult(STATUS.SUCCESS);
     }
 }

game-server/app/servers/role/remote/roleRemote.ts

@@ -10,6 +10,10 @@ import { setApiIsClose } from '../../../services/chatService';
 import { setPvpSeasonNum, setPvpSettleSeasonNum } from '../../../services/timeTaskService';
 import { setKvToMemory } from '../../../services/pushService';
 import { setHiddenData } from '../../../services/memoryCache/hiddenData';
+import { DEBUG_MAGIC_WORD, MAIL_TYPE } from '../../../consts';
+import { ActivityTimeLimitRankModel } from '../../../db/ActivityTimeLimitRank';
+import { RoleModel } from '../../../db/Role';
+import { sendMailToManyPlayerByContent } from '../../../services/mailService';
 
 export default function (app: Application) {
     new HandlerService(app, {});
@@ -168,4 +172,29 @@ export class RoleRemote {
             errlogger.error(`remote ${__filename} \n ${e.stack}`);
         }
     }
+
+    public async repairTimeLimitRank(magicWord: string, activityId: number, serverIds: number[], ridRoleIds: string[]) {
+        try {
+            if(magicWord != DEBUG_MAGIC_WORD) return;
+
+            for(let serverId of serverIds) {
+                let allRanks = await ActivityTimeLimitRankModel.getRank(serverId, activityId);
+                let roles = await RoleModel.findAllRoleForTimeLimitRank(serverId, 16);
+                let roleIds: string[] = [];
+                
+                for(let { roleId } of roles) {
+                    let index = allRanks.findIndex(cur => cur.roleId == roleId);
+                    if(index == -1 && ridRoleIds.indexOf(roleId) == -1) roleIds.push(roleId);
+                }
+                await sendMailToManyPlayerByContent(MAIL_TYPE.TIME_LIMIT_RANK, roleIds, {
+                    params: ['战力', '200+'],
+                    goods: [{ id: 71002, count: 40 }, { id: 31002, count: 500 }]
+                });
+                   
+            }
+
+        } catch(e) {
+            errlogger.error(`remote ${__filename} \n ${e.stack}`);
+        }
+    }
 }

game-server/app/services/activity/timeLimitRankService.ts

@@ -6,7 +6,7 @@ import { RoleModel } from "../../db/Role";
 import { TimeLimitRankData } from "../../domain/activityField/timeLimitRankField";
 import { GuildRankInfo, RoleRankInfo } from "../../domain/rank";
 import { stringWithTypeToRewardInter } from "../../pubUtils/roleUtil";
-import { sendMailByContent, sendMailToGuildByContent } from "../mailService";
+import { sendMailByContent, sendMailToGuildByContent, sendMailToManyPlayerByContent } from "../mailService";
 import { Rank } from "../rankService";
 import { getServerCreateTime } from "../redisService";
 import { getActivitiesByType, getActivityById } from "./activityService";
@@ -86,7 +86,7 @@ export async function sendRankMail(data: TimeLimitRankData, serverId: number) {
         }
     } else {
         let allRank = <RoleRankInfo[]>(await r.getRankByRange());
-
+        let sentRoleIds: string[] = [];
         for(let { rank, roleId } of allRank) {
             let reward = data.getRewardByRank(rank);
             if(reward) {
@@ -94,8 +94,19 @@ export async function sendRankMail(data: TimeLimitRankData, serverId: number) {
                     params: [data.tabName, `${rank}`],
                     goods: stringWithTypeToRewardInter(reward.rewards)
                 });
+                sentRoleIds.push(roleId);
             }
         }
+        let lastReward = data.getRewardByRank(9999);
+        let roles = await RoleModel.findAllRoleForTimeLimitRank(serverId, 16);
+        let roleIds: string[] = [];
+        for(let { roleId } of roles) {
+            if(sentRoleIds.indexOf(roleId) == -1) roleIds.push(roleId);
+        }
+        await sendMailToManyPlayerByContent(MAIL_TYPE.TIME_LIMIT_RANK, roleIds, {
+            params: [data.tabName, '200+'],
+            goods: stringWithTypeToRewardInter(lastReward.rewards)
+        });
     }
 }
 

game-server/app/services/mailService.ts

@@ -86,6 +86,14 @@ export async function sendMailToLeagueByContent(contentId: MAIL_TYPE, leagueCode
     return true;
 }
 
+export async function sendMailToManyPlayerByContent(contentId: MAIL_TYPE, roleIds: string[], params: { sendName?: string, endTime?: number, params?: string[], goods?: RewardInter[] }) {
+    let f = new SendMailFun();
+    let code = f.setWithContentId(contentId, params);
+    await f.createGroupMails(code, roleIds);
+    await f.pushToUsers();
+    return true;
+}
+
 export async function sendMailsByGmMail(gmmails: GMMailType[]) {
     let f = new SendMailFun();
     for(let gmmail of gmmails) {

shared/db/Role.ts

@@ -883,6 +883,10 @@ export default class Role extends BaseModel {
          return await RoleModel.exists({ 'userInfo.uid': uid, lv: { $gt: 3 }, serverId: { $lt: serverId } });
      }
  
+     public static async findAllRoleForTimeLimitRank(serverId: number, lv: number) {
+        let role: RoleType[] = await RoleModel.find({ serverId, lv: { $gte: lv } }).select('roleId').lean();
+        return role
+     }
 }
 
 export const RoleModel = getModelForClass(Role);