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

import { Application, ChannelService, HandlerService, } from 'pinus';
// import { sendRolesMails } from '../../../services/mailService';
import { gameData, reloadResources } from '../../../pubUtils/data';
import { RankFirstModel, RankFirstType } from '../../../db/RankFirst';
import { PVPConfigModel, PVPConfigType } from '../../../db/PvpConfig';
import { treatRoleName, taflush, sendSurveyMail, sendGiftCodeMail } from '../../../services/sdkService';
import { getServerMainten, setServerMainten, stopServerMainten } from '../../../services/gmService';
import { errlogger } from '../../../util/logger';
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';
import * as dicParam from '../../../pubUtils/dicParam';

export default function (app: Application) {
    new HandlerService(app, {});
    return new RoleRemote(app);
}

export class RoleRemote {

    constructor(private app: Application) {
        this.app = app;
        // this.channelService = app.get('channelService');
        this.loadRankFirst();
    }
    // private channelService: ChannelService;

    private rankFirstRewards: Map<number, Map<number, RankFirstType>> = new Map();

    private async loadRankFirst() {
        let rankFirstRewards = await RankFirstModel.findAllRankRewards();
        for(let rank of rankFirstRewards) {
            if(!this.rankFirstRewards.has(rank.serverId)) {
                this.rankFirstRewards.set(rank.serverId, new Map());
            }
            this.rankFirstRewards.get(rank.serverId).set(rank.id, rank);
        }
        this.app.set('rankFirstRewards', this.rankFirstRewards);
    }

    public setRankFirst(rank: RankFirstType) {
        try {
            // console.log('****** setRankFirst', rank.serverId, rank.id, rank)
            if(!this.rankFirstRewards.has(rank.serverId)) {
                this.rankFirstRewards.set(rank.serverId, new Map());
            }
            this.rankFirstRewards.get(rank.serverId).set(rank.id, rank);
            this.app.set('rankFirstRewards', this.rankFirstRewards);
        } catch(e) {
            errlogger.error(`remote ${__filename} \n ${e.stack}`);
        }

    }

    public getRankFirstById(serverId: number, id: number) {
        try {
            return this.rankFirstRewards.get(serverId)?.get(id);
        } catch(e) {
            errlogger.error(`remote ${__filename} \n ${e.stack}`);
        }
    }

    /**
     * 重载json资源
     */
    public async reloadResources(type?: string) {
        try {
            reloadResources(type);
        } catch(e) {
            errlogger.error(`remote ${__filename} \n ${e.stack}`);
        }
    }

    public async setDicParam(field1: string, field2: string, value: string|number) {
        try {
            if(dicParam[field1] && dicParam[field1][field2]) dicParam[field1][field2] = value;
        } catch(e) {
            errlogger.error(`remote ${__filename} \n ${e.stack}`);
        }
    }

    public async setGameDataToApp() {
        try {
            this.app.set('gameData', gameData);
            this.app.set('dicParam', dicParam);
        } catch(e) {
            errlogger.error(`remote ${__filename} \n ${e.stack}`);
        }
    }

    public async setPvpSeasonNum(pvpConfig: PVPConfigType) {
        try {
            await setPvpSeasonNum(pvpConfig);
        } catch(e) {
            errlogger.error(`remote ${__filename} \n ${e.stack}`);
        }
    }

    public async setPvpSettleSeasonNum(pvpConfig: PVPConfigType) {
        try {
            await setPvpSettleSeasonNum(pvpConfig);
        } catch(e) {
            errlogger.error(`remote ${__filename} \n ${e.stack}`);
        }
    }

    public async treatRoleName(roleId: string) {
        try {
            await treatRoleName(roleId);
        } catch(e) {
            errlogger.error(`remote ${__filename} \n ${e.stack}`);
        }
    }

    public setServerMainten(serverIds: number[], startTime: number, endTime: number, version: string) {
        try {
            setServerMainten(serverIds, startTime, endTime, version);
        } catch(e) {
            errlogger.error(`remote ${__filename} \n ${e.stack}`);
        }
    }

    public stopServerMainten(serverIds: number[]) {
        try {
            stopServerMainten(serverIds);
        } catch(e) {
            errlogger.error(`remote ${__filename} \n ${e.stack}`);
        }
    }

    public getServerMainten(serverId: number) {
        try {
            return getServerMainten(serverId);
        } catch(e) {
            errlogger.error(`remote ${__filename} \n ${e.stack}`);
        }
    }

    public taflush() {
        try {
            return taflush();
        } catch(e) {
            errlogger.error(`remote ${__filename} \n ${e.stack}`);
        }
    }

    public async sendSurveyMail(code: string) {
        try {
            await sendSurveyMail(code);
        } catch(e) {
            errlogger.error(`remote ${__filename} \n ${e.stack}`);
        }
    }


    public async sendGiftCodeMail(message: string) {
        try {
            await sendGiftCodeMail(message);
        } catch(e) {
            errlogger.error(`remote ${__filename} \n ${e.stack}`);
        }
    }

    public async setApiIsClose(isClose: boolean) {
        try {
            setApiIsClose(isClose);
        } catch(e) {
            errlogger.error(`remote ${__filename} \n ${e.stack}`);
        }
    }

    public async setHiddenData(heroes: number[], goods: number[], refTime: number) {
        try {
            setHiddenData(heroes, goods, refTime);
        } catch(e) {
            errlogger.error(`remote ${__filename} \n ${e.stack}`);
        }
    }

    public async setKvToMemory(originK: string, originV: string, aesKey: string, aesIV: string, now: number) {
        try {
            setKvToMemory(originK, originV, aesKey, aesIV, now);
        } catch(e) {
            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}`);
        }
    }

    public async fun() {
        try {
            console.log('预留一个函数，用于之后线上维护时需要使用');
        } catch(e) {
            errlogger.error(`remote ${__filename} \n ${e.stack}`);
        } 
    }
}