后台：服务器维护

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

@@ -3,6 +3,7 @@ import { ActivityModel, ActivityModelType } from '../../../db/Activity';
 import { ServerlistModel } from '../../../db/Serverlist';
 import { reloadResources } from '../../../pubUtils/data';
 import { _getActivitiesByType, _getActivityById, _getActivities } from '../../../services/activity/activityService';
+import { getServerMainten, setServerMainten, stopServerMainten } from '../../../services/gmService';
 
 export default function (app: Application) {
     new HandlerService(app, {});
@@ -30,8 +31,8 @@ export class ActivityRemote {
     }
 
     public async loadActivities() {
-        let servers = await ServerlistModel.getAllServerList();
+        let servers = await ServerlistModel.findByEnv(this.app.get('env'));
-        for(let { serverId, activityGroupId } of servers) {
+        for(let { id: serverId, activityGroupId } of servers) {
             for(let groupId of activityGroupId) {
                 if(!this.groupToServer.has(groupId)) {
                     this.groupToServer.set(groupId, []);
@@ -116,4 +117,16 @@ export class ActivityRemote {
     public getActivities() {
         return _getActivities();
     }
+
+    public setServerMainten(serverIds: number[], startTime: number, endTime: number) {
+        setServerMainten(serverIds, startTime, endTime);
+    }
+
+    public stopServerMainten(serverIds: number[]) {
+        stopServerMainten(serverIds);
+    }
+
+    public getServerMainten(serverId: number) {
+        return getServerMainten(serverId);
+    }
 }

game-server/app/servers/battle/remote/battleRemote.ts

@@ -1,6 +1,7 @@
 import { Application, ChannelService, FrontendSession, RemoterClass, HandlerService, } from 'pinus';
 import { PVPConfigType } from '../../../db/SystemConfig';
 import { reloadResources } from '../../../pubUtils/data';
+import { getServerMainten, setServerMainten, stopServerMainten } from '../../../services/gmService';
 
 export default function (app: Application) {
     new HandlerService(app, {});
@@ -87,4 +88,16 @@ export class BattleRemote {
             this.app.set('pvpSeasonEndTime', pvpConfig.seasonEndTime);
         }
     }
+
+    public setServerMainten(serverIds: number[], startTime: number, endTime: number) {
+        setServerMainten(serverIds, startTime, endTime);
+    }
+
+    public stopServerMainten(serverIds: number[]) {
+        stopServerMainten(serverIds);
+    }
+
+    public getServerMainten(serverId: number) {
+        return getServerMainten(serverId);
+    }
 }

game-server/app/servers/chat/remote/chatRemote.ts

@@ -13,6 +13,7 @@ import { MailParam } from '../../../domain/roleField/mail';
 import { RankFirstType } from '../../../db/RankFirst';
 import { LotType } from '../../../db/Lot';
 import { _checkFilterWords, getTire } from '../../../services/sdkService';
+import { getServerMainten, setServerMainten, stopServerMainten } from '../../../services/gmService';
 
 export default function (app: Application) {
     new HandlerService(app, {});
@@ -289,4 +290,16 @@ export class ChatRemote {
     public async checkFilterWords(word: string) {
         return await _checkFilterWords(word);
     }
+
+    public setServerMainten(serverIds: number[], startTime: number, endTime: number) {
+        setServerMainten(serverIds, startTime, endTime);
+    }
+
+    public stopServerMainten(serverIds: number[]) {
+        stopServerMainten(serverIds);
+    }
+
+    public getServerMainten(serverId: number) {
+        return getServerMainten(serverId);
+    }
 }

game-server/app/servers/connector/filter/global.ts

@@ -6,6 +6,8 @@ import { resResult, checkWhiteListWithUid, genCode } from "../../../pubUtils/uti
 import { BLOCK_TYPE, CHANNEL_PREFIX, MSG_TYPE, STATUS } from "../../../consts";
 import { UserModel } from "../../../db/User";
 import { SERVER_DEBUG_MODE } from "../../../pubUtils/dicParam";
+import { nowSeconds } from "../../../pubUtils/timeUtil";
+import { getServerMainten } from "../../../services/gmService";
 export function globalFilter(app: Application) {
     return new Filter(app);
 }
@@ -37,13 +39,17 @@ Filter.prototype.before = async function (routeRecord: RouteRecord, msg: any, se
 
     session.push('teamCode', () => {});
 
-    const maintenServers = this.app.get('maintenServers');
+    if(sid) {
-    if(maintenServers && maintenServers.indexOf(serverId) != -1) { // 该服务器维护
+        const mainten = getServerMainten(serverId);
-        let isWhiteList = await checkWhiteListWithUid(uid);
+        console.log('***** maintenServers', mainten)
-        if(isWhiteList) return next(null);
+        if(mainten) { // 该服务器维护
+            if(mainten.startTime > nowSeconds() || mainten.endTime < nowSeconds()) return next(null)
+            let isWhiteList = await checkWhiteListWithUid(uid);
+            if(isWhiteList) return next(null);
     
-        pinus.app.get('channelService').pushMessageByUids('onServerMaintenance', resResult(STATUS.SERVER_MAINTENANCE), [{ uid: roleId, sid }]);
+            pinus.app.get('channelService').pushMessageByUids('onServerMaintenance', resResult(STATUS.SERVER_MAINTENANCE), [{ uid: roleId, sid }]);
-        return next(new Error(), resResult(STATUS.SERVER_MAINTENANCE));
+            return next(new Error(), resResult(STATUS.SERVER_MAINTENANCE));
+        }
     }
 
     let hasBlockWords = false;

game-server/app/servers/connector/remote/connectorRemote.ts

@@ -6,6 +6,7 @@ import { UserGuildType } from '../../../db/UserGuild';
 import { kickUser } from '../../../services/connectorService';
 import { PVPConfigType } from '../../../db/SystemConfig';
 import { setDicAuctionTime } from '../../../services/guildActivityService';
+import { getServerMainten, setServerMainten, stopServerMainten } from '../../../services/gmService';
 export default function (app: Application) {
     new HandlerService(app, {});
     return new ConnectorRemote(app);
@@ -16,7 +17,6 @@ export class ConnectorRemote {
     constructor(private app: Application) {
         this.app = app;
     }
-    private maintenServers: number[] = []; // 维护中的服务器
 
     public async remoteLogin(uid: string, message?: any) {
         await kickUser(this.app, uid, message);
@@ -69,13 +69,16 @@ export class ConnectorRemote {
         reloadResources();
     }
 
-    public setServerMainten(maintenServers: number[]) {
+    public setServerMainten(serverIds: number[], startTime: number, endTime: number) {
-        this.app.set('maintenServers', maintenServers);
+        setServerMainten(serverIds, startTime, endTime);
-        return this.maintenServers = maintenServers;
     }
 
-    public getServerMainten() {
+    public stopServerMainten(serverIds: number[]) {
-        return this.maintenServers;
+        stopServerMainten(serverIds);
+    }
+
+    public getServerMainten(serverId: number) {
+        return getServerMainten(serverId);
     }
 
     public setPvpSeasonNum(pvpConfig: PVPConfigType) {

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

@@ -12,8 +12,6 @@ import { RewardInter } from '../../../pubUtils/interface';
 import { MarqueeModel } from '../../../db/Marquee';
 import { ServerlistModel } from '../../../db/Serverlist';
 import { pushCurrentTime } from '../../../services/chatService';
-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';
@@ -156,31 +154,6 @@ export class GmHandler {
         return resResult(STATUS.SUCCESS);
     }
 
-    async startMaintenance(msg: { code: string }, session: BackendSession) {
-        const { code } = msg;
-        const uid = session.get('uid');
-        const maintenance = await MaintenanceModel.updateStatusByCode(code, true, uid);
-        if (!maintenance) return resResult(STATUS.WRONG_PARMS);
-        await initMaintenance(maintenance);
-
-        return resResult(STATUS.SUCCESS,);
-    }
-
-    async stopMaintenance(msg: { code: string }, session: BackendSession) {
-        const { code } = msg;
-        const uid = session.get('uid');
-        const maintenance = await MaintenanceModel.updateStatusByCode(code, false, uid);
-        if (!maintenance) return resResult(STATUS.WRONG_PARMS);
-        await stopMaintenance(maintenance, uid);
-
-        return resResult(STATUS.SUCCESS,);
-    }
-
-    async setMaintenance() {
-        pinus.app.rpc.connector.connectorRemote.setServerMainten.broadcast([1]);
-        return resResult(STATUS.SUCCESS);
-    }
-
     async updateActivity(msg: { activityId: number|string, groupId: number, beginTime: number, endTime: number, type: number, data: string }, session: BackendSession) {
         const { activityId, groupId, beginTime, endTime, type, data } = msg;
         const uid = session.get('uid');

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

@@ -1,14 +1,17 @@
 import { Application, BackendSession, pinus } from 'pinus';
-import { getRandSingleEelm, resResult } from '../../../pubUtils/util';
+import { genCode, getRandSingleEelm, resResult } from '../../../pubUtils/util';
 import { STATUS } from '../../../consts/statusCode';
 import moment = require('moment');
 import { CreateServerParam, UpdateRegionParams } from '../../../domain/backEndField/params';
 import { RegionModel } from '../../../db/Region';
 import { gameData } from '../../../pubUtils/data';
-import { ServerlistModel } from '../../../db/Serverlist';
+import { Maintenance, ServerlistModel } from '../../../db/Serverlist';
 import { nowSeconds } from '../../../pubUtils/timeUtil';
 import { GM_MAIL_TYPE, MAIL_TIME_TYPE, REF_CIRCLE_MAIL_TIME } from '../../../consts';
 import { SendMailFun } from '../../../services/mailService';
+import { sendOpenServerMail } from '../../../services/gmService';
+import { initMaintenance, stopMaintenance } from '../../../services/timeTaskService';
+import { isNumber } from 'util';
 let timer: NodeJS.Timer;
 export default function (app: Application) {
     return new GmHandler(app);
@@ -18,6 +21,7 @@ export class GmHandler {
     constructor(private app: Application) {
     }
 
+    // 保存大区配置
     async saveRegionConf(msg: UpdateRegionParams, session: BackendSession) {
         let params = new UpdateRegionParams(msg);
         let uid = session.get('uid');
@@ -34,10 +38,13 @@ export class GmHandler {
         return resResult(STATUS.SUCCESS);
     }
 
+    // 手动开服
     async createNewServer(msg: CreateServerParam, session: BackendSession) {
         let params = new CreateServerParam(msg);
         let uid = session.get('uid');
         if(!params.checkParams()) return resResult(STATUS.WRONG_PARMS);
+
+        console.log('*******', params);
         let curRegion = await RegionModel.findRegionByEnv(params.env);
         if(!curRegion) return resResult(STATUS.WRONG_PARMS);
 
@@ -46,26 +53,35 @@ export class GmHandler {
         if(!dicServerName) return resResult(STATUS.DIC_DATA_NOT_FOUND);
 
         let newServer = await ServerlistModel.newServer(params, curRegion, dicServerName, uid);
-        let mails = [ params.openMail, params.circleMail ];
+        if(params.openMail) await sendOpenServerMail('openMail', params.openMail, newServer, uid);
-        for(let mail of mails) {
+        if(params.circleMail) await sendOpenServerMail('circleMail', params.circleMail, newServer, uid);
-            let needSend = false;
+        await RegionModel.newServer(curRegion.id, newServer)
-            if(mail.timeType == MAIL_TIME_TYPE.CIRCLE) {
-                let refTime = moment(moment().format(`YYYY-MM-DD ${REF_CIRCLE_MAIL_TIME}:00:00`)).unix();
-                let sendTime = moment(moment().format('YYYY-MM-DD '+ mail.circleHour)).unix();
-                if(sendTime < refTime) sendTime += 86400;
-                let now = nowSeconds();
-                if(refTime < now && sendTime > now) {
-                    needSend = true;
-                }
-            } else {
-                needSend = true;
-            }
-            if(needSend) {
-                let f = new SendMailFun();
-                await f.setWithGmMail(mail);
-                await f.sendToServer([newServer.id]);
-            }
-        }
         return resResult(STATUS.SUCCESS);
     }
+
+    // 开始维护
+    async startMaintenance(msg: { id: number, startTime: number, endTime: number, hasNotify: boolean }, session: BackendSession) {
+        const { id, startTime, endTime, hasNotify } = msg;
+        if(!id || !isNumber(startTime) || !isNumber(endTime)) return resResult(STATUS.WRONG_PARMS);
+        const uid = session.get('uid');
+        let newMaintenance: Maintenance = { batchCode: genCode(10), startTime, endTime, hasNotify, isOpen: true }
+        let server = await ServerlistModel.updateByServerId(id, { maintenance: newMaintenance });
+        await pinus.app.rpc.systimer.systimerRemote.initMaintenance.broadcast([server]);
+
+        return resResult(STATUS.SUCCESS,);
+    }
+
+    // 提前结束维护
+    async stopMaintenance(msg: { id: number }, session: BackendSession) {
+        const { id } = msg;
+        const uid = session.get('uid');
+        let server = await ServerlistModel.findByServerId(id);
+        let maintenance = server.maintenance;
+        if(maintenance) {
+            // console.log('&&&', server, server.id)
+            await pinus.app.rpc.systimer.systimerRemote.stopMaintenance.broadcast(maintenance.batchCode, [server.id]);
+        }
+
+        return resResult(STATUS.SUCCESS,);
+    }
 }

game-server/app/servers/guild/remote/guildRemote.ts

@@ -1,6 +1,7 @@
 import { Application, ChannelService, HandlerService, } from 'pinus';
 import { reloadResources } from '../../../pubUtils/data';
 import { treatGuildName } from '../../../services/sdkService';
+import { getServerMainten, setServerMainten, stopServerMainten } from '../../../services/gmService';
 
 export default function (app: Application) {
     new HandlerService(app, {});
@@ -26,4 +27,16 @@ export class GuildRemote {
     public async treatGuildName(content: string) {
         await treatGuildName(content);
     }
+
+    public setServerMainten(serverIds: number[], startTime: number, endTime: number) {
+        setServerMainten(serverIds, startTime, endTime);
+    }
+
+    public stopServerMainten(serverIds: number[]) {
+        stopServerMainten(serverIds);
+    }
+
+    public getServerMainten(serverId: number) {
+        return getServerMainten(serverId);
+    }
 }

game-server/app/servers/order/remote/orderRemote.ts

@@ -1,6 +1,7 @@
 import { Application, ChannelService, HandlerService, } from 'pinus';
 import { reloadResources } from '../../../pubUtils/data';
 import { settleOrderFromRedisPub } from '../../../services/orderService';
+import { getServerMainten, setServerMainten, stopServerMainten } from '../../../services/gmService';
 
 export default function (app: Application) {
     new HandlerService(app, {});
@@ -26,4 +27,16 @@ export class OrderRemote {
     public async settleOrderFromRedisPub(message: string) {
         await settleOrderFromRedisPub(message);
     }
+
+    public setServerMainten(serverIds: number[], startTime: number, endTime: number) {
+        setServerMainten(serverIds, startTime, endTime);
+    }
+
+    public stopServerMainten(serverIds: number[]) {
+        stopServerMainten(serverIds);
+    }
+
+    public getServerMainten(serverId: number) {
+        return getServerMainten(serverId);
+    }
 }

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

@@ -11,6 +11,8 @@ import { Figure } from '../../../domain/dbGeneral';
 import { getDefaultRoleInfo } from '../../../services/roleService';
 import { PVPConfigType } from '../../../db/SystemConfig';
 import { treatRoleName } from '../../../services/sdkService';
+import { getServerMainten, setServerMainten, stopServerMainten } from '../../../services/gmService';
+
 export default function (app: Application) {
     new HandlerService(app, {});
     return new RoleRemote(app);
@@ -121,4 +123,16 @@ export class RoleRemote {
     public async treatRoleName(roleId: string) {
         await treatRoleName(roleId);
     }
+
+    public setServerMainten(serverIds: number[], startTime: number, endTime: number) {
+        setServerMainten(serverIds, startTime, endTime);
+    }
+
+    public stopServerMainten(serverIds: number[]) {
+        stopServerMainten(serverIds);
+    }
+
+    public getServerMainten(serverId: number) {
+        return getServerMainten(serverId);
+    }
 }

game-server/app/servers/systimer/remote/systimerRemote.ts

@@ -1,11 +1,12 @@
 import { Application, ChannelService } from 'pinus';
-import { resetPvpSeasonTime, guildActivityStart, gateActivityEnd, cityActivityEnd, raceActivityEnd, guildActivitySchedule, auctionSchedule } from '../../../services/timeTaskService';
+import { resetPvpSeasonTime, guildActivityStart, gateActivityEnd, cityActivityEnd, raceActivityEnd, guildActivitySchedule, auctionSchedule, initMaintenance, stopMaintenance } from '../../../services/timeTaskService';
 import PvpDefenseType from '../../../db/PvpDefense';
 import { DicGuildActivity } from '../../../pubUtils/dictionary/DicGuildActivity';
 import { reloadResources } from '../../../pubUtils/data';
 import { setMarquee, cancelMarquee } from '../../../services/gmService';
 import { setDicAuctionTime, setDicGuildActivity } from '../../../services/guildActivityService';
 import { setWeek } from '../../../pubUtils/timeUtil';
+import { ServerlistType } from '../../../db/Serverlist';
 
 export default function (app: Application) {
     return new SystimerRemote(app);
@@ -89,4 +90,12 @@ export class SystimerRemote {
      async setDay(week: number) {
         setWeek(week);
     }
+
+    public async initMaintenance(servers?: ServerlistType[]) {
+        await initMaintenance(servers);
+    }
+
+    public async stopMaintenance(batchCode: string, serverIds: number[]) {
+        await stopMaintenance(batchCode, serverIds);
+    }
 }

game-server/app/services/gmService.ts

@@ -1,15 +1,16 @@
 import { MarqueeType, MarqueeModel } from "../db/Marquee";
-import { MARQUEE_TYPE, SERVER_STATUS } from "../consts";
+import { GM_MAIL_STATUS, MAIL_TIME_TYPE, MARQUEE_TYPE, REF_CIRCLE_MAIL_TIME, 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 { MaintenanceModel, MaintenanceType } from '../db/Maintenance';
 import { pinus } from "pinus";
 import { getWorldChannelSid } from "./chatChannelService";
-import { ServerlistModel } from "../db/Serverlist";
+import { ServerlistModel, ServerlistType } from "../db/Serverlist";
 import { NoticeModel, NoticeType } from "../db/Notice";
 import { SendMailFun } from "./mailService";
-import { GMMailType } from '../db/GMMail';
+import GMMail, { GMMailModel, GMMailType } from '../db/GMMail';
+import moment = require("moment");
+import { getSeconds, nowSeconds } from "../pubUtils/timeUtil";
 
 // —————————————— 跑马灯 —————————————— //
 // 初始
@@ -103,69 +104,132 @@ export async function cancelMarquee(code: string) {
 
 // —————————————— 停服维护 —————————————— //
 // 维护信息
-export async function initMaintenance(maintenance?: MaintenanceType) {
+// export async function initMaintenance() {
-    if(!maintenance) 
+//     let servers = await ServerlistModel.findByEnv(pinus.app.get('env'));
-        maintenance = await MaintenanceModel.findOpenMaintenance();
+//     for(let server of servers) 
-    if(maintenance) {
+//     // if(!maintenance) 
-        let { startTime, marquee } = maintenance;
+//     //     maintenance = await MaintenanceModel.findOpenMaintenance();
-        if(marquee) {
+//     // if(maintenance) {
-            let result = await generateMarqueeSchedule(<MarqueeType>marquee);
+//     //     let { startTime, marquee } = maintenance;
-            // console.log(result);
+//     //     if(marquee) {
-        }
+//     //         let result = await generateMarqueeSchedule(<MarqueeType>marquee);
-        if(Date.now() > startTime.getTime()) {
+//     //         // console.log(result);
-            await startMaintenance(maintenance);
+//     //     }
-        } else {
+//     //     if(Date.now() > startTime.getTime()) {
-            let startJob = scheduleJob(`startMainten${maintenance.code}`, startTime.getTime(), async () => {
+//     //         await startMaintenance(maintenance);
-                await startMaintenance(maintenance, startJob);
+//     //     } else {
-            });
+//     //         let startJob = scheduleJob(`startMainten${maintenance.code}`, startTime.getTime(), async () => {
+//     //             await startMaintenance(maintenance, startJob);
+//     //         });
+//     //     }
+//     }
+// }
+
+// // 开启维护
+// async function startMaintenance(maintenance: MaintenanceType, startJob?: Job) {
+//     // 向全服发送
+//     let { serverIds, notice } = maintenance;
+//     for(let serverId of serverIds) {
+//         let chatSid = await getWorldChannelSid(serverId);
+//         await pinus.app.rpc.chat.chatRemote.sendServerMaintenance.toServer(chatSid, serverId);
+//     }
+
+//     // 更新serverlist上的status
+//     await ServerlistModel.updateByServerIds(serverIds, { serverStatus: SERVER_STATUS.MAINTENANCE });
+//     // 更新notice的isEnable
+//     if(notice) {
+//         await NoticeModel.updateNotice((<NoticeType>notice).id, { isEnable: true });
+//     }
+    
+//     // 更新connectorRemote里面的维护服务器
+//     await pinus.app.rpc.connector.connectorRemote.setServerMainten.broadcast(serverIds);
+// }
+
+// // 停止维护
+// export async function stopMaintenance(maintenance: MaintenanceType, uid: number) {
+//     let { serverIds, notice, marquee, mail } = maintenance;
+//     // 更新serverlist上的status
+//     await ServerlistModel.updateByServerIds(serverIds, { serverStatus: SERVER_STATUS.HOT });
+//     // 更新notice的isEnable
+//     if(notice) {
+//         await NoticeModel.updateNotice((<NoticeType>notice).id, { isEnable: false });
+//     }
+
+//     // 更新connectorRemote里面的维护服务器
+//     let connectorServers = pinus.app.getServersByType('connector');
+//     for(let { id } of connectorServers) {
+//         await pinus.app.rpc.connector.connectorRemote.setServerMainten.toServer(id, []);
+//     }
+
+//     if(marquee) {
+//         await cancelMarquee((<MarqueeType>marquee).code);
+//     }
+//     console.log('*****', JSON.stringify(mail));
+//     if(mail) {
+//         let f = new SendMailFun();
+//         await f.setWithGmMail((<GMMailType>mail)._id);
+//         await f.sendToServer(serverIds);
+//         // await f.saveRecord(uid);
+//     }
+// }
+
+export async function sendOpenServerMail(type: 'openMail'|'circleMail', mail: GMMail, newServer: ServerlistType, uid: number) {
+    let receivers = [{ 
+        env: newServer.env,
+        serverId: newServer.id
+     }];
+     let addParam = {...mail, receivers, status: GM_MAIL_STATUS.PASS };
+     if(type == 'openMail') {
+         addParam.timeType = MAIL_TIME_TYPE.DELAY;
+         addParam.startTime = newServer.openTime;
+     }
+    let gmmail = await GMMailModel.addMail(addParam, uid);
+    let needSend = false;
+    if(mail.timeType == MAIL_TIME_TYPE.CIRCLE) {
+        let refTime = moment(moment().format(`YYYY-MM-DD ${REF_CIRCLE_MAIL_TIME}:00:00`)).unix();
+        let sendTime = moment(moment().format('YYYY-MM-DD '+ mail.circleHour)).unix();
+        if(sendTime < refTime) sendTime += 86400;
+        let now = nowSeconds();
+        if(refTime < now && sendTime > now) {
+            needSend = true;
         }
+    } else {
+        needSend = true;
     }
-}
+    if(needSend) {
-
-// 开启维护
-async function startMaintenance(maintenance: MaintenanceType, startJob?: Job) {
-    // 向全服发送
-    let { serverIds, notice } = maintenance;
-    for(let serverId of serverIds) {
-        let chatSid = await getWorldChannelSid(serverId);
-        await pinus.app.rpc.chat.chatRemote.sendServerMaintenance.toServer(chatSid, serverId);
-    }
-
-    // 更新serverlist上的status
-    await ServerlistModel.updateByServerIds(serverIds, { serverStatus: SERVER_STATUS.MAINTENANCE });
-    // 更新notice的isEnable
-    if(notice) {
-        await NoticeModel.updateNotice((<NoticeType>notice).id, { isEnable: true });
-    }
-    
-    // 更新connectorRemote里面的维护服务器
-    await pinus.app.rpc.connector.connectorRemote.setServerMainten.broadcast(serverIds);
-}
-
-// 停止维护
-export async function stopMaintenance(maintenance: MaintenanceType, uid: number) {
-    let { serverIds, notice, marquee, mail } = maintenance;
-    // 更新serverlist上的status
-    await ServerlistModel.updateByServerIds(serverIds, { serverStatus: SERVER_STATUS.HOT });
-    // 更新notice的isEnable
-    if(notice) {
-        await NoticeModel.updateNotice((<NoticeType>notice).id, { isEnable: false });
-    }
-
-    // 更新connectorRemote里面的维护服务器
-    let connectorServers = pinus.app.getServersByType('connector');
-    for(let { id } of connectorServers) {
-        await pinus.app.rpc.connector.connectorRemote.setServerMainten.toServer(id, []);
-    }
-
-    if(marquee) {
-        await cancelMarquee((<MarqueeType>marquee).code);
-    }
-    console.log('*****', JSON.stringify(mail));
-    if(mail) {
         let f = new SendMailFun();
-        await f.setWithGmMail((<GMMailType>mail)._id);
+        await f.setWithGmMail(gmmail);
-        await f.sendToServer(serverIds);
+        await f.sendToServer([newServer.id]);
-        // await f.saveRecord(uid);
     }
+    return true;
+}
+
+
+
+export function setServerMainten(serverIds: number[], startTime: number, endTime: number) {
+    let maintenServers = pinus.app.get('maintenServers')||new Map();
+    for(let id of serverIds) {
+        if(!maintenServers.has(id)) {
+            maintenServers.set(id, { startTime, endTime });
+        } else {
+            maintenServers.get(id).startTime = startTime;
+            maintenServers.get(id).endTime = endTime;
+        }
+    }
+    pinus.app.set('maintenServers', maintenServers);
+}
+
+export function stopServerMainten(serverIds: number[]) {
+    let maintenServers = pinus.app.get('maintenServers')||new Map();
+    for(let id of serverIds) {
+        if(maintenServers.has(id)) {
+            maintenServers.delete(id);
+        }
+    }
+    pinus.app.set('maintenServers', maintenServers);
+}
+
+export function getServerMainten(serverId: number) {
+    let maintenServers = pinus.app.get('maintenServers')||new Map();
+    return maintenServers.get(serverId);
 }

game-server/app/services/mailService.ts

@@ -109,7 +109,7 @@ export class SendMailFun {
     }
 
     // 从GMMail表读取数据
-    public async setWithGmMail(gmmail: GMMailTypeParam) {
+    public async setWithGmMail(gmmail: GMMailType) {
         this.gmmail = gmmail;
         this.contentId = 0;
         if(gmmail.timeType == MAIL_TIME_TYPE.IMMEDIATE) {

game-server/app/services/redisService.ts

@@ -17,7 +17,7 @@ import { getRandSingleEelm } from '../pubUtils/util';
  */
 export async function initAllRank() {
     console.log('******* initAllRank ******')
-    const serverList = await ServerlistModel.getAllServerList();
+    const serverList = await ServerlistModel?.findByEnv(pinus.app.get('env'))||[];
     await delKeys(REDIS_KEY.ONLINE_USERS);
     await delKeys(REDIS_KEY.USER_INFO);
     await delKeys(REDIS_KEY.GUILD_INFO);

game-server/app/services/timeTaskService.ts

@@ -1,11 +1,11 @@
 
-import { scheduleJob, Job, } from 'node-schedule';
+import { scheduleJob, Job, scheduledJobs, } from 'node-schedule';
 import { PVPConfigModel, PVPConfigType } from '../db/SystemConfig';
 import { nowSeconds, getTimeFun, getSeconds } from '../pubUtils/timeUtil';
 import { getTodayGuildActivity, gameData } from '../pubUtils/data';
 import { pvpSeasonEnd } from './pvpService';
 import { getAllOnlineRoles, getAllServers, delGuildActivityRank } from './redisService';
-import { GUILD_ACTIVITY_TYPE, REFRESH_TIME, SEND_NAME, SERVER_OPEN_TIME, COUNTER, AUCTION_TIME, GM_MAIL_TYPE } from '../consts';
+import { GUILD_ACTIVITY_TYPE, REFRESH_TIME, SEND_NAME, SERVER_OPEN_TIME, COUNTER, AUCTION_TIME, GM_MAIL_TYPE, SERVER_STATUS } from '../consts';
 import { RoleModel } from '../db/Role';
 import { pinus } from 'pinus';
 import { indexOf } from 'underscore';
@@ -19,13 +19,16 @@ import { dispatch } from '../pubUtils/dispatcher';
 import { Rank } from './rankService';
 import { checkTask } from './taskService';
 import { everydayRefresh } from './connectorService';
-import { initMarquee, initMaintenance } from './gmService';
+import { initMarquee } from './gmService';
 import moment = require('moment');
 import { CounterModel } from '../db/Counter';
 import { reportOneOnline } from './authenticateService';
 import { PVP } from '../pubUtils/dicParam';
 import { fetch37Words } from './sdkService';
 import { GMMailModel } from '../db/GMMail';
+import { Maintenance, ServerlistModel, ServerlistType, ServerlistUpdate } from '../db/Serverlist';
+import { getWorldChannelSid } from './chatService';
+import { createMarqueeMsg, pushMarqueeMsg } from './sysChatService';
 
 const PER_SECOND = 1 * 1000;
 const PER_DAY = 24 * 60 * 60;
@@ -397,3 +400,131 @@ async function sendCircleMail() {
         }
     }
 }
+
+
+/*** 维护 */
+
+let maintenInfos = new Map<string, { servers: ServerlistType[], maintenance: Maintenance }>(); // batchCode => {servers, maintenance}
+export async function initMaintenance(servers?: ServerlistType[]) {
+    if(!servers) servers = await ServerlistModel.findByEnv(pinus.app.get('env'));
+
+    console.log('#### initMaintenance', servers)
+
+    for(let server of servers) {
+        let { maintenance } = server;
+        if(maintenance && maintenance.isOpen) {
+            if(!maintenInfos.has(maintenance.batchCode)) {
+                maintenInfos.set(maintenance.batchCode, { servers: [], maintenance });
+            }
+            maintenInfos.get(maintenance.batchCode).servers.push(server);
+        }
+    }
+    for(let [batchCode] of maintenInfos) {
+        await setMaintenance(batchCode);
+    }
+}
+
+// 设置维护
+async function setMaintenance(batchCode: string) {
+    let { maintenance } = maintenInfos.get(batchCode);
+    let now = nowSeconds();
+    // 发送消息
+    if(maintenance.hasNotify && now < maintenance.startTime) {
+        if(now > maintenance.startTime - 5 * 60) {
+            maintenanceNotifySchedule(batchCode);
+        } else {
+            scheduleJob(`maintenNotify${batchCode}`, maintenance.startTime - 5 * 60, () => {
+                maintenanceNotifySchedule(batchCode);
+            })
+        }
+    } else {
+        if(scheduledJobs[`maintenNotify${batchCode}`]) scheduledJobs[`maintenNotify${batchCode}`].cancel();
+    }
+    // 开始维护
+    console.log('******* setMaintenance', now, now < maintenance.endTime, now > maintenance.startTime)
+    if(now < maintenance.endTime) {
+        if(now > maintenance.startTime) {
+            console.log('*******')
+            await startMaintenanceSchedule(batchCode);
+        } else {
+            scheduleJob(`startMainten${batchCode}`, maintenance.startTime * 1000, async () => {
+                await startMaintenanceSchedule(batchCode);
+            });
+        }
+    } else {
+        if(scheduledJobs[`startMainten${batchCode}`]) scheduledJobs[`startMainten${batchCode}`].cancel();
+    }
+
+}
+
+// 维护前通知
+async function maintenanceNotifySchedule(batchCode: string) {
+    let { servers, maintenance } = maintenInfos.get(batchCode);
+    if(scheduledJobs[`maintenNotify${batchCode}`]) scheduledJobs[`maintenNotify${batchCode}`].cancel();
+    if(scheduledJobs[`maintenSec${batchCode}`]) scheduledJobs[`maintenSec${batchCode}`].cancel();
+
+    scheduleJob(`maintenSec${batchCode}`, `0 */1 * * * *`, async () => {
+        for(let { id: serverId } of servers) {
+            let msgData = await createMarqueeMsg('', '系统', serverId, '服务器即将维护，请玩家提前退出游戏');
+            await pushMarqueeMsg(msgData);
+        }
+    })
+}
+
+// 开始维护
+async function startMaintenanceSchedule(batchCode: string) {
+    let { servers, maintenance } = maintenInfos.get(batchCode);
+    let serverIds = servers.map(cur => cur.id);
+    if(scheduledJobs[`maintenNotify${batchCode}`]) scheduledJobs[`maintenNotify${batchCode}`].cancel();
+    if(scheduledJobs[`maintenSec${batchCode}`]) scheduledJobs[`maintenSec${batchCode}`].cancel();
+    if(scheduledJobs[`startMainten${batchCode}`]) scheduledJobs[`startMainten${batchCode}`].cancel();
+
+    // 向全服发送
+    for(let { id: serverId } of servers) {
+        let chatSid = await getWorldChannelSid(serverId);
+        if(chatSid) {
+            await pinus.app.rpc.chat.chatRemote.sendServerMaintenance.toServer(chatSid, serverId);
+        }
+    }
+
+    // 更新serverlist上的status
+    await ServerlistModel.updateByServerIds(serverIds, { serverStatus: SERVER_STATUS.MAINTENANCE });
+    
+    // 更新connectorRemote里面的维护服务器
+    console.log('******** startMaintenanceSchedule', batchCode, serverIds, maintenance.startTime, maintenance.endTime)
+    pinus.app.rpc.connector.connectorRemote.setServerMainten.broadcast(serverIds, maintenance.startTime, maintenance.endTime);
+    pinus.app.rpc.activity.activityRemote.setServerMainten.broadcast(serverIds, maintenance.startTime, maintenance.endTime);
+    pinus.app.rpc.battle.battleRemote.setServerMainten.broadcast(serverIds, maintenance.startTime, maintenance.endTime);
+    pinus.app.rpc.chat.chatRemote.setServerMainten.broadcast(serverIds, maintenance.startTime, maintenance.endTime);
+    pinus.app.rpc.guild.guildRemote.setServerMainten.broadcast(serverIds, maintenance.startTime, maintenance.endTime);
+    pinus.app.rpc.order.orderRemote.setServerMainten.broadcast(serverIds, maintenance.startTime, maintenance.endTime);
+    pinus.app.rpc.role.roleRemote.setServerMainten.broadcast(serverIds, maintenance.startTime, maintenance.endTime);
+}
+
+// 提前结束维护
+export async function stopMaintenance(batchCode: string, serverIds: number[]) {
+    // console.log('***********', serverIds)
+    let { servers = [], maintenance = {} as Maintenance } = maintenInfos.get(batchCode)||{};
+    for(let id of serverIds) {
+        let index = servers.findIndex(cur => cur.id == id);
+        if(index != -1) servers.splice(index);
+    }
+    if(servers.length == 0) {
+        if(scheduledJobs[`maintenNotify${batchCode}`]) scheduledJobs[`maintenNotify${batchCode}`].cancel();
+        if(scheduledJobs[`maintenSec${batchCode}`]) scheduledJobs[`maintenSec${batchCode}`].cancel();
+        if(scheduledJobs[`startMainten${batchCode}`]) scheduledJobs[`startMainten${batchCode}`].cancel();
+        maintenInfos.delete(batchCode);
+    }
+
+    // 更新serverlist上的status
+    await ServerlistModel.updateByServerIds(serverIds, { serverStatus: SERVER_STATUS.HOT, 'maintenance.isOpen': false } as ServerlistUpdate);
+    
+    // 更新connectorRemote里面的维护服务器
+    pinus.app.rpc.connector.connectorRemote.stopServerMainten.broadcast(serverIds);
+    pinus.app.rpc.activity.activityRemote.stopServerMainten.broadcast(serverIds);
+    pinus.app.rpc.battle.battleRemote.stopServerMainten.broadcast(serverIds);
+    pinus.app.rpc.chat.chatRemote.stopServerMainten.broadcast(serverIds);
+    pinus.app.rpc.guild.guildRemote.stopServerMainten.broadcast(serverIds);
+    pinus.app.rpc.order.orderRemote.stopServerMainten.broadcast(serverIds);
+    pinus.app.rpc.role.roleRemote.stopServerMainten.broadcast(serverIds);
+}

gm-server/app/controller/game.ts

@@ -2,19 +2,19 @@ import { Controller } from 'egg';
 
 export default class GameController extends Controller {
 
-  public async getServerListByEnv() {
+  // public async getServerListByEnv() {
-    const { ctx } = this;
+  //   const { ctx } = this;
-    ctx.body = await ctx.service.game.getServerListByEnv();
+  //   ctx.body = await ctx.service.game.getServerListByEnv();
-    return 
+  //   return 
-  }
+  // }
 
-  public async getServerList() {
+  // public async getServerList() {
-    const { ctx } = this;
+  //   const { ctx } = this;
-    const { page, pageSize, sortField, sortOrder, form } = ctx.request.body;
+  //   const { page, pageSize, sortField, sortOrder, form } = ctx.request.body;
 
-    ctx.body = await ctx.service.game.getServerList(page, pageSize, sortField, sortOrder, form);
+  //   ctx.body = await ctx.service.game.getServerList(page, pageSize, sortField, sortOrder, form);
-    return
+  //   return
-  }
+  // }
 
   public async getRegions() {
     const { ctx } = this;

gm-server/app/router.ts

@@ -50,8 +50,8 @@ export default (app: Application) => {
   // router.post('/api/users/delgiftCode',  controller.users.delGiftCode);
   router.get('/api/users/getgiftcodedetails/:id/:filename', controller.users.getGiftCodeDetails);
 
-  router.post('/api/game/getserverlistbyenv', tokenParser, controller.game.getServerListByEnv);
+  // router.post('/api/game/getserverlistbyenv', tokenParser, controller.game.getServerListByEnv);
-  router.post('/api/game/getserverlist', controller.game.getServerList);
+  // router.post('/api/game/getserverlist', controller.game.getServerList);
   router.post('/api/game/getregions', controller.game.getRegions);
   router.post('/api/game/getservers', controller.game.getServers);
   router.post('/api/game/getregionstategy', controller.game.getRegionStategy);

gm-server/app/service/Game.ts

@@ -1,6 +1,6 @@
 import { Service } from 'egg';
 import { STATUS } from '@consts';
-import { GameModel } from '@db/Game';
+// import { GameModel } from '@db/Game';
 import { ServerlistModel } from '@db/Serverlist';
 import { gameData } from '@pubUtils/data';
 import { DicHero } from '@pubUtils/dictionary/DicHero';
@@ -21,27 +21,27 @@ export default class Game extends Service {
     /**
      * 获取正式服，测试服，开发服等环境
      */
-    public async getServerListByEnv() {
+    // public async getServerListByEnv() {
-        const { ctx, app } = this;
+    //     const { ctx, app } = this;
-        let env = app.config.env
+    //     let env = app.config.env
-        let serverEnv = await GameModel.getServerEnvList();
+    //     let serverEnv = await GameModel.getServerEnvList();
-        let curEnv = serverEnv.find(cur => cur.env == env);
+    //     let curEnv = serverEnv.find(cur => cur.env == env);
-        const list = await ServerlistModel.findByServerType(curEnv?.serverType);
+    //     const list = await ServerlistModel.findByServerType(curEnv?.serverType);
 
-        return ctx.service.utils.resResult(STATUS.SUCCESS, {
+    //     return ctx.service.utils.resResult(STATUS.SUCCESS, {
-            list
+    //         list
-        });
+    //     });
-    }
+    // }
 
-    public async getServerList(page: number, pageSize: number, sortField: string, sortOrder: string, form: { id?: number, serverId?: string|number, name?: string, groupName?: string, groupId?: number, serverType?: string } = {}) {
+    // public async getServerList(page: number, pageSize: number, sortField: string, sortOrder: string, form: { id?: number, serverId?: string|number, name?: string, groupName?: string, groupId?: number, serverType?: string } = {}) {
-        const { ctx } = this;
+    //     const { ctx } = this;
 
-        const list = await ServerlistModel.findByCondition(page, pageSize, sortField, sortOrder, form);
+    //     const list = await ServerlistModel.findByCondition(page, pageSize, sortField, sortOrder, form);
-        const total = await ServerlistModel.countByCondition( form )
+    //     const total = await ServerlistModel.countByCondition( form )
-        return ctx.service.utils.resResult(STATUS.SUCCESS, {
+    //     return ctx.service.utils.resResult(STATUS.SUCCESS, {
-            list, total
+    //         list, total
-        });
+    //     });
-    }
+    // }
 
 
     public async getRegions() {
@@ -57,6 +57,7 @@ export default class Game extends Service {
         const { ctx } = this;
 
         const list = await ServerlistModel.getAllServerList();
+        console.log('******', list)
         return ctx.service.utils.resResult(STATUS.SUCCESS, {
             list
         });

shared/consts/constModules/sysConst.ts

@@ -707,6 +707,7 @@ export enum SERVER_STATUS {
     HOT = 2,          // 火爆
     WILL_OPEN = 3,    // 即将开启
     MAINTENANCE = 4,  // 维护中 
+    HIDE = 0,  // 隐藏 
 }
 
 export enum WHITE_LIST_TYPE {

shared/db/Counter.ts

@@ -1,5 +1,5 @@
 import BaseModel from './BaseModel';
-import { index, getModelForClass, prop, DocumentType, ReturnModelType, mongoose } from '@typegoose/typegoose';
+import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
 
 /**
   * 自增 ID

shared/db/GMMail.ts

@@ -23,8 +23,6 @@ export class Receiver {
     roleId?: string;
     @prop({ required: true })
     roleName?: string;
-    @prop({ required: true })
-    hasSend?: boolean;
 }
 
 export default class GMMail extends BaseModel {

shared/db/Maintenance.ts

@@ -1,107 +0,0 @@
-import BaseModel from './BaseModel';
-import { index, getModelForClass, prop, DocumentType, mongoose, Ref } from '@typegoose/typegoose';
-import Marquee, { MarqueeType } from './Marquee';
-import Notice, { NoticeType } from './Notice';
-import GMMail from './GMMail';
-import { genCode } from '../pubUtils/util';
-import { GMMailType } from './GMMail';
-
-/**
-  * 开服策略
-*/
-@index({ id: 1 })
-
-export default class Maintenance extends BaseModel {
-
-    @prop({ required: true })
-    code: string;          // 策略唯一标志
-
-    @prop({ required: true, type: Number })
-    serverIds: number[];    // 服务器类型
-
-    @prop({ required: true })
-    isOpen: boolean;       // 维护是否使用
-
-    @prop({ required: true })
-    startTime: Date;       // 维护开始时间
-
-    @prop({ ref: () => Marquee, type: mongoose.Schema.Types.ObjectId })
-    marquee: Ref<Marquee>;      // 跑马灯，连接到marquee表
-
-    @prop({ ref: () => Notice, type: mongoose.Schema.Types.ObjectId })
-    notice: Ref<Notice>;        // 维护公告
-
-    @prop({ ref: () => GMMail, type: mongoose.Schema.Types.ObjectId })
-    mail: Ref<GMMail>;          // 维护结束邮件
-
-
-    public static async createData(values: MaintenanceTypeParam, marquee: MarqueeType, notice: NoticeType, mail: GMMailType, uid = 1) {
-        const code = genCode(8);
-        const rec: MaintenanceType = await MaintenanceModel.findOneAndUpdate({ code }, { 
-            $setOnInsert: {...values, code, isOpen: false, marquee: marquee._id, notice: notice._id, mail: mail._id, createdBy: uid}, $set: { updatedBy: uid }
-         }, { new: true, upsert: true }).lean();
-         return rec;
-    }
-
-    public static async updateData(code: string, values: MaintenanceTypeParam, uid = 1) {
-        const rec: MaintenanceType = await MaintenanceModel.findOneAndUpdate({ code }, { $set: { ...values, updatedBy: uid } }, { new: true, upsert: true })
-        .populate('marquee', 'code')
-        .populate('notice')
-        .populate('mail')
-        .lean();
-        return rec;
-    }
-
-    public static async findOpenMaintenance() {
-        const rec: MaintenanceType = await MaintenanceModel.findOne({ isOpen: true }, { _id: 0 }).populate('marquee').populate('notice').populate('mail').lean();
-        return rec;
-    }
-
-    public static async findByCode(code: string) {
-        const rec: MaintenanceType = await MaintenanceModel.findOne({ code }).populate('marquee').populate('notice').populate('mail').lean();
-        return rec;
-    }
-
-    public static async updateStatusByCode(code: string, isOpen: boolean, uid = 1) {
-        const rec: MaintenanceType = await MaintenanceModel.findOneAndUpdate({ code }, { $set: { isOpen, updatedBy: uid } }).populate('marquee').populate('notice').populate('mail').lean();
-        return rec;
-    }
-
-    private static getSearchObj(form: { isOpen?: boolean }) {
-        let searchObj = {};
-        if (form.isOpen) searchObj['isOpen'] = form.isOpen;
-        return searchObj
-    }
-
-    public static async findByCondition(page: number, pageSize: number, sortField: string, sortOrder: string, form: { isOpen?: boolean } = {}) {
-
-        let searchObj = this.getSearchObj(form);
-        let sort = {};
-        if (sortField && sortOrder) {
-            if (sortOrder == 'ascend') {
-                sort[sortField] = 1;
-            } else if (sortOrder == 'descend') {
-                sort[sortField] = -1;
-            }
-        }
-        const result: MaintenanceType[] = await MaintenanceModel.find(searchObj, { _id: 0 })
-        .populate('marquee').populate('notice', '+showStartTime +showEndTime').populate('mail')
-        .limit(pageSize).skip((page - 1) * pageSize).sort(sort).lean({ getters: true, virtuals: true });
-        return result;
-
-    }
-
-    public static async countByCondition(form: { isOpen?: boolean } = {}) {
-
-        let searchObj = this.getSearchObj(form);
-        const result = await MaintenanceModel.count(searchObj);
-        return result;
-    }
-
-
-}
-
-export const MaintenanceModel = getModelForClass(Maintenance);
-
-export interface MaintenanceType extends Pick<DocumentType<Maintenance>, keyof Maintenance> { }
-export type MaintenanceTypeParam = Partial<MaintenanceType>; // 将所有字段变成可选项

shared/db/Region.ts

@@ -3,6 +3,7 @@ import { CounterModel } from './Counter';
 import BaseModel from './BaseModel';
 import { index, getModelForClass, prop, DocumentType, mongoose, ReturnModelType } from '@typegoose/typegoose';
 import ServerStategy from './ServerStategy';
+import { ServerlistType } from './Serverlist';
 
 
 /**
@@ -35,6 +36,9 @@ export default class Region extends BaseModel {
     @prop({ required: true })
     latestServer: number;          // 最新服
 
+    @prop({ required: true })
+    latestServerUniqId: number;       // 最新服唯一id
+
     @prop({ required: true })
     serverCount: number;          // 总数
 
@@ -56,6 +60,13 @@ export default class Region extends BaseModel {
         return rec;
     }
 
+    public static async newServer(id: number, newServer: ServerlistType, uid = 1) {
+        const rec: RegionType = await RegionModel.findOneAndUpdate({ id }, { 
+            $set: { latestServer: newServer.serverId, latestServerUniqId: newServer.id, updatedBy: uid },
+            $inc: { serverCount: 1 }
+        }, { new: true }).lean();
+        return rec;
+    }
     public static async getAllRegion() {
         const rec: RegionType[] = await RegionModel.find().select('-_id -stategy').lean();
         return rec;

shared/db/Serverlist.ts

@@ -5,11 +5,31 @@ import { COUNTER, SERVER_STATUS } from '../consts';
 import { CreateServerParam } from '../domain/backEndField/params';
 import { RegionType } from './Region';
 import { DicServerName } from '../pubUtils/dictionary/DicServerName';
+import { nowSeconds } from '../pubUtils/timeUtil';
 
+export class Maintenance {
+
+  @prop({ required: true })
+  batchCode: string;       // 批次，如果是从大区列表维护就是一批的，小区列表上就是一服一个
+  
+  @prop({ required: true })
+  isOpen: boolean;       // 维护是否使用
+
+  @prop({ required: true })
+  startTime: number;       // 维护开始时间
+
+  @prop({ required: true })
+  endTime: number;       // 维护结束时间
+
+  @prop({ required: true })
+  hasNotify: boolean;       // 是否有维护通知
+
+}
 /**
   * 游戏字段接口
 */
 @index({ id: 1 })
+@index({ env: 1 })
 @modelOptions({ schemaOptions: { id: false } })
 export default class Serverlist extends BaseModel {
 
@@ -23,7 +43,7 @@ export default class Serverlist extends BaseModel {
   prefix: string;                // 前缀
 
   @prop({ required: true })
-  id: number;                // 小区id 自增
+  id: number;                // 小区id 自增，全大区共用自增counter，玩家role表中存的就是这个serverId
 
   @prop({ required: true })
   serverId: number;              // 相同serverType下的id，不同serverType下id一定不同，但是serverId可能相同
@@ -44,8 +64,7 @@ export default class Serverlist extends BaseModel {
   activityGroupId: number[];  // 活动组
 
   public get status() {
-    let now = new Date();
+    if (nowSeconds() > this.openTime) {
-    if (now > this.openTime) {
       return this.serverStatus;
     } else {
       return SERVER_STATUS.WILL_OPEN; // 未开服
@@ -53,10 +72,10 @@ export default class Serverlist extends BaseModel {
   }
 
   @prop({ required: true })
-  openTime: Date;
+  openTime: number;
 
   @prop({ required: true })
-  stopRegisterTime: Date;
+  stopRegisterTime: number;
 
   @prop({ required: true, default: true })
   canRegister: boolean;
@@ -67,6 +86,9 @@ export default class Serverlist extends BaseModel {
   @prop({ required: true, default: 0 })
   medianCe: number;          // 中位数武将战力、缩小10000倍后的结果
 
+  @prop({ required: true, type: Maintenance, _id: false })
+  maintenance: Maintenance
+
   public static async getAllServerList() {
     let id = await CounterAllModal.getCounter(COUNTER.SERVER);
     let result: ServerlistType[] = [];
@@ -79,7 +101,7 @@ export default class Serverlist extends BaseModel {
   }
 
   public static async findByServerId(serverId: number) {
-    let server: ServerlistType = await ServerlistModel.findOne({ id: serverId }).select('medianCe activityGroupId').lean({ getters: true, virtuals: true });
+    let server: ServerlistType = await ServerlistModel.findOne({ id: serverId }).lean({ getters: true, virtuals: true });
     return server;
   }
 
@@ -89,7 +111,7 @@ export default class Serverlist extends BaseModel {
   }
 
   public static async updateByServerId(serverId: number, update: ServerlistUpdate) {
-    let server: ServerlistType = await ServerlistModel.findOneAndUpdate({ id: serverId }, { $set: update }).lean({ getters: true, virtuals: true });
+    let server: ServerlistType = await ServerlistModel.findOneAndUpdate({ id: serverId }, { $set: update }, {new: true}).lean({ getters: true, virtuals: true });
     return server;
   }
 
@@ -98,19 +120,13 @@ export default class Serverlist extends BaseModel {
     return result;
   }
 
-  public static async updateGroupName(groupId: number, groupName: string) {
-    let server = await ServerlistModel.updateMany({ groupId }, { $set: { groupName } });
-    return server;
-  }
-
   public static async newServer(params: CreateServerParam, region: RegionType, dicServerName: DicServerName, uid = 1 ) {
     let { prefix, id: regionId, env } = region;
     // 分大区
     let id = await CounterAllModal.getNewCounter(COUNTER.SERVER);
-    let { openTime: openTimeNum, stopRegisterTime: hour, activityGroupId } = params;
+    let { openTime, stopRegisterTime: hour, activityGroupId } = params;
     let { id: serverId, sname: name, groupId, groupName } = dicServerName;
-    let openTime = new Date(openTimeNum * 1000);
+    let stopRegisterTime = openTime + hour * 60 * 60;
-    let stopRegisterTime = new Date(openTimeNum + hour * 60 * 60);
 
     const doc = new ServerlistModel();
     const update = Object.assign(doc.toJSON(), { 
@@ -124,49 +140,11 @@ export default class Serverlist extends BaseModel {
     return server;
   }
 
-  public static async findByServerType(serverType?: string) {
+  public static async findByEnv(env?: string) {
-    let condition = {};
+    let server: ServerlistType[] = await ServerlistModel.find({ env, serverStatus: { $gt: 0 } }).sort({ id: -1 }).lean({ getters: true, virtuals: true });
-    if(serverType) {
-      condition['serverType'] = serverType;
-    }
-    let server: ServerlistType[] = await ServerlistModel.find(condition).sort({ id: -1 }).lean({ getters: true, virtuals: true });
     return server;
   }
 
-  private static getSearchObj(form: { id?: number, serverId?: string|number, name?: string, groupName?: string, groupId?: number, serverType?: string }) {
-    let searchObj = {};
-    if (form.id != undefined) searchObj['id'] = form.id;
-    if (form.serverId != undefined) searchObj['serverId'] = form.serverId;
-    if (form.groupId != undefined) searchObj['groupId'] = form.groupId;
-    if (form.name != undefined) searchObj['name'] = { $regex: new RegExp(form.name.toString(), 'i') };
-    if (form.groupName != undefined) searchObj['groupName'] = { $regex: new RegExp(form.groupName.toString(), 'i') };
-    if (form.serverType != undefined) searchObj['serverType'] = form.serverType;
-    return searchObj
-  }
-
-  public static async findByCondition(page: number, pageSize: number, sortField: string, sortOrder: string, form: { id?: number, serverId?: string|number, name?: string, groupName?: string, groupId?: number, serverType?: string } = {}) {
-
-    let searchObj = this.getSearchObj(form);
-    let sort = {};
-    if(sortField && sortOrder) {
-        if(sortOrder == 'ascend') {
-            sort[sortField] = 1;
-        } else if (sortOrder == 'descend') {
-            sort[sortField] = -1;
-        }
-    }
-    const result: ServerlistType[] = await ServerlistModel.find(searchObj, { _id: 0 }).limit(pageSize).skip((page - 1) * pageSize).sort(sort).lean({ getters: true, virtuals: true });
-    return result;
-
-  }
-
-  public static async countByCondition(form: { id?: number, serverId?: string|number, name?: string, groupName?: string, groupId?: number, serverType?: string } = {}) {
-
-    let searchObj = this.getSearchObj(form);
-    const result = await ServerlistModel.count(searchObj);
-    return result;
-  }
-
   //根据多个活动id查询活动数据
   public static async findServerByIds(ids: number[]) {
     let result: ServerlistType[] = await ServerlistModel.find({ id: { $in: ids } }).lean();

shared/db/index.ts

@@ -10,6 +10,7 @@ import { loadGMMailModel } from './GMMail';
 import { loadCounterModal } from "./CounterAll";
 
 export function loadGmDb(connect: mongoose.Connection) {
+    // console.log('************')
     loadApiModel(connect);
     loadGMGroupModel(connect);
     loadGMUserModel(connect);

shared/domain/backEndField/params.ts

@@ -121,7 +121,9 @@ export class CreateServerParam {
     env: string = '';
     openTime: number = 0;
     activityGroupId: number[] = [];
+    hasOpenMail: boolean = false;
     openMail?: GMMail;
+    hasCircleMail: boolean = false;
     circleMail?: GMMail;
     stopRegisterTime: number = 0;
 
@@ -135,6 +137,8 @@ export class CreateServerParam {
         if(!this.env || !this.openTime  || !this.stopRegisterTime || !isArray(this.activityGroupId) || this.activityGroupId.length <= 0 ) {
             return false
         }
+        if(this.hasOpenMail && !this.openMail) return false;
+        if(this.hasCircleMail && !this.circleMail) return false;
         return true;
     }
 }

shared/domain/gameField/serverlist.ts

@@ -1,5 +1,4 @@
 import { RoleType } from '../../db/Role';
-import { getSeconds } from '../../pubUtils/timeUtil';
 import { ServerlistType } from '../../db/Serverlist';
 
 export class ServerParam {
@@ -15,10 +14,10 @@ export class ServerParam {
     constructor(server: ServerlistType) {
         this.id = server.id;
         this.serverId = server.serverId;
-        this.serverStr = `S${server.serverId}`;
+        this.serverStr = `${server.prefix}${server.serverId}`;
         this.name = server.name;
         this.status = server.status;
-        this.openTime = getSeconds(server.openTime);
+        this.openTime = server.openTime;
     }
 }
 
@@ -31,15 +30,17 @@ export class GroupParam {
     constructor(server: ServerlistType) {
         this.groupId = server.groupId;
         this.groupName = server.groupName;
-        this.groupStr = `S${server.serverId}-S${server.serverId + 9}`;
+        this.groupStr = `${server.prefix}${server.serverId}`;
         this.servers = new Array<ServerParam>();
     }
 
     public pushServer(server: ServerlistType) {
         let srv = new ServerParam(server);
         this.servers.push(srv);
-        let min = this.servers.reduce((pre, cur) => pre < cur? pre: cur);
+        this.servers.sort((a, b) => b.serverId - a.serverId);
-        this.groupStr = `${min.serverId}-${min.serverId + 9}`
+        let min = this.servers[this.servers.length - 1];
+        let max = this.servers[0];
+        this.groupStr = `${min.serverStr}-${max.serverStr}`
     }
 }
 

web-server/app/controller/game.ts

@@ -26,12 +26,12 @@ export default class GameController extends Controller {
 
     public async getServerList() {
         const { ctx } = this;
-        let { serverType, auth, uid, clientVersion } = ctx;
+        let { uid, clientVersion } = ctx;
         console.log('clientVersion', clientVersion);
         let serverList = new Array<GroupParam>();
         let loginServerList = new Array<ServerParamWithRole>();
 
-        let allServers = await ServerlistModel.findByServerType(auth == 1 ? null : serverType);
+        let allServers = await ServerlistModel.findByEnv(ctx.app.config.realEnv);
         let roles = await RoleModel.findAllByUid(uid, true, true);
         for (let server of allServers) {
             let curGroup = serverList.find(cur => cur.groupId == server.groupId);

web-server/app/service/Game.ts

@@ -1,6 +1,5 @@
 
 import { Service } from 'egg';
-import { MaintenanceModel } from '@db/Maintenance';
 
 /**
  * Test Service
@@ -12,14 +11,15 @@ export default class Game extends Service {
     // }
     
     public async getServerMainten() {
-        // return this.app['maintenServers']||[];
+    //     // return this.app['maintenServers']||[];
 
-        const maintenance = await MaintenanceModel.findOpenMaintenance();
+    //     const maintenance = await MaintenanceModel.findOpenMaintenance();
-        if(maintenance) {
+    //     if(maintenance) {
-            return maintenance.serverIds;
+    //         return maintenance.serverIds;
-        } else {
+    //     } else {
-            return [];
+    //         return [];
-        }
+    //     }
+    return []
     }
 
     // public async readDbMaintenance() {