ZYZ/game-server/app/servers/activity/remote/activityRemote.ts

import { Application, ChannelService, HandlerService, } from 'pinus';
import { ActivityModel, ActivityModelType } from '../../../db/Activity';
import { ServerlistModel } from '../../../db/Serverlist';
import { reloadResources } from '../../../pubUtils/data';
import { _getActivitiesByType, _getActivityById, _getActivities, _getActivitiesByServerId } from '../../../services/activity/activityService';
import { getServerMainten, setServerMainten, stopServerMainten } from '../../../services/gmService';
import { taflush } from '../../../services/sdkService';
import { ActivityInRemote } from '../../../domain/activityField/activityField';
import { errlogger } from '../../../util/logger';
import { ActivityGroupModel } from '../../../db/ActivityGroup';

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

export class ActivityRemote {

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

    private channelService: ChannelService;
    private activityByServer: Map<number, number[]> = new Map();  // serverId => activityId[];
    private activities: Map<number, ActivityInRemote> = new Map(); // activityId => activity
    private activityByType: Map<number, Map<number, number[]>> = new Map(); // serverId => type => activityId[];
    private groupToServer: Map<number, number[]> = new Map(); // group => serverId[];

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

    public async loadActivities() {
        try {
            let activityGroup = await ActivityGroupModel.findAllActivityGroup();
            for(let { groupId, serverIds } of activityGroup) {
                for(let serverId of serverIds) {
                    if(!this.groupToServer.has(groupId)) {
                        this.groupToServer.set(groupId, []);
                    }
                    this.groupToServer.get(groupId).push(serverId);
                }
            }
    
            let activities = await ActivityModel.findOpenAndComingActivityes();
            let activityIds: number[] = [];
            for(let activity of activities) {
                this.activities.set(activity.activityId, new ActivityInRemote(activity));
                activityIds.push(activity.activityId);
            }
            this.setActivityTypeAndServer();
    
            this.app.set('activityByServer', this.activityByServer);
            this.app.set('activityByType', this.activityByType);
            this.app.set('activities', this.activities);
            this.app.set('groupToServer', this.groupToServer);
            // console.log('****** loadActivities')
        } catch(e) {
            errlogger.error(`remote ${__filename} \n ${e.stack}`);
        }
    }

    private setActivityTypeAndServer() {
        this.activityByServer.clear();
        this.activityByType.clear();

        for(let [_, activity] of this.activities) {
            let servers = this.groupToServer.get(activity.groupId)||[];
            for(let serverId of servers) {
                if(!this.activityByServer.has(serverId)) {
                    this.activityByServer.set(serverId, []);
                }
                this.activityByServer.get(serverId).push(activity.activityId);

                if(!this.activityByType.has(serverId)) {
                    this.activityByType.set(serverId, new Map());
                }
                if(!this.activityByType.get(serverId).has(activity.type)) {
                    this.activityByType.get(serverId).set(activity.type, []);
                }
                this.activityByType.get(serverId).get(activity.type).push(activity.activityId);
            }
        }

        this.app.set('activityByServer', this.activityByServer);
        this.app.set('activityByType', this.activityByType);
        this.app.set('activities', this.activities);
        this.app.set('groupToServer', this.groupToServer);
    }

    public async updateActivities(activities: ActivityInRemote[]) {
        try {
            // console.log('******* activities', activities)
            let activityIds: number[] = [];
            for(let activity of activities) {
                this.activities.set(activity.activityId, activity);
                activityIds.push(activity.activityId);
            }
            this.setActivityTypeAndServer();
    
            this.app.set('activityByServer', this.activityByServer);
            this.app.set('activityByType', this.activityByType);
            this.app.set('activities', this.activities);
            this.app.set('groupToServer', this.groupToServer);
        } catch(e) {
            errlogger.error(`remote ${__filename} \n ${e.stack}`);
        }
    }

    public async deleteActivities(activityIds: number[]) {
        try {
            for(let activityId of activityIds) {
                this.activities.delete(activityId);
            }
            this.setActivityTypeAndServer();
    
            this.app.set('activityByServer', this.activityByServer);
            this.app.set('activityByType', this.activityByType);
            this.app.set('activities', this.activities);
            this.app.set('groupToServer', this.groupToServer);
        } catch(e) {
            errlogger.error(`remote ${__filename} \n ${e.stack}`);
        }
    }

    public async saveGroupToServer(groupId: number, serverIds: number[]) {
        try {
            this.groupToServer.set(groupId, serverIds);
            this.setActivityTypeAndServer();
    
            this.app.set('activityByServer', this.activityByServer);
            this.app.set('activityByType', this.activityByType);
            this.app.set('activities', this.activities);
            this.app.set('groupToServer', this.groupToServer);
        } catch(e) {
            errlogger.error(`remote ${__filename} \n ${e.stack}`);
        }
    }

    public async saveActivitiesToGroup(groupId: number, activities: number[]) {
        try {
            for(let activityId of activities) {
                if(this.activities.get(activityId)) {
                    this.activities.get(activityId).groupId = groupId;
                }
            }
            this.setActivityTypeAndServer();
        } catch(e) {
            errlogger.error(`remote ${__filename} \n ${e.stack}`);
        }
    }

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

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

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

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

    public setServerMainten(serverIds: number[], startTime: number, endTime: number) {
        try {
            setServerMainten(serverIds, startTime, endTime);
        } 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}`);
        }
    }
}