xinyuxi/ZYZ
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

后台：服务器维护

Browse Source
This commit is contained in:
luying
2021-12-08 10:25:21 +08:00
parent 103314a8bf
commit 22f8d3c438
29 changed files with 512 additions and 343 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
game-server/app/servers/activity/remote/activityRemote.ts
View File

@@ -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();
for(let { serverId, activityGroupId } of servers) {
let servers = await ServerlistModel.findByEnv(this.app.get('env'));
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);
}
}

13
game-server/app/servers/battle/remote/battleRemote.ts
View File

@@ -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);
}
}

13
game-server/app/servers/chat/remote/chatRemote.ts
View File

@@ -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);
}
}

20
game-server/app/servers/connector/filter/global.ts
View File

@@ -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(maintenServers && maintenServers.indexOf(serverId) != -1) { // 该服务器维护
let isWhiteList = await checkWhiteListWithUid(uid);
if(isWhiteList) return next(null);
pinus.app.get('channelService').pushMessageByUids('onServerMaintenance', resResult(STATUS.SERVER_MAINTENANCE), [{ uid: roleId, sid }]);
return next(new Error(), resResult(STATUS.SERVER_MAINTENANCE));
if(sid) {
const mainten = getServerMainten(serverId);
console.log('***** maintenServers', mainten)
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 }]);
return next(new Error(), resResult(STATUS.SERVER_MAINTENANCE));
}
}
let hasBlockWords = false;

15
game-server/app/servers/connector/remote/connectorRemote.ts
View File

@@ -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[]) {
this.app.set('maintenServers', maintenServers);
return this.maintenServers = maintenServers;
public setServerMainten(serverIds: number[], startTime: number, endTime: number) {
setServerMainten(serverIds, startTime, endTime);
}
public getServerMainten() {
return this.maintenServers;
public stopServerMainten(serverIds: number[]) {
stopServerMainten(serverIds);
}
public getServerMainten(serverId: number) {
return getServerMainten(serverId);
}
public setPvpSeasonNum(pvpConfig: PVPConfigType) {

27
game-server/app/servers/gm/handler/gmHandler.ts
View File

@@ -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');

60
game-server/app/servers/gm/handler/gmServerHandler.ts
View File

@@ -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 ];
for(let mail of mails) {
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) {
let f = new SendMailFun();
await f.setWithGmMail(mail);
await f.sendToServer([newServer.id]);
}
}
if(params.openMail) await sendOpenServerMail('openMail', params.openMail, newServer, uid);
if(params.circleMail) await sendOpenServerMail('circleMail', params.circleMail, newServer, uid);
await RegionModel.newServer(curRegion.id, newServer)
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,);
}
}

13
game-server/app/servers/guild/remote/guildRemote.ts
View File

@@ -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);
}
}

13
game-server/app/servers/order/remote/orderRemote.ts
View File

@@ -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);
}
}

14
game-server/app/servers/role/remote/roleRemote.ts
View File

@@ -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);
}
}

11
game-server/app/servers/systimer/remote/systimerRemote.ts
View File

@@ -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);
}
}

184
game-server/app/services/gmService.ts
View File

@@ -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) {
if(!maintenance)
maintenance = await MaintenanceModel.findOpenMaintenance();
if(maintenance) {
let { startTime, marquee } = maintenance;
if(marquee) {
let result = await generateMarqueeSchedule(<MarqueeType>marquee);
// console.log(result);
}
if(Date.now() > startTime.getTime()) {
await startMaintenance(maintenance);
} else {
let startJob = scheduleJob(`startMainten${maintenance.code}`, startTime.getTime(), async () => {
await startMaintenance(maintenance, startJob);
});
}
}
}
// export async function initMaintenance() {
// let servers = await ServerlistModel.findByEnv(pinus.app.get('env'));
// for(let server of servers)
// // if(!maintenance)
// // maintenance = await MaintenanceModel.findOpenMaintenance();
// // if(maintenance) {
// // let { startTime, marquee } = maintenance;
// // if(marquee) {
// // let result = await generateMarqueeSchedule(<MarqueeType>marquee);
// // // console.log(result);
// // }
// // if(Date.now() > startTime.getTime()) {
// // await startMaintenance(maintenance);
// // } 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);
}
// // 开启维护
// 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 });
}
// // 更新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);
// // 更新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) {
let f = new SendMailFun();
await f.setWithGmMail(gmmail);
await f.sendToServer([newServer.id]);
}
return true;
}
// 停止维护
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);
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;
}
}
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);
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);
}

