后台：停服维护

2021-07-16 15:33:28 +08:00
parent 4d1723b5c2
commit 23750e89b9
9 changed files with 211 additions and 37 deletions
--- a/game-server/app/servers/gm/handler/gmHandler.ts
+++ b/game-server/app/servers/gm/handler/gmHandler.ts
@@ -14,6 +14,8 @@ import { RewardInter } from '../../../pubUtils/interface';
 import { MarqueeModel } from '../../../db/Marquee';
 import { ServerlistModel } from '../../../db/Serverlist';
 import { getWorldChannelSid } from '../../../services/chatService';
+import { MaintenanceModel } from '../../../db/Maintenance';
+import { initMaintenance, stopMaintenance } from '../../../services/gmService';
 export default function(app: Application) {
    return new GmHandler(app);
 }
@@ -186,16 +188,24 @@ export class GmHandler {
        return resResult(STATUS.SUCCESS);
    }

-    async sendMaintenance(msg: { serverType: string }, session: BackendSession) {
-        const { serverType } = msg;
-        let allServers = await ServerlistModel.findByServerType(serverType);
-        let results = [];
-        for(let { serverId } of allServers) {
-            let chatSid = await getWorldChannelSid(serverId);
-            let result = await this.app.rpc.chat.chatRemote.sendServerMaintenance.toServer(chatSid, serverId);
-            results.push(result);
-        }
-        return resResult(STATUS.SUCCESS, results);
+    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);
+        
+        return resResult(STATUS.SUCCESS,);
    }

    async setMaintenance() {
--- a/game-server/app/services/gmService.ts
+++ b/game-server/app/services/gmService.ts
@@ -102,11 +102,15 @@ export async function cancelMarquee(code: string) {

 // —————————————— 停服维护 —————————————— //
 // 维护信息
-export async function initMaintenance() {
-    const maintenance = await MaintenanceModel.findOpenMaintenance();
+export async function initMaintenance(maintenance?: MaintenanceType) {
+    if(!maintenance) 
+        maintenance = await MaintenanceModel.findOpenMaintenance();
    if(maintenance) {
        let { startTime, marquee } = maintenance;
-        if(marquee) await generateMarqueeSchedule(<MarqueeType>marquee);
+        if(marquee) {
+            let result = await generateMarqueeSchedule(<MarqueeType>marquee);
+            console.log(result);
+        }
        if(Date.now() > startTime.getTime()) {
            await startMaintenance(maintenance);
        } else {
@@ -117,6 +121,7 @@ export async function initMaintenance() {
    }
 }

+// 开启维护
 async function startMaintenance(maintenance: MaintenanceType, startJob?: Job) {
    // 向全服发送
    let { serverIds, notice } = maintenance;
@@ -132,10 +137,31 @@ async function startMaintenance(maintenance: MaintenanceType, startJob?: Job) {
        await NoticeModel.updateNotice((<NoticeType>notice).id, { isEnable: true });
    }
    
-    // 更新connectorRemote里面的
+    // 更新connectorRemote里面的维护服务器
    let connectorServers = pinus.app.getServersByType('connector');
    for(let { id } of connectorServers) {
-        pinus.app.rpc.connector.connectorRemote.setServerMainten.toServer(id, serverIds);
+        await pinus.app.rpc.connector.connectorRemote.setServerMainten.toServer(id, serverIds);
+    }
+
+}
+
+// 停止维护
+export async function stopMaintenance(maintenance: MaintenanceType) {
+    let { serverIds, notice, marquee } = 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);
    }
-    if(startJob) startJob.cancel();
 }
--- a/gm-server/app/controller/game.ts
+++ b/gm-server/app/controller/game.ts
@@ -1,4 +1,5 @@
 import { Controller } from 'egg';
+import { STATUS } from '@consts';

 export default class GameController extends Controller {

@@ -22,6 +23,35 @@ export default class GameController extends Controller {
    return
  }

+  public async getMaintenanceList() {
+    const { ctx } = this;
+    const {page, pageSize, sortField, sortOrder, form} = ctx.request.body;
+
+    ctx.body = await ctx.service.game.getMaintenanceList(page, pageSize, sortField, sortOrder, form);
+    return
+  }
+
+  public async updateMaintenance() {
+    const { ctx } = this;
+    const {values, marquee, notice, mail} = ctx.request.body;
+
+    let goods = [];
+    try{
+      goods = JSON.parse(mail.goods);
+    } catch(e) {
+      ctx.body = ctx.service.utils.resResult(STATUS.GM_JSON_FORMAT_ERR);
+      return
+    }
+    console.log(goods)
+
+    ctx.body = await ctx.service.game.updateMaintenance(
+      {...values, startTime: new Date(values.startTime)}, 
+      {...marquee, startTime: new Date(marquee.startTime), endTime: new Date(marquee.endTime)},
+      {...notice, showStartTime: new Date(notice.showStartTime), showEndTime: new Date(notice.showEndTime), startTime: new Date(notice.startTime), endTime: new Date(notice.endTime)},
+      {...mail, goods});
+    return
+  }
+
  public async getServerStategyList() {
    const { ctx } = this;
    const { page, pageSize, sortField, sortOrder, form } = ctx.request.body;
--- a/gm-server/app/router.ts
+++ b/gm-server/app/router.ts
@@ -51,6 +51,10 @@ export default (app: Application) => {
  router.post('/api/game/getserverenv', tokenParser, controller.game.getServerEnv);
  router.post('/api/game/getserverlistbyenv', tokenParser, controller.game.getServerListByEnv);
  router.post('/api/game/getserverlist', controller.game.getServerList);
+
+  router.post('/api/game/getmaintenancelist', controller.game.getMaintenanceList);
+  router.post('/api/game/updatemaintenance', controller.game.updateMaintenance);
+
  router.post('/api/game/getdicgoods', tokenParser, controller.game.getDicGoods);
  router.post('/api/game/getdichero', tokenParser, controller.game.getDicHero);
  router.post('/api/game/getdicrmb', tokenParser, controller.game.getDicRMB);
--- a/gm-server/app/service/Game.ts
+++ b/gm-server/app/service/Game.ts
@@ -1,5 +1,5 @@
 import { Service } from 'egg';
-import { STATUS } from '@consts';
+import { STATUS, MARQUEE_TYPE } from '@consts';
 import { GameModel } from '@db/Game';
 import { ServerlistModel, ServerlistUpdate } from '@db/Serverlist';
 import { gameData } from '@pubUtils/data';
@@ -8,8 +8,10 @@ import { DicRMB } from '@pubUtils/dictionary/DicRMB';
 import { DicActivityType } from '@pubUtils/dictionary/DicActivityType';
 import { DicTaskType } from '@pubUtils/dictionary/DicTaskType';
 import { ServerStategyModel, ServerStategyTypeParam } from '@db/ServerStategy';
-import { NoticeModel, NoticeTypeParam } from '@db/Notice';
-import { MarqueeModel, MarqueeParam } from '@db/Marquee';
+import { NoticeModel, NoticeTypeParam, NoticeType } from '@db/Notice';
+import { MarqueeModel, MarqueeParam, MarqueeType } from '@db/Marquee';
+import { MaintenanceModel, MaintenanceTypeParam } from '@db/Maintenance';
+import { GMMailTypeParam, GMMailModel, GMMailType } from '@db/GMMail';

 /**
 * Test Service
@@ -44,7 +46,6 @@ export default class Game extends Service {
        });
    }

-
    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;

@@ -55,6 +56,47 @@ export default class Game extends Service {
        });
    }

+    public async getMaintenanceList(page: number, pageSize: number, sortField: string, sortOrder: string, form: { isOpen?: boolean } = {}) {
+        const { ctx } = this;
+
+        const list = await MaintenanceModel.findByCondition(page, pageSize, sortField, sortOrder, form);
+        const total = await MaintenanceModel.countByCondition( form )
+        return ctx.service.utils.resResult(STATUS.SUCCESS, {
+            list: list.map(cur => {
+                let marquee = <MarqueeType>cur.marquee;
+                let notice = <NoticeType>cur.notice;
+                return {
+                    ...cur, startTime: cur.startTime.getTime(),
+                    marquee: marquee?{...marquee, startTime: marquee.startTime.getTime(), endTime: marquee.endTime.getTime()}:null,
+                    notice: notice?{...notice, startTime: notice.startTime.getTime(), endTime: notice.endTime.getTime(), showStartTime: notice.showStartTime.getTime(), showEndTime: notice.showEndTime.getTime()}:null
+                }
+            }), total
+        });
+    }
+
+    public async updateMaintenance(values: MaintenanceTypeParam, marquee: MarqueeParam, notice: NoticeTypeParam, mail: GMMailTypeParam) {
+        const { ctx } = this;
+        if(values.code == 'new') {
+            let serverEnv = await GameModel.getServerEnvList();
+            let curEnv = serverEnv.find(cur => cur.env == this.app.config.env);
+    
+            let marqueeResult = await MarqueeModel.createData({ ...marquee, serverIds: values.serverIds, type: MARQUEE_TYPE.SCHEDULE, isRunning: false }, ctx.user?.uid);
+            let noticeResult = await NoticeModel.updateNotice('new', { ...notice, type: 1, sort: 1000, serverType: curEnv?.serverType, isEnable: true }, ctx.user?.uid);
+            let mailResult = await GMMailModel.addMail({ ...mail, useTempTime: true }, ctx.user?.uid);
+            await MaintenanceModel.createData(values, marqueeResult, noticeResult, mailResult);
+        } else {
+            let maintenanceResult = await MaintenanceModel.updateData(values.code, values, ctx.user?.uid);
+            if(!maintenanceResult) return ctx.service.utils.resResult(STATUS.WRONG_PARMS);
+            let marqueeResult = <MarqueeType>maintenanceResult.marquee;
+            let noticeResult = <NoticeType>maintenanceResult.notice;
+            let mailResult = <GMMailType>maintenanceResult.mail;
+            if(marqueeResult) await MarqueeModel.updateData(marqueeResult.code, marquee, ctx.user?.uid);
+            if(noticeResult) await NoticeModel.updateNotice(noticeResult.id, notice, ctx.user?.uid);
+            if(mailResult) await GMMailModel.updateMailById(mailResult._id, mail, ctx.user?.uid);
+        }
+        return ctx.service.utils.resResult(STATUS.SUCCESS);
+    }
+
    public async getServerStategyList(page: number, pageSize: number, sortField: string, sortOrder: string, form: { id?: number, name?: string }) {
        const { ctx } = this;

--- a/shared/db/Maintenance.ts
+++ b/shared/db/Maintenance.ts
@@ -1,8 +1,10 @@
 import BaseModel from './BaseModel';
 import { index, getModelForClass, prop, DocumentType, mongoose, Ref } from '@typegoose/typegoose';
-import Marquee from './Marquee';
-import Notice from './Notice';
+import Marquee, { MarqueeType } from './Marquee';
+import Notice, { NoticeType } from './Notice';
 import GMMail from './GMMail';
+import { genCode } from '../pubUtils/util';
+import { GMMailType } from './GMMail';

 /**
  * 开服策略
@@ -29,21 +31,74 @@ export default class Maintenance extends BaseModel {
    @prop({ ref: 'Notice', type: mongoose.Schema.Types.ObjectId })
    notice: Ref<Notice>;        // 维护公告

-    @prop({ ref: 'Notice', type: mongoose.Schema.Types.ObjectId })
+    @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').lean();
+        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 }).lean();
+        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 = MaintenanceModel.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 = MaintenanceModel.getSearchObj(form);
+        const result = await MaintenanceModel.count(searchObj);
+        return result;
+    }
+
+
 }

 export const MaintenanceModel = getModelForClass(Maintenance);
--- a/web-server/app.ts
+++ b/web-server/app.ts
@@ -27,8 +27,8 @@ export default class FooBoot implements IBoot {
  async willReady() {
    // All plugins have started, can do some thing before app ready.
    // await this.customLoadModel();
-    const ctx = await this.app.createAnonymousContext();
-    await ctx.service.game.readDbMaintenance();
+    // const ctx = await this.app.createAnonymousContext();
+    // await ctx.service.game.readDbMaintenance();
  }

  async didReady() {
--- a/web-server/app/middleware/checkMainten.ts
+++ b/web-server/app/middleware/checkMainten.ts
@@ -5,7 +5,7 @@ module.exports = () => {
    return async function checkMainten(ctx, next) {
        const { serverId } = ctx.request.body;
        if (serverId) {
-            let maintenServers = ctx.service.game.getServerMainten();
+            let maintenServers = await ctx.service.game.getServerMainten();
            if (maintenServers.indexOf(serverId) != -1) {
                let isWhiteList = await checkWhiteList(ctx.tel, ctx.request.ip, ctx.auth);
                if (isWhiteList) {
--- a/web-server/app/service/Game.ts
+++ b/web-server/app/service/Game.ts
@@ -7,20 +7,27 @@ import { MaintenanceModel } from '@db/Maintenance';
 */
 export default class Game extends Service {

-    public setServerMainten(maintenServers: number[]) {
-        return this.app['maintenServers'] = maintenServers;
-    }
+    // public setServerMainten(maintenServers: number[]) {
+    //     return this.app['maintenServers'] = maintenServers;
+    // }
    
-    public getServerMainten() {
-        return this.app['maintenServers']||[];
-    }
+    public async getServerMainten() {
+        // return this.app['maintenServers']||[];

-    public async readDbMaintenance() {
        const maintenance = await MaintenanceModel.findOpenMaintenance();
        if(maintenance) {
-            this.setServerMainten(maintenance.serverIds);
+            return maintenance.serverIds;
+        } else {
+            return [];
        }
    }

+    // public async readDbMaintenance() {
+    //     const maintenance = await MaintenanceModel.findOpenMaintenance();
+    //     if(maintenance) {
+    //         this.setServerMainten(maintenance.serverIds);
+    //     }
+    // }
+

 }