🐞 fix(定时任务): 新服定时任务不完善

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

@@ -7,7 +7,7 @@ import { taflush } from '../../../services/sdkService';
 import { ActivityInRemote } from '../../../domain/activityField/activityField';
 import { errlogger } from '../../../util/logger';
 import { ActivityGroupModel } from '../../../db/ActivityGroup';
-import { deleteActivities, loadActivities, saveActivitiesToGroup, updateActivities, _getActivityById, _getActivitiesByType, _getActivities, _getActivitiesByServerId } from '../../../services/activity/activityRemoteService';
+import { deleteActivities, loadActivities, saveActivitiesToGroup, updateActivities, _getActivityById, _getActivitiesByType, _getActivities, _getActivitiesByServerId, saveGroupToServer } from '../../../services/activity/activityRemoteService';
 import { saveActivityMemory } from '../../../services/log/memoryLogService';
 import { setApiIsClose } from '../../../services/chatService';
 
@@ -36,15 +36,6 @@ export class ActivityRemote {
         }
     }
 
-    public async loadActivities() {
-        try {
-            // console.log('****** loadActivities')
-            await loadActivities();
-        } catch(e) {
-            errlogger.error(`remote ${__filename} \n ${e.stack}`);
-        }
-    }
-
     public async updateActivities(activities: ActivityInRemote[]) {
         try {
             // console.log('******* activities', activities)
@@ -62,9 +53,9 @@ export class ActivityRemote {
         }
     }
 
-    public async saveGroupToServer(groupId: number, serverIds: number[]) {
+    public async saveGroupToServer(groupId: number[], serverIds: number[]) {
         try {
-            this.saveGroupToServer(groupId, serverIds);
+            saveGroupToServer(groupId, serverIds);
         } catch(e) {
             errlogger.error(`remote ${__filename} \n ${e.stack}`);
         }

game-server/app/servers/gm/handler/gmHandler.ts

@@ -154,11 +154,8 @@ export class GmHandler {
     async updateActivityGroup(msg: { groupId: number, serverIds: number[], activityIds: number[] }, session: BackendSession) {
         const uid = session.get('uid');
         let { groupId, serverIds, activityIds } = msg;
-        let activityServers = pinus.app.getServersByType('activity');
-        for(let server of activityServers) {
-            pinus.app.rpc.activity.activityRemote.saveActivitiesToGroup.toServer(server.id, groupId, activityIds);
-            pinus.app.rpc.activity.activityRemote.saveGroupToServer.toServer(server.id, groupId, serverIds);
-        }
+        pinus.app.rpc.activity.activityRemote.saveActivitiesToGroup.broadcast(groupId, activityIds);
+        pinus.app.rpc.activity.activityRemote.saveGroupToServer.broadcast([groupId], serverIds);
         return resResult(STATUS.SUCCESS);
     }
 

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

@@ -1,11 +1,6 @@
-import { Application, ChannelService, HandlerService, pinus, } from 'pinus';
-import { ActivityModel, ActivityModelType } from '../../db/Activity';
-import { ServerlistModel } from '../../db/Serverlist';
-import { reloadResources } from '../../pubUtils/data';
-import { getServerMainten, setServerMainten, stopServerMainten } from '../../services/gmService';
-import { taflush } from '../../services/sdkService';
+import { pinus, } from 'pinus';
+import { ActivityModel } from '../../db/Activity';
 import { ActivityInRemote } from '../../domain/activityField/activityField';
-import { errlogger } from '../../util/logger';
 import { ActivityGroupModel } from '../../db/ActivityGroup';
 
 const activityByServer: Map<number, number[]> = new Map();  // serverId => activityId[];
@@ -20,6 +15,22 @@ export function clearData() {
     groupToServer.clear();
 }
 
+function updateActivityByType(_activityByType: Map<number, Map<number, number[]>>) {
+    activityByType.clear();
+    for(let [serverId, map] of _activityByType) {
+        activityByType.set(serverId, map);
+    }
+    pinus.app.set('activityByServer', activityByType);
+}
+
+function updateActivityByServer(_activityByServer: Map<number, number[]>) {
+    activityByServer.clear();
+    for(let [serverId, arr] of _activityByServer) {
+        activityByServer.set(serverId, arr);
+    }
+    pinus.app.set('activityByServer', activityByServer);
+}
+
 export async function loadActivities() {
     clearData();
     let activityGroup = await ActivityGroupModel.findAllActivityGroup();
@@ -47,32 +58,30 @@ export async function loadActivities() {
 }
 
 export async function setActivityTypeAndServer() {
-    
-    activityByServer.clear();
-    activityByType.clear();
+    let _activityByServer: Map<number, number[]> = new Map();  // serverId => activityId[];
+    let _activityByType: Map<number, Map<number, number[]>> = new Map();
 
     for(let [_, activity] of activities) {
         let servers = groupToServer.get(activity.groupId)||[];
         for(let serverId of servers) {
-            if(!activityByServer.has(serverId)) {
-                activityByServer.set(serverId, []);
+            if(!_activityByServer.has(serverId)) {
+                _activityByServer.set(serverId, []);
             }
-            activityByServer.get(serverId).push(activity.activityId);
+            _activityByServer.get(serverId).push(activity.activityId);
 
-            if(!activityByType.has(serverId)) {
-                activityByType.set(serverId, new Map());
+            if(!_activityByType.has(serverId)) {
+                _activityByType.set(serverId, new Map());
             }
-            if(!activityByType.get(serverId).has(activity.type)) {
-                activityByType.get(serverId).set(activity.type, []);
+            if(!_activityByType.get(serverId).has(activity.type)) {
+                _activityByType.get(serverId).set(activity.type, []);
             }
-            activityByType.get(serverId).get(activity.type).push(activity.activityId);
+            _activityByType.get(serverId).get(activity.type).push(activity.activityId);
         }
     }
+    updateActivityByServer(_activityByServer);
+    updateActivityByType(_activityByType);
+    
 
-    pinus.app.set('activityByServer', activityByServer);
-    pinus.app.set('activityByType', activityByType);
-    pinus.app.set('activities', activities);
-    pinus.app.set('groupToServer', groupToServer);
 }
 
 export function updateActivities(activityDb: ActivityInRemote[]) {
@@ -93,9 +102,10 @@ export function deleteActivities(activityIds: number[]) {
     setActivityTypeAndServer();
 }
 
-export function saveGroupToServer(groupId: number, serverIds: number[]) {
-
-    groupToServer.set(groupId, serverIds);
+export function saveGroupToServer(groupIds: number[], serverIds: number[]) {
+    for(let groupId of groupIds) {
+        groupToServer.set(groupId, serverIds);
+    }
     setActivityTypeAndServer();
 }
 

game-server/app/services/gmService.ts

@@ -191,9 +191,14 @@ export async function createNewServer(region: RegionType ,serverId: number, para
     if(params.circleMail) await sendOpenServerMail('circleMail', params.circleMail, newServer, uid);
     if(params.activityGroupId && params.activityGroupId.length > 0) {
         await ActivityGroupModel.addServerToGroupData(newServer.id, params.activityGroupId);
-        let activityServers = pinus.app.getServersByType('activity');
-        for(let server of activityServers) {
-            pinus.app.rpc.activity.activityRemote.loadActivities.toServer(server.id);
+        let activityGroups = await ActivityGroupModel.findByServerId(newServer.id);
+        await pinus.app.rpc.activity.activityRemote.saveGroupToServer.broadcast(params.activityGroupId, [newServer.id]);
+
+        let aids = activityGroups.reduce((pre, cur) => [...pre, ...cur.activities], []);
+        let activities = await ActivityModel.findActivityByIds(aids);
+        let timeLimitRanks = activities.filter(cur => cur.type == ACTIVITY_TYPE.TIME_LIMIT_RANK);
+        if(timeLimitRanks.length > 0) {
+            pinus.app.rpc.systimer.systimerRemote.updateTimeLimitRank.broadcast(timeLimitRanks);
         }
     }
     await RegionModel.newServer(region.id, newServer);