活动：修改活动的时候改变内存

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

@@ -42,8 +42,23 @@ export class ActivityRemote {
         }
 
         let activities = await ActivityModel.findOpenAndComingActivityes();
+        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);
+    }
+
+    private setActivityTypeAndServer() {
+        this.activityByServer.clear();
+        this.activityByType.clear();
+
+        for(let [_, activity] of this.activities) {
             let servers = this.groupToServer.get(activity.activityId)||[];
             for(let serverId of servers) {
                 if(!this.activityByServer.has(serverId)) {
@@ -60,66 +75,34 @@ export class ActivityRemote {
                 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);
     }
 
     public async updateActivities(activities: ActivityModelType[]) {
+        let activityIds: number[] = [];
         for(let activity of activities) {
-            let { activityId, groupId, type } = activity;
+            this.activities.set(activity.activityId, activity);
-            // 'activities'
+            activityIds.push(activity.activityId);
-            this.activities.set(activityId, activity);
-            let serverIds = this.groupToServer.get(groupId)||[]; // 现在这个group对应的serverIds
-            // 'activityByServer' & 'activityByType'
-            // 将原来的都删掉，再塞入
-            for(let [serverId, activityIds] of this.activityByServer) {
-                let index = activityIds.indexOf(activityId);
-                if(index != -1) this.activityByServer.get(serverId).splice(index);
-            }
-            for(let [serverId, typeToActivities] of this.activityByType) {
-                for(let [type, activityIds] of typeToActivities) {
-                    let index = activityIds.indexOf(activityId);
-                    if(index != -1) this.activityByType.get(serverId).get(type).splice(index);
-                }
-            }
-            // 塞入
-            for(let serverId of serverIds) {
-                if(!this.activityByServer.has(serverId)) {
-                    this.activityByServer.set(serverId, []);
-                }
-                this.activityByServer.get(serverId).push(activityId);
-
-                if(!this.activityByType.has(serverId)) {
-                    this.activityByType.set(serverId, new Map());
-                }
-                if(!this.activityByType.get(serverId).has(type)) {
-                    this.activityByType.get(serverId).set(type, []);
-                }
-                this.activityByType.get(serverId).get(type).push(activityId);
-            }
-            
         }
+        this.setActivityTypeAndServer();
     }
 
     public async deleteActivities(activityIds: number[]) {
         for(let activityId of activityIds) {
-            // 'activities'
             this.activities.delete(activityId);
-            // 'activityByServer' & 'activityByType'
-            // 将原来的都删掉
-            for(let [serverId, activityIds] of this.activityByServer) {
-                let index = activityIds.indexOf(activityId);
-                if(index != -1) this.activityByServer.get(serverId).splice(index);
-            }
-            for(let [serverId, typeToActivities] of this.activityByType) {
-                for(let [type, activityIds] of typeToActivities) {
-                    let index = activityIds.indexOf(activityId);
-                    if(index != -1) this.activityByType.get(serverId).get(type).splice(index);
-                }
-            }
         }
+        this.setActivityTypeAndServer();
+    }
+
+    public async saveGroupToServer(groupId: number, serverIds: number[]) {
+        this.groupToServer.set(groupId, serverIds);
+        this.setActivityTypeAndServer();
+    }
+
+    public async saveActivitiesToGroup(groupId: number, activities: number[]) {
+        for(let activityId of activities) {
+            this.activities.get(activityId).groupId = groupId;
+        }
+        this.setActivityTypeAndServer();
     }
 
     public getActivityById(activityId: number) {

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

@@ -17,6 +17,8 @@ import { MaintenanceModel } from '../../../db/Maintenance';
 import { initMaintenance, stopMaintenance } from '../../../services/gmService';
 import { checkActivityEditable, checkActivityGroupType } from '../../../services/activity/activityService';
 import { ActivityModel } from '../../../db/Activity';
+import { ActivityGroupModel } from '../../../db/ActivityGroup';
+import { ActivityGroupTypeModel } from '../../../db/ActivityGroupType';
 export default function (app: Application) {
     return new GmHandler(app);
 }
@@ -261,4 +263,81 @@ export class GmHandler {
 
         return resResult(STATUS.SUCCESS);
     }
+
+    async saveGroupToServer(msg: { groupId: number, serverIds: number[] }, session: BackendSession) {
+        const { groupId, serverIds } = msg;
+        const uid = session.get('uid');
+        
+        await ServerlistModel.pullByGroupId(groupId);
+        let servers = await ServerlistModel.findServerByIds(serverIds);
+        for(let server of servers) {
+            let pushArr: number[] = [], pullArr: number[] = [];
+            let activityGroupId = server.activityGroupId||[];
+            if(!activityGroupId.includes(groupId)) {
+                pushArr.push(groupId);
+            }
+            await ServerlistModel.updateActivityGroup(server._id, pushArr, pullArr);
+        }
+        await ActivityGroupModel.updateServerData(groupId, serverIds, uid);
+
+        let activityServers = pinus.app.getServersByType('activity');
+        for(let server of activityServers) {
+            pinus.app.rpc.activity.activityRemote.saveGroupToServer.toServer(server.id, groupId, serverIds);
+        }
+
+        return resResult(STATUS.SUCCESS);
+    }
+
+    /**
+     * 选择活动组内的活动
+     */
+    async saveActivitiesToGroup(msg: { groupId: number, activities: number[] }, session: BackendSession) {
+        const { groupId, activities: activityIds } = msg;
+        const uid = session.get('uid');
+
+        let activities = await ActivityModel.findActivityByIds(activityIds);
+        let checkResult = await checkActivityGroupType(groupId, activities);
+        if(!checkResult) return resResult(STATUS.GM_ACTIVITY_NOT_FIT_GROUP_TYPE);
+
+        await ActivityGroupModel.setActivitiesToGroupData(groupId, activityIds, uid);
+    
+        let activityServers = pinus.app.getServersByType('activity');
+        for(let server of activityServers) {
+            pinus.app.rpc.activity.activityRemote.saveActivitiesToGroup.toServer(server.id, groupId, activityIds);
+        }
+        return resResult(STATUS.SUCCESS)
+    }
+
+    async saveSingleActivityToGroup(msg: { groupId: number, index: number, activityId: number }, session: BackendSession) {
+        const { groupId, index, activityId } = msg;
+        const uid = session.get('uid');
+        
+        let activity = await ActivityModel.findActivity(activityId);
+        if(!activity) return resResult(STATUS.ACTIVITY_MISSING);
+        let checkResult = await checkActivityGroupType(groupId, [activity]);
+        if(checkResult) return checkResult;
+
+        let activityGroup = await ActivityGroupModel.findGroupData(groupId);
+        if(!activityGroup) return resResult(STATUS.GM_ACTIVITY_GROUP_NOT_FOUND);
+
+        if(activityGroup.type != 0) {
+            let activityGroupType = await ActivityGroupTypeModel.findByGroupType(activityGroup.type);
+            if(!activityGroupType) return resResult(STATUS.GM_ACTIVITY_GROUP_TYPE_NOT_FOUND);
+            let dic = activityGroupType.activityTypes;
+            let curDic = dic.find(cur => cur.index == index);
+            console.log(dic, curDic)
+            if(curDic.activityType != activity.type) return resResult(STATUS.GM_ACTIVITY_NOT_FIT_GROUP_TYPE)
+        }
+
+        let activityIds = activityGroup.activities||[];
+        if(activityIds.indexOf(activityId) == -1) activityIds.push(activityId);
+
+        await ActivityGroupModel.setActivitiesToGroupData(groupId, activityIds, uid);
+    
+        let activityServers = pinus.app.getServersByType('activity');
+        for(let server of activityServers) {
+            pinus.app.rpc.activity.activityRemote.saveActivitiesToGroup.toServer(server.id, groupId, activityIds);
+        }
+        return resResult(STATUS.SUCCESS)
+    }
 }

game-server/app/services/gmService.ts

@@ -1,9 +1,8 @@
 import { MarqueeType, MarqueeModel } from "../db/Marquee";
-import { MARQUEE_TYPE, STATUS, SERVER_STATUS } from "../consts";
+import { MARQUEE_TYPE, SERVER_STATUS } from "../consts";
 import { scheduleJob, scheduledJobs, Job } from 'node-schedule';
 import { createMarqueeMsg as sysCreateMarqueeMsg, pushMarqueeMsg as sysPushMarqueeMsg } from './sysChatService';
 import { GroupMessageType } from "../db/GroupMessage";
-import { resResult } from "../pubUtils/util";
 import { MaintenanceModel, MaintenanceType } from '../db/Maintenance';
 import { pinus } from "pinus";
 import { getWorldChannelSid } from "./chatChannelService";

gm-server/app/router.ts

@@ -79,9 +79,9 @@ export default (app: Application) => {
   router.post('/api/activity/deleteactivity', tokenParser, controller.activity.deleteActivity);
   router.post('/api/activity/getactivitygrouplist', tokenParser, controller.activity.getActivityGroupList);
   router.post('/api/activity/updateactivitygroupname', controller.activity.updateActivityGroupName);
-  router.post('/api/activity/saveactivitiestogroup', tokenParser, controller.activity.saveActivitiesToGroup);
+  // router.post('/api/activity/saveactivitiestogroup', tokenParser, controller.activity.saveActivitiesToGroup);
-  router.post('/api/activity/savesingleactivitytogroup', controller.activity.saveSingleActivityToGroup);
+  // router.post('/api/activity/savesingleactivitytogroup', controller.activity.saveSingleActivityToGroup);
-  router.post('/api/activity/savegrouptoserver', tokenParser, controller.activity.saveGroupToServer);
+  // router.post('/api/activity/savegrouptoserver', tokenParser, controller.activity.saveGroupToServer);
   router.post('/api/activity/creategroup', tokenParser, controller.activity.createGroup);
   router.post('/api/activity/deletegroup', tokenParser, controller.activity.deleteGroup);
   router.post('/api/activity/getactivitygrouptypelist', controller.activity.getActivityGroupTypeList);