2
game-server/app/services/mailService.ts
View File

@@ -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) {

2
game-server/app/services/redisService.ts
View File

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

137
game-server/app/services/timeTaskService.ts
View File

@@ -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;
@@ -396,4 +399,132 @@ async function sendCircleMail() {
await f.sendToServer(serverIds);
}
}
}
/*** 维护 */
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);
}

22
gm-server/app/controller/game.ts
View File

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

4
gm-server/app/router.ts
View File

@@ -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/getserverlist', controller.game.getServerList);
// router.post('/api/game/getserverlistbyenv', tokenParser, controller.game.getServerListByEnv);
// 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);

39
gm-server/app/service/Game.ts
View File

@@ -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() {
const { ctx, app } = this;
let env = app.config.env
let serverEnv = await GameModel.getServerEnvList();
let curEnv = serverEnv.find(cur => cur.env == env);
const list = await ServerlistModel.findByServerType(curEnv?.serverType);
// public async getServerListByEnv() {
// const { ctx, app } = this;
// let env = app.config.env
// let serverEnv = await GameModel.getServerEnvList();
// let curEnv = serverEnv.find(cur => cur.env == env);
// const list = await ServerlistModel.findByServerType(curEnv?.serverType);
return ctx.service.utils.resResult(STATUS.SUCCESS, {
list
});
}
// return ctx.service.utils.resResult(STATUS.SUCCESS, {
// 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 } = {}) {
const { ctx } = this;
// 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 list = await ServerlistModel.findByCondition(page, pageSize, sortField, sortOrder, form);
const total = await ServerlistModel.countByCondition( form )
return ctx.service.utils.resResult(STATUS.SUCCESS, {
list, total
});
}
// const list = await ServerlistModel.findByCondition(page, pageSize, sortField, sortOrder, form);
// const total = await ServerlistModel.countByCondition( form )
// return ctx.service.utils.resResult(STATUS.SUCCESS, {
// 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
});

1
shared/consts/constModules/sysConst.ts
View File

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

2
shared/db/Counter.ts
View File

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

2
shared/db/GMMail.ts
View File

@@ -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 {

107
shared/db/Maintenance.ts
View File

@@ -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>; // 将所有字段变成可选项

11
shared/db/Region.ts
View File

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

88
shared/db/Serverlist.ts
View File

@@ -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 (now > this.openTime) {
if (nowSeconds() > 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 = new Date(openTimeNum + hour * 60 * 60);
let stopRegisterTime = openTime + 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) {
let condition = {};
if(serverType) {
condition['serverType'] = serverType;
}
let server: ServerlistType[] = await ServerlistModel.find(condition).sort({ id: -1 }).lean({ getters: true, virtuals: true });
public static async findByEnv(env?: string) {
let server: ServerlistType[] = await ServerlistModel.find({ env, serverStatus: { $gt: 0 } }).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();

1
shared/db/index.ts
View File

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

4
shared/domain/backEndField/params.ts
View File

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

13
shared/domain/gameField/serverlist.ts
View File

@@ -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.groupStr = `${min.serverId}-${min.serverId + 9}`
this.servers.sort((a, b) => b.serverId - a.serverId);
let min = this.servers[this.servers.length - 1];
let max = this.servers[0];
this.groupStr = `${min.serverStr}-${max.serverStr}`
}
}

4
web-server/app/controller/game.ts
View File

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

16
web-server/app/service/Game.ts
View File

@@ -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();
if(maintenance) {
return maintenance.serverIds;
} else {
return [];
}
// const maintenance = await MaintenanceModel.findOpenMaintenance();
// if(maintenance) {
// return maintenance.serverIds;
// } else {
// return [];
// }
return []
}
// public async readDbMaintenance() {