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

Merge branch 'feature/backend'

Browse Source
This commit is contained in:
luying
2021-12-18 13:14:15 +08:00
parent e17406b53b 4c41224c9b
commit 019142872c
125 changed files with 9262 additions and 2385 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
config.js
View File

@@ -5,9 +5,6 @@ function main (){
return console.log('参数请填写环境变量');
}
let env = args[0];
if(args[0] == 'stable') {
env = 'production';
}
let configObject = {
env: env

22
game-server/app.ts
View File

@@ -28,6 +28,7 @@ import { updateTeamStatus } from './app/services/comBattleService';
import { resResult, genCode } from './app/pubUtils/util';
import { errlogger, infologger } from './app/util/logger';
import { connectThinkingData, getTire } from './app/services/sdkService';
import { loadGmDb } from './app/db';
const filePath = (_pinus as any).FILEPATH;
filePath.MASTER = '/config/master';
@@ -67,6 +68,7 @@ app.configure(function () {
console.log('serverName:', app.get('serverName'))
initMongodb(app);
initGmMongodb(app);
initRedis(app);
setupRoutes(app);
setupFilters(app);
@@ -124,7 +126,7 @@ app.configure(ALL_ENVS, 'guild', function () {
})
app.configure(ALL_ENVS, 'systimer', function () {
app.afterStart(async () => {
app.event.on('start_all', async (servers) => {
await redisService.initAllRank();
await timeTaskService.init();
redisService.redisSubScribe();
@@ -135,7 +137,14 @@ app.configure(ALL_ENVS, 'chat', function() {
app.event.on('start_all', () => {
getTire();
});
})
});
app.configure(ALL_ENVS, 'activity', function () {
app.event.on('start_all', () => {
app.rpc.activity.activityRemote.loadActivities.toServer(app.getServerId());
});
});
function errorHandler(err: Error, msg: any, resp: any,
session: FrontendOrBackendSession, cb: HandlerCallback) {
@@ -158,8 +167,8 @@ export function globalErrorHandler(err: Error, msg: any, resp: any,
}
}
function initMongodb(app: _pinus.Application) {
mongoose.connect(app.get('database').mongo, { useNewUrlParser: true, useUnifiedTopology: true, useCreateIndex: true, useFindAndModify: false }, (err) => {
async function initMongodb(app: _pinus.Application) {
await mongoose.connect(app.get('database').mongo, { useNewUrlParser: true, useUnifiedTopology: true, useCreateIndex: true, useFindAndModify: false }, (err) => {
if (err) {
errlogger.error('mongodb connect err', err);
} else {
@@ -168,6 +177,11 @@ function initMongodb(app: _pinus.Application) {
});
}
async function initGmMongodb(app: _pinus.Application) {
let gmconnect = await mongoose.createConnection(app.get('database').gmmongo, { useNewUrlParser: true, useUnifiedTopology: true, useCreateIndex: true, useFindAndModify: false });
loadGmDb(gmconnect);
console.log('mongoGmDb connect suc')
}
function initRedis(app: _pinus.Application) {
const redisClient = connectRedis(app.get('database').redis, app.get('database').redispw);
app.set('redis', redisClient);

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

@@ -3,6 +3,8 @@ 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';
import { taflush } from '../../../services/sdkService';
export default function (app: Application) {
new HandlerService(app, {});
@@ -14,7 +16,6 @@ export class ActivityRemote {
constructor(private app: Application) {
this.app = app;
this.channelService = app.get('channelService');
this.loadActivities();
}
private channelService: ChannelService;
@@ -30,9 +31,9 @@ export class ActivityRemote {
reloadResources();
}
private async loadActivities() {
let servers = await ServerlistModel.getAllServerList();
for(let { serverId, activityGroupId } of servers) {
public async loadActivities() {
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, []);
@@ -52,6 +53,7 @@ export class ActivityRemote {
this.app.set('activityByServer', this.activityByServer);
this.app.set('activityByType', this.activityByType);
this.app.set('activities', this.activities);
console.log('****** loadActivities')
}
private setActivityTypeAndServer() {
@@ -116,4 +118,20 @@ 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);
}
public taflush() {
return taflush();
}
}

2
game-server/app/servers/battle/handler/comBattleHandler.ts
View File

@@ -747,7 +747,7 @@ export class ComBattleHandler {
if(r != roleId) roleIdList.push(r);
}
}
const roles = await RoleModel.findRoleByField('roleId', roleIdList, ROLE_SELECT.SHOW_SIMPLE, true);
const roles = await RoleModel.findByRoleIds(roleIdList, ROLE_SELECT.SHOW_SIMPLE, true);
let result = new Array<FriendParams>();
for(let role of roles) {
if(role.quitTime == role.loginTime) {

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

@@ -1,6 +1,8 @@
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';
import { taflush } from '../../../services/sdkService';
export default function (app: Application) {
new HandlerService(app, {});
@@ -87,4 +89,20 @@ 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);
}
public taflush() {
return taflush();
}
}

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

@@ -12,7 +12,8 @@ import { getAllGuildActivityStatus } from '../../../services/guildActivityServic
import { MailParam } from '../../../domain/roleField/mail';
import { RankFirstType } from '../../../db/RankFirst';
import { LotType } from '../../../db/Lot';
import { _checkFilterWords, getTire } from '../../../services/sdkService';
import { _checkFilterWords, getTire, taflush } from '../../../services/sdkService';
import { getServerMainten, setServerMainten, stopServerMainten } from '../../../services/gmService';
export default function (app: Application) {
new HandlerService(app, {});
@@ -289,4 +290,20 @@ 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);
}
public taflush() {
return taflush();
}
}

18
game-server/app/servers/chat/remote/guildRemote.ts
View File

@@ -10,6 +10,7 @@ import { MailParam } from '../../../domain/roleField/mail';
import { pick } from 'underscore';
import { LotType } from '../../../db/Lot';
import { DividendType } from '../../../db/Dividend';
import { getRoleOnlineInfo } from '../../../services/redisService';
export default function (app: Application) {
new HandlerService(app, {});
@@ -66,12 +67,13 @@ export class GuildRemote {
* @param message 推送信息
* @param sid 玩家服
*/
private pushMessageByUids(guildCode: string, path: string, roleId: string, message: { code: string, roleId?: string }, sid?: string) {
private async pushMessageByUids(guildCode: string, path: string, roleId: string, message: { code: string, roleId?: string }, sid?: string) {
let channel = this.getChannel(guildCode);
let uids = [];
if (!sid) {
sid = channel && channel.getMember(roleId)['sid'];
let onlineUser = await getRoleOnlineInfo(roleId);
sid = onlineUser.sid;
}
if (sid) {
uids.push({ uid: roleId, sid });
@@ -165,10 +167,14 @@ export class GuildRemote {
* @param oldLeaderId 旧团长
*/
public changeLeader(guildCode: string, managerCnt: number, newLeader: RoleType, oldLeaderId: string) {
let { roleId, roleName, frame, head, spine, lv, quitTime } = newLeader;
this.updateInfo(guildCode, { managerCnt, leader: { roleId, roleName, frame, head, spine, lv, quitTime } });
this.demotion(guildCode, oldLeaderId);
this.promotion(guildCode, roleId);
try{
let { roleId, roleName, frame, head, spine, lv, quitTime } = newLeader;
this.updateInfo(guildCode, { managerCnt, leader: { roleId, roleName, frame, head, spine, lv, quitTime } });
this.demotion(guildCode, oldLeaderId);
this.promotion(guildCode, roleId);
}catch(e) {
console.log(e.stack)
}
}
/**

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

@@ -1,11 +1,13 @@
import {Application, RouteRecord, FrontendOrBackendSession, HandlerCallback, pinus} from "pinus";
import {Application, RouteRecord, FrontendOrBackendSession, HandlerCallback, pinus, FrontendSession} from "pinus";
// import { checkEvent } from '../../../services/eventSercive';
import { refresh } from '../../../services/refreshService';
import { checkPrivateChat, checkGuildChat, checkOtherChat, checkRoleName, checkGuildName } from "../../../services/sdkService";
import { resResult, checkWhiteListWithUid, genCode } from "../../../pubUtils/util";
import { CHANNEL_PREFIX, MSG_TYPE, STATUS } from "../../../consts";
import { resResult, checkWhiteList, genCode } from "../../../pubUtils/util";
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);
}
@@ -19,29 +21,39 @@ Filter.prototype.before = async function (routeRecord: RouteRecord, msg: any, se
const sid: string = session.get('sid');
const roleId: string = session.get('roleId');
const uid: number = session.get('userid');
const ip: string = session.get('ip');
console.log('*********** global before ip', ip)
let guildCode = session.get('guildCode');
let blockType = session.get('blockType');
if(blockType == BLOCK_TYPE.BLOCK) return next(new Error(), resResult(STATUS.BLOCKED));
if(blockType == BLOCK_TYPE.BAN) {
if([
'chat.chatHandler.sendPrivateMessage',
'chat.chatHandler.sendGroupMessage',
'battle.barrageHandler.sendBarrage',
'guild.guildHandler.sendMail',
'guild.guildHandler.setGuildInfo',
].indexOf(routeRecord.route) != -1) {
return next(new Error(), resResult(STATUS.BANNED));
}
}
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);
if(sid) {
const mainten = getServerMainten(serverId);
if(mainten) { // 该服务器维护
if(mainten.startTime > nowSeconds() || mainten.endTime < nowSeconds()) 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 isWhiteList = await checkWhiteList(this.app.get('env'), ip, uid, serverId);
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;
// if(pinus.app.get('env') == 'production') {
// if(routeRecord.route == 'guild.guildHandler.createGuild') {
// hasBlockWords = await checkFilterWords(msg.name);
// } else if (routeRecord.route == 'role.roleHandler.initRole') {
// hasBlockWords = await checkFilterWords(msg.roleName);
// } else if (routeRecord.route == 'role.roleHandler.rename') {
// hasBlockWords = await checkFilterWords(msg.roleName);
// }
// }
if(SERVER_DEBUG_MODE.CHECK_WORD == 1) {
switch(routeRecord.route) {
case 'chat.chatHandler.sendPrivateMessage':
@@ -64,6 +76,18 @@ Filter.prototype.before = async function (routeRecord: RouteRecord, msg: any, se
break;
}
}
case 'battle.barrageHandler.sendBarrage':
{
let result = await checkOtherChat(roleId, CHANNEL_PREFIX.WORLD, msg.content);
if(!result) hasBlockWords = true;
break;
}
case 'guild.guildHandler.sendMail':
{
let result = await checkGuildChat(roleId, guildCode, msg.info);
if(!result) hasBlockWords = true;
break;
}
case 'role.roleHandler.rename':
case 'role.roleHandler.initRole':
{

6
game-server/app/servers/connector/handler/entryHandler.ts
View File

@@ -133,6 +133,7 @@ export class EntryHandler {
session.set('loginTime', role.loginTime);
session.set('roleName', role.roleName);
session.set('eventStatus', role.eventStatus);
session.set('blockType', role.blockType);
session.set('sid', self.app.get('serverId'));
session.set('serverId', role.serverId);
session.set('guildCode', role.guildCode);
@@ -146,6 +147,7 @@ export class EntryHandler {
session.push('updatedMailAt', () => { });
session.push('loginTime', () => { });
session.push('guildCode', () => { });
session.push('blockType', () => { });
session.push('ip', () => { });
// console.log(role.guildCode)
// session.push('rid', function (err) {
@@ -248,6 +250,7 @@ export class EntryHandler {
session.set('roleName', user.name);
session.set('eventStatus', 0);
session.set('sid', self.app.get('serverId'));
session.push('uid', () => { });
session.push('sid', () => { });
session.push('roleId', () => { });
session.push('roleName', () => { });
@@ -261,7 +264,8 @@ export class EntryHandler {
// put user into channel
return resResult(STATUS.SUCCESS, {
serverType: this.app.get('serverName')
serverType: this.app.get('serverName'),
env: this.app.get('env')
});
}

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

@@ -6,6 +6,8 @@ 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';
import { taflush } from '../../../services/sdkService';
export default function (app: Application) {
new HandlerService(app, {});
return new ConnectorRemote(app);
@@ -16,10 +18,9 @@ export class ConnectorRemote {
constructor(private app: Application) {
this.app = app;
}
private maintenServers: number[] = []; // 维护中的服务器
public async remoteLogin(uid: string) {
await kickUser(this.app, uid);
public async remoteLogin(uid: string, message?: any) {
await kickUser(this.app, uid, message);
}
public async setOtherUserGuildSession(params: { roleId: string, userGuild: UserGuildType}[]) {
@@ -50,6 +51,18 @@ export class ConnectorRemote {
}
}
public async setOtherUseBlockTypeSession(params: { roleId: string, blockType: string}[]) {
let sessionService = this.app.get('sessionService');
for(let {roleId, blockType} of params) {
let sessions = sessionService.getByUid(roleId);
if(!!sessions) {
sessions.forEach(session => {
sessionService.aimportAll(session.id, { blockType });
});
}
}
}
/**
* 重载json资源
*/
@@ -57,13 +70,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) {
@@ -79,4 +95,8 @@ export class ConnectorRemote {
async setDicAuctionTime(startTime: number, endActivity: number, startGuild: number, endGuild: number, startWorld: number, endWorld: number) {
setDicAuctionTime(startTime, endActivity, startGuild, endGuild, startWorld, endWorld);
}
public taflush() {
return taflush();
}
}

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

@@ -7,21 +7,21 @@ import { STATUS } from '../../../consts/statusCode';
import { GMMailModel } from '../../../db/GMMail';
import { delGuildActivityRank, getRoleOnlineInfo } from '../../../services/redisService';
import { SendMailFun } from '../../../services/mailService';
import { GM_MAIL_TYPE } from '../../../consts';
import { GM_MAIL_STATUS, GM_MAIL_TYPE, MAIL_TIME_TYPE, REF_CIRCLE_MAIL_TIME } from '../../../consts';
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 { checkActivityEditable, checkActivityGroupType, checkActivityGroupTypeWithId } from '../../../services/activity/activityService';
import { ActivityModel } from '../../../db/Activity';
import { ActivityGroupModel } from '../../../db/ActivityGroup';
import { ActivityGroupTypeModel } from '../../../db/ActivityGroupType';
import { GuildActivityCityModel } from '../../../db/GuildActivityCity';
import { GuildActivityRecordModel } from '../../../db/GuildActivityRec';
import { getTimeFunM } from '../../../pubUtils/timeUtil';
import { getTimeFunM, nowSeconds } from '../../../pubUtils/timeUtil';
import moment = require('moment');
import { sendUngotDividend } from '../../../services/auctionService';
import { taflush } from '../../../services/sdkService';
let timer: NodeJS.Timer;
export default function (app: Application) {
return new GmHandler(app);
@@ -31,88 +31,55 @@ export class GmHandler {
constructor(private app: Application) {
}
async pushEvent(msg: { uid: number, serverId: number }, session: BackendSession) {
let { uid, serverId } = msg;
let role = await RoleModel.findByUid(uid, serverId);
if (!role) return resResult(STATUS.GM_ROLE_NOT_FOUND);
let { roleId, roleName, eventStatus } = role;
let channelService = this.app.get('channelService');
let event = await getEvent(eventStatus, roleId, roleName);
let hisOnlineInfo = await getRoleOnlineInfo(role.roleId);
if (hisOnlineInfo.isOnline) {
channelService.pushMessageByUids('onSpecialEvent', resResult(STATUS.SUCCESS, { event }), [{
uid: roleId,
sid: hisOnlineInfo.sid
}]);
}
return resResult(STATUS.SUCCESS, { list: event });
}
async clearEvent(msg: {}, session: BackendSession) {
let roleId = session.get('roleId');
await EventRecordModel.deleteAccount(roleId);
return resResult(STATUS.SUCCESS);
}
async pushMessage(msg: { uid: number, serverId: number, eventName: string, message: string }, session: BackendSession) {
let { uid, serverId, eventName, message } = msg;
let content = {};
try {
content = JSON.parse(message);
} catch (e) {
return resResult(STATUS.GM_JSON_FORMAT_ERR);
}
// console.log(uid, serverId)
let role = await RoleModel.findByUid(uid, serverId);
if (!role) return resResult(STATUS.GM_ROLE_NOT_FOUND);
let { roleId } = role;
let hisOnlineInfo = await getRoleOnlineInfo(role.roleId);
if (hisOnlineInfo.isOnline) {
let sid = hisOnlineInfo.sid;
if (!!sid) {//下发邮件，对应前端红点提示
pinus.app.channelService.pushMessageByUids(eventName, resResult(STATUS.SUCCESS, content), [{ uid: roleId, sid }]);
}
}
return resResult(STATUS.SUCCESS, { msg: content });
}
//对接gm后台，下发邮件
async addMail(msg: { endTime: number, sendName: string, content: string, goods: RewardInter[], sendTime: number }) {
let { endTime, content, sendName, sendTime, goods } = msg;
let mail = await GMMailModel.addMail({ endTime, content, sendName, sendTime, goods });
return resResult(STATUS.SUCCESS, { mail });
}
async sendMail(msg: { id: string, mailType: number, roleIds?: string[], serverIds?: number[] }, session: BackendSession) {
async sendMail(msg: { id: string, isPass: boolean }, session: BackendSession) {
const uid: number = session.get('uid')
let { id, mailType, roleIds, serverIds } = msg;
let f = new SendMailFun();
await f.setWithGmMail(id);
if (mailType == GM_MAIL_TYPE.SINGLE || mailType == GM_MAIL_TYPE.GROUP) {
await f.sendToUsers(mailType, roleIds);
} else {
await f.sendToServer(serverIds);
let { id, isPass } = msg;
let gmmail = await GMMailModel.getGmMailById(id);
if(!gmmail) return resResult(STATUS.GM_MAIL_NOT_FOUND);
let { receivers, mailType, status, timeType, startTime, circleHour, circleDay } = gmmail;
if(status != GM_MAIL_STATUS.CREATE) {
return resResult(STATUS.GM_MAIL_HAS_SENT);
}
await f.saveRecord(uid);
return resResult(STATUS.SUCCESS);
}
async sendWithContent(msg: { contentId: number, mailType: number, params: { params?: string[], sendName?: string, goods?: RewardInter[], endTime?: number }, roleIds?: string[], serverIds?: number[] }, session: BackendSession) {
let { contentId, mailType, roleIds, serverIds, params } = msg;
let f = new SendMailFun();
f.setWithContentId(contentId, params);
if (mailType == GM_MAIL_TYPE.SINGLE || mailType == GM_MAIL_TYPE.GROUP) {
await f.sendToUsers(mailType, roleIds);
} else {
await f.sendToServer(serverIds);
let needSend = false;
if(isPass) {
if(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 '+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);
if (mailType == GM_MAIL_TYPE.SINGLE || mailType == GM_MAIL_TYPE.GROUP) {
let roleIds = receivers.filter(cur => cur.env == this.app.get('env')).map(cur => cur.roleId);
await f.sendToUsers(mailType, roleIds);
} else {
let serverIds = receivers.filter(cur => cur.env == this.app.get('env')).map(cur => cur.serverId);
await f.sendToServer(serverIds);
}
// await f.saveRecord(uid);
}
let sendTime = '';
if(isPass) {
if(timeType == MAIL_TIME_TYPE.IMMEDIATE) {
sendTime = moment().format('YYYY-MM-DD HH:mm:ss');
} else if (timeType == MAIL_TIME_TYPE.DELAY) {
sendTime = moment(startTime * 1000).format('YYYY-MM-DD HH:mm:ss');
} else if (timeType == MAIL_TIME_TYPE.CIRCLE) {
sendTime = (circleDay == 0?'每天': '每周'+circleDay) + ' ' + circleHour;
}
}
await GMMailModel.updateMailById(id, { status: isPass? GM_MAIL_STATUS.PASS: GM_MAIL_STATUS.NOT_PASS, viewAt: new Date(), viewBy: uid, sendTime }, uid);
return resResult(STATUS.SUCCESS);
}
@@ -161,59 +128,14 @@ export class GmHandler {
}
}
async createMarquee(msg: { startTime: string, endTime: string, interval: number, content: string }, session: BackendSession) {
async createMarquee(msg: { startTime: number, endTime: number, interval: number, content: string }, session: BackendSession) {
const { startTime, endTime, interval, content } = msg;
let marquee = await MarqueeModel.createData({ serverIds: [1], type: 2, startTime: new Date(startTime), endTime: new Date(endTime), interval, content });
let marquee = await MarqueeModel.createData({ timeType: 2, startTime, endTime, interval, content });
return resResult(STATUS.SUCCESS, {
code: marquee.code
});
}
async sendMarquee(msg: { code: string }, session: BackendSession) {
const { code } = msg;
let systimerServers = this.app.getServersByType('systimer');
for (let { id } of systimerServers) {
let result = await this.app.rpc.systimer.systimerRemote.setMarquee.toServer(id, code);
if (!result) return resResult(STATUS.GM_MARQUEE_ERR);
}
return resResult(STATUS.SUCCESS);
}
async cancelMarquee(msg: { code: string }, session: BackendSession) {
const { code } = msg;
let systimerServers = this.app.getServersByType('systimer');
for (let { id } of systimerServers) {
let result = await this.app.rpc.systimer.systimerRemote.cancelMarquee.toServer(id, code);
if (!result) return resResult(STATUS.GM_MARQUEE_CANCEL_ERR);
}
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');
@@ -231,7 +153,7 @@ export class GmHandler {
let activities = await ActivityModel.findActivityByIds(aids);
let checkTimeResult = await checkActivityEditable(activities);
if(!checkTimeResult) return resResult(STATUS.GM_CAN_NOT_EDIT_ACT);
let checkGroup = await checkActivityGroupType(groupId, activities);
let checkGroup = await checkActivityGroupTypeWithId(groupId, activities);
if(!checkGroup) return resResult(STATUS.GM_ACTIVITY_NOT_FIT_GROUP_TYPE);
activities = await ActivityModel.addActivity(aids, groupId, beginTime ? new Date(beginTime) : undefined, endTime ? new Date(endTime) : undefined, type, data, uid);
@@ -262,9 +184,25 @@ export class GmHandler {
return resResult(STATUS.SUCCESS);
}
async saveGroupToServer(msg: { groupId: number, serverIds: number[] }, session: BackendSession) {
const { groupId, serverIds } = msg;
async updateActivityGroup(msg: { groupId: number, groupName: string, serverIds: number[], activities: number[], type: number }, session: BackendSession) {
const uid = session.get('uid');
let { groupId, groupName, serverIds, activities, type } = msg;
let groupTypeObj = await ActivityGroupTypeModel.findByGroupType(type);
if(!groupTypeObj) return resResult(STATUS.GM_ACTIVITY_GROUP_TYPE_NOT_FOUND);
{
let result = await this.saveActivitiesToGroup(groupId, type, activities, uid);
if(result.code != 0) return result;
}
{
let result = await this.saveGroupToServer(groupId, serverIds, uid);
if(result.code != 0) return result;
}
await ActivityGroupModel.updateGroup(groupId, {groupName, type}, uid);
return resResult(STATUS.SUCCESS);
}
async saveGroupToServer(groupId: number, serverIds: number[], uid: number) {
await ServerlistModel.pullByGroupId(groupId);
let servers = await ServerlistModel.findServerByIds(serverIds);
@@ -289,12 +227,10 @@ export class GmHandler {
/**
* 选择活动组内的活动
*/
async saveActivitiesToGroup(msg: { groupId: number, activities: number[] }, session: BackendSession) {
const { groupId, activities: activityIds } = msg;
const uid = session.get('uid');
async saveActivitiesToGroup(groupId: number, groupType: number, activityIds: number[], uid: number) {
let activities = await ActivityModel.findActivityByIds(activityIds);
let checkResult = await checkActivityGroupType(groupId, activities);
let checkResult = await checkActivityGroupType(groupType, activities);
if(!checkResult) return resResult(STATUS.GM_ACTIVITY_NOT_FIT_GROUP_TYPE);
await ActivityGroupModel.setActivitiesToGroupData(groupId, activityIds, uid);
@@ -303,7 +239,7 @@ export class GmHandler {
for(let server of activityServers) {
pinus.app.rpc.activity.activityRemote.saveActivitiesToGroup.toServer(server.id, groupId, activityIds);
}
return resResult(STATUS.SUCCESS)
return resResult(STATUS.SUCCESS);
}
async saveSingleActivityToGroup(msg: { groupId: number, index: number, activityId: number }, session: BackendSession) {
@@ -312,7 +248,7 @@ export class GmHandler {
let activity = await ActivityModel.findActivity(activityId);
if(!activity) return resResult(STATUS.ACTIVITY_MISSING);
let checkResult = await checkActivityGroupType(groupId, [activity]);
let checkResult = await checkActivityGroupTypeWithId(groupId, [activity]);
if(checkResult) return checkResult;
let activityGroup = await ActivityGroupModel.findGroupData(groupId);
@@ -421,4 +357,16 @@ export class GmHandler {
await pushCurrentTime(now.getTime());
return resResult(STATUS.SUCCESS);
}
async taflus() {
taflush();
pinus.app.rpc.activity.activityRemote.taflush.broadcast();
pinus.app.rpc.battle.battleRemote.taflush.broadcast();
pinus.app.rpc.chat.chatRemote.taflush.broadcast();
pinus.app.rpc.connector.connectorRemote.taflush.broadcast();
pinus.app.rpc.guild.guildRemote.taflush.broadcast();
pinus.app.rpc.order.orderRemote.taflush.broadcast();
pinus.app.rpc.role.roleRemote.taflush.broadcast();
pinus.app.rpc.systimer.systimerRemote.taflush.broadcast();
}
}

201
game-server/app/servers/gm/handler/gmRoleHandler.ts Normal file
View File

@@ -0,0 +1,201 @@
import { Application, BackendSession, pinus } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { STATUS } from '../../../consts/statusCode';
import { getRoleOnlineInfo, updateUserInfo } from '../../../services/redisService';
import { addItems, createHeroes } from '../../../services/rewardService';
import { RewardInter } from '../../../pubUtils/interface';
import { getExpByLv } from '../../../pubUtils/data';
import { RoleModel, RoleType } from '../../../db/Role';
import { BLOCK_TYPE, GUILD_AUTH, GUILD_DISMISS_WAY, GUILD_JOB, GUILD_MASTER_CHANGE_WAY, GUILD_STATUS, GUILD_STRUCTURE, ITEM_CHANGE_REASON, MAIL_TYPE, REDIS_KEY, TA_EVENT } from '../../../consts';
import { GuildFormParam } from '../../../domain/backEndField/params';
import { GuildModel, GuildUpdateParam } from '../../../db/Guild';
import { getGuildChannelSid } from '../../../services/chatService';
import { pushGuildNoticeUpdateMsg } from '../../../services/sysChatService'
import { Rank } from '../../../services/rankService';
import { UserGuildModel } from '../../../db/UserGuild';
import { UserGuildApplyModel } from '../../../db/UserGuildApply';
import { reportTAEvent } from '../../../services/sdkService';
import { sendMailByContent } from '../../../services/mailService';
import { GuildLeader } from '../../../domain/rank';
let timer: NodeJS.Timer;
export default function (app: Application) {
return new GmRoleHandler(app);
}
export class GmRoleHandler {
constructor(private app: Application) {
}
async addItems(msg: { roleId: string, roleName: string, serverId: number, values: { reward: RewardInter[], heroes: number[], lv: number }}, session: BackendSession) {
let { roleId, roleName, serverId, values } = msg;
let { reward, heroes, lv } = values;
if (reward == undefined && heroes == undefined && lv == undefined) {
return resResult(STATUS.WRONG_PARMS);
}
let connect = await getRoleOnlineInfo(roleId);
let sid = connect.isOnline?connect.sid: null;
if(reward &&reward.length > 0) {
await addItems(roleId, roleName, sid, values.reward, ITEM_CHANGE_REASON.DEBUG);
}
if(heroes && heroes.length > 0) {
await createHeroes(roleId, roleName, sid, serverId, heroes.map(hid => { return { hid, count: 1 }}))
}
if(lv && lv > 0) {
let exp = getExpByLv(lv - 1)?.sum||0;
await RoleModel.updateRoleInfo(roleId, { lv, exp })
let uids = [{ uid: roleId, sid }];
pinus.app.get('channelService').pushMessageByUids('onPlayerExpChange', resResult(STATUS.SUCCESS, {
isLvUp: false, lv, exp
}), uids);
}
return resResult(STATUS.SUCCESS);
}
async handleBlock(msg: { roleId: string, blockType: BLOCK_TYPE, blockReason: string }, session: BackendSession) {
let { roleId, blockType, blockReason } = msg;
if(roleId == undefined || blockType == undefined || blockReason == undefined) return resResult(STATUS.WRONG_PARMS);
let role = await RoleModel.updateRoleInfo(roleId, { blockType, blockReason });
if(!role) return resResult(STATUS.ROLE_NOT_FOUND);
let { isOnline, sid } = await getRoleOnlineInfo(roleId);
if(isOnline) {
await this.app.rpc.connector.connectorRemote.setOtherUseBlockTypeSession.toServer(sid,[{ roleId, blockType }]);
if(blockType == BLOCK_TYPE.BLOCK) { // 踢走
await this.app.rpc.connector.connectorRemote.remoteLogin.toServer(sid, roleId, STATUS.BLOCKED);
}
}
return resResult(STATUS.SUCCESS);
}
async updateGuild(msg: GuildFormParam, session: BackendSession ) {
const uid = session.get('uid');
let params = new GuildFormParam(msg);
if(!params.checkParams()) return resResult(STATUS.WRONG_PARMS);
let guild = await GuildModel.findByCode(params.code);
let structure = guild.structure||[];
let updateParams: GuildUpdateParam = { code: params.code };
if(params.name && guild.name != params.name) updateParams.name = params.name;
if(params.fund != undefined && guild.fund != params.fund) updateParams.fund = params.fund;
if(params.notice && guild.notice != params.notice) updateParams.notice = params.notice;
if(params.lv && guild.lv != params.lv) updateParams.lv = params.lv;
for(let id = GUILD_STRUCTURE.START; id < GUILD_STRUCTURE.END; id ++) {
let curStructure = structure.find(cur => cur.id == id);
let lv = params.lv;
switch(id) {
case GUILD_STRUCTURE.ARMY_CENTER:
lv = params.lv; break;
case GUILD_STRUCTURE.EQUIP_PRODUCE:
lv = params.equipProduce; break;
case GUILD_STRUCTURE.BOSS:
lv = params.boss; break;
case GUILD_STRUCTURE.TRAIN:
lv = params.train; break;
case GUILD_STRUCTURE.DONATE:
lv = params.donate; break;
case GUILD_STRUCTURE.WISH_POOL:
lv = params.wishPool; break;
case GUILD_STRUCTURE.STORE:
lv = params.store; break;
}
if(curStructure) {
curStructure.lv = lv;
} else {
structure.push({ id, lv });
}
}
updateParams.structure = structure;
let chatSid = await getGuildChannelSid(params.code);
console.log('*****', params.code, updateParams)
this.app.rpc.chat.guildRemote.updateInfo.toServer(chatSid, params.code, updateParams);
// 设置玩家名
if(updateParams.name != undefined || updateParams.lv != undefined) {
let arr = [];
if(updateParams.name != undefined) arr.push({ field: 'name', value: updateParams.name });
if(updateParams.lv != undefined) arr.push({ field: 'lv', value: updateParams.lv });
await updateUserInfo(REDIS_KEY.GUILD_INFO, params.code, arr);
}
if (updateParams.lv != undefined) {
let r = new Rank(REDIS_KEY.GUILD_LV_RANK, { serverId: guild.serverId });
await r.setRankWithGuildInfo2(guild.code, updateParams.lv, guild.activeWeekly, guild.lvUpdateTime, guild);
}
guild = await GuildModel.updateInfo(params.code, updateParams);
return resResult(STATUS.SUCCESS);
}
async dismissGuild(msg: { code: string }, session: BackendSession) {
const { code } = msg;
let guild = await GuildModel.findByCode(code, null, '+serverId');
if(!guild) return resResult(STATUS.GUILD_NOT_FOUND);
if(guild.status == GUILD_STATUS.DISMISSED) return resResult(STATUS.GUILD_DELETE_ERROR);
let serverId = guild.serverId;
guild = await GuildModel.dismiss(code, serverId);
if (!guild) return resResult(STATUS.GUILD_DELETE_ERROR);
await UserGuildModel.dismiss(code);
const { members } = guild;
await RoleModel.dissmissGuild(members);
await UserGuildApplyModel.deleteApplyByGuild(code);
await this.app.rpc.connector.connectorRemote.setOtherUserGuildSession.broadcast(members.map(roleId => { return { roleId, userGuild: null } })); // 更新session
// 删除channel
let chatSid = await getGuildChannelSid(code);
this.app.rpc.chat.guildRemote.dismiss.toServer(chatSid, code);
let r = new Rank(REDIS_KEY.GUILD_ACTIVE_RANK, { serverId });
await r.removeFromRank({ guildCode: code });
let r2 = new Rank(REDIS_KEY.GUILD_LV_RANK, { serverId });
await r2.removeFromRank({ guildCode: code });
let leader = <RoleType>guild.leader;
reportTAEvent(leader.roleId, TA_EVENT.GUILD_DISMISS, { name: guild.name, way: GUILD_DISMISS_WAY.BACKEND });
return resResult(STATUS.SUCCESS, { code, status: guild.status });
}
async setGuildLeader(msg: { code: string, roleId: string }, session: BackendSession) {
const { code, roleId } = msg;
let guild = await GuildModel.findByCode(code, null, '+serverId');
if(!guild) return resResult(STATUS.GUILD_NOT_FOUND);
if(guild.status == GUILD_STATUS.DISMISSED) return resResult(STATUS.GUILD_DELETE_ERROR);
let role = await RoleModel.findByRoleId(roleId);
if(!role) return resResult(STATUS.ROLE_NOT_FOUND);
let userGuild = await UserGuildModel.getMyGuild(roleId);
if(!userGuild || userGuild.guildCode != code) return resResult(STATUS.GUILD_KICK_ERROR);
if(userGuild.auth == GUILD_AUTH.LEADER) return resResult(STATUS.GUILD_USER_IS_LEADER);
let leader = <RoleType>guild.leader;
// 交换
let oldLeaderUserGuild = await UserGuildModel.updateInfo(leader.roleId, { auth: GUILD_AUTH.MEMBER, job: GUILD_JOB.SHIBING }, {}, 'auth'); // 团长撤
await this.app.rpc.connector.connectorRemote.setOtherUserGuildSession.broadcast([{ roleId: leader.roleId, userGuild: oldLeaderUserGuild }]); // 更新session
let newLeaderUserGuild = await UserGuildModel.updateInfo(roleId, { auth: GUILD_AUTH.LEADER, job: GUILD_JOB.DAJIANGJUN }, {}, 'auth'); // 最高功勋人升
await this.app.rpc.connector.connectorRemote.setOtherUserGuildSession.broadcast([{ roleId: roleId, userGuild: newLeaderUserGuild }]); // 更新session
let managerCntInc = userGuild.auth == GUILD_AUTH.MANAGER ? -1 : 0; // 管理人数
guild = await GuildModel.updateInfo(code, { leader: role._id }, { managerCnt: managerCntInc }, 'managerCnt name'); // 如果有转让团长设置leader
// 添加动态
let chatSid = await getGuildChannelSid(code);
this.app.rpc.chat.guildRemote.changeLeader.toServer(chatSid, code, guild.managerCnt, role, leader.roleId);
await sendMailByContent(MAIL_TYPE.GUILD_BE_IMPEACH, leader.roleId, { params: [guild.name] });
await sendMailByContent(MAIL_TYPE.GUILD_BE_SET_LEADER, roleId, { params: [guild.name] });
await updateUserInfo(REDIS_KEY.GUILD_INFO, code, [{ field: 'leader', value: new GuildLeader(role) }]);
reportTAEvent(roleId, TA_EVENT.GUILD_MASTER_CHANGE, { way: GUILD_MASTER_CHANGE_WAY.BACKEND, change_id_after: roleId })
return resResult(STATUS.SUCCESS, { code });
}
}

124
game-server/app/servers/gm/handler/gmServerHandler.ts Normal file
View File

@@ -0,0 +1,124 @@
import { Application, BackendSession, pinus } from 'pinus';
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, RegionType } from '../../../db/Region';
import { gameData } from '../../../pubUtils/data';
import { Maintenance, ServerlistModel, ServerlistUpdate } 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 { createNewServer, sendOpenServerMail } from '../../../services/gmService';
import { initAutoCreateServer, initMaintenance, stopMaintenance } from '../../../services/timeTaskService';
import { isNumber } from 'util';
import { MarqueeModel } from '../../../db/Marquee';
let timer: NodeJS.Timer;
export default function (app: Application) {
return new GmHandler(app);
}
export class GmHandler {
constructor(private app: Application) {
}
// 保存大区配置
async saveRegionConf(msg: UpdateRegionParams, session: BackendSession) {
let params = new UpdateRegionParams(msg);
let uid = session.get('uid');
if(!params.checkParams()) return resResult(STATUS.WRONG_PARMS);
let region: RegionType;
if(params.id == 'new') {
let update = params.getUpdateParam();
region = await RegionModel.createNewRegion(update, uid);
} else {
let oldRegion = await RegionModel.findRegionById(params.id);
if(!oldRegion) return resResult(STATUS.WRONG_PARMS);
let update = params.getUpdateParam(oldRegion);
region = await RegionModel.updateRegion(params.id, update, uid);
}
await initAutoCreateServer(region);
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);
let { latestServer = 0 } = curRegion;
let dicServerName = gameData.serverNames.get(latestServer + 1);
if(!dicServerName) return resResult(STATUS.DIC_DATA_NOT_FOUND);
await createNewServer(curRegion, latestServer + 1, params, uid);
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 startRegionMaintenance(msg: { startTime: number, endTime: number, hasNotify: boolean }, session: BackendSession) {
const { startTime, endTime, hasNotify } = msg;
if(!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 servers = await ServerlistModel.findByEnv(this.app.get('env'));
console.log('*********servers', servers)
await ServerlistModel.updateByServerIds(servers.map(server => server.id), { maintenance: newMaintenance });
await pinus.app.rpc.systimer.systimerRemote.initMaintenance.broadcast(servers);
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) {
// 更新serverlist上的status
await ServerlistModel.updateByServerId(server.id, { 'maintenance.isOpen': false } as ServerlistUpdate);
// console.log('&&&', server, server.id)
await pinus.app.rpc.systimer.systimerRemote.stopMaintenance.broadcast(maintenance.batchCode, [server.id]);
}
return resResult(STATUS.SUCCESS,);
}
async sendMarquee(msg: { code: string }, session: BackendSession) {
const { code } = msg;
let marquee = await MarqueeModel.findByCode(code);
if(!marquee) return resResult(STATUS.DB_DATA_NOT_FOUND);
await MarqueeModel.updateData(code, { isEnable: true });
let result = await this.app.rpc.systimer.systimerRemote.setMarquee.broadcast(marquee);
if (!result) return resResult(STATUS.GM_MARQUEE_ERR);
return resResult(STATUS.SUCCESS);
}
async cancelMarquee(msg: { code: string }, session: BackendSession) {
const { code } = msg;
await MarqueeModel.updateData(code, { isEnable: false });
let result = await this.app.rpc.systimer.systimerRemote.cancelMarquee.broadcast(code);
if (!result) return resResult(STATUS.GM_MARQUEE_CANCEL_ERR);
return resResult(STATUS.SUCCESS);
}
}

75
game-server/app/servers/gm/remote/gmRemote.ts
View File

@@ -1,13 +1,6 @@
import { Application, ChannelService, HandlerService, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { STATUS } from '../../../consts';
import { setGmMails, getGmMailById, getGmMails, getGmUseMails } from '../../../pubUtils/gmData/gmDataUtil';
import { MAIL_TYPE, MAIL_TEM_TYPE, MAIL_STATUS } from "../../../consts/constModules/mailConst";
import { mailData } from "../../../pubUtils/interface";
import { findWhere } from 'underscore';
import { nowSeconds } from '../../../pubUtils/timeUtil';
import { GroupMailType } from '../../../db/GroupMail';
import { MailType } from '../../../db/Mail';
import { mongoose } from '@typegoose/typegoose';
const { ObjectId } = mongoose.Types;
export default function (app: Application) {
@@ -100,72 +93,4 @@ export class GMRemote {
};
channel.pushMessage('onLeave', resResult(STATUS.SUCCESS, param));
}
public refreshGmMails(mails: [any]) {
setGmMails(mails);
}
/**
* 获得据上次刷新后，可以加入的邮件
* @param updatedMailAt
* @param serverId
*/
public getMailsByTime(updatedMailAt: number, serverId: number) {
let gmMails = getGmMails(updatedMailAt, serverId);
return gmMails;
}
// /**
// * 获得可以领取的邮件奖
// * @param serverId
// * @param groupMailRewards
// * @param mailRewards
// */
// public getUseMails(serverId: number, groupMailRewards: GroupMailType[], mailRewards: MailType[]) {
// let nowTime = nowSeconds();
// let mailGoods = [];
// let mails = [];
// let mailIds = [];
// let groupMailIds = [];
// groupMailRewards.map(({_id, goods, mailId, mailTemType})=>{
// if (mailTemType == MAIL_TEM_TYPE.GMTYPE) {//gm邮件检查是否有奖励以及是否可以领取
// let gmMail = getGmMailById(mailId, serverId, nowTime);
// if (!gmMail || !gmMail.goods.length|| gmMail.endTime < nowSeconds()) {
// return;
// }
// mailGoods.push(...gmMail.goods);
// } else {
// if (!goods.length)//系统邮件，检查是否有奖励
// return;
// mailGoods.push(...goods);
// }
// mails.push({id: _id, status: MAIL_STATUS.RECEIVED, mailType: MAIL_TYPE.GROUPMAIL});
// groupMailIds.push(_id);
// });
// mailRewards.map(({_id, goods, mailId, mailTemType})=>{
// if (mailTemType == MAIL_TEM_TYPE.GMTYPE) {//gm邮件检查是否有奖励以及是否可以领取
// let gmMail = getGmMailById(mailId, serverId, nowTime);
// if (!gmMail || !gmMail.goods.length|| gmMail.endTime < nowSeconds()) {
// return;
// }
// mailGoods.push(...gmMail.goods);
// } else {
// if (!goods.length)//系统邮件，检查是否有奖励
// return;
// mailGoods.push(...goods);
// }
// mails.push({id: _id, status: MAIL_STATUS.RECEIVED, mailType: MAIL_TYPE.SINGLEMAIL});
// mailIds.push(_id);
// });
// return {mailIds, groupMailIds, mails, mailGoods};
// }
/**
* 通过模板mailId获得gm邮件
* @param mailId
* @param serverId
* @param nowTime
*/
public getUseGmMailById(mailId: string, serverId: number, nowTime: number) {
let gmMail = getGmMailById(mailId, serverId, nowTime);
return gmMail;
}
}

19
game-server/app/servers/guild/handler/guildHandler.ts
View File

@@ -109,7 +109,7 @@ export class GuildHandler {
const serverId = session.get('serverId');
const { page = 1, showPeopleMax, name } = msg;
const guildList = await GuildModel.findByCondition(page, showPeopleMax, name, serverId);
const guildList = await GuildModel.getGuildList(page, showPeopleMax, name, serverId);
const applyList = await UserGuildApplyModel.findApplyByRole(roleId);
const { quitGuildTime: quitTime = 0 } = await RoleModel.findByRoleId(roleId);
@@ -213,7 +213,7 @@ export class GuildHandler {
return resResult(STATUS.GUILD_MANAGER_REACH_MAX);
}
const userGuild = await UserGuildModel.updateInfo(memberRoleId, { auth, job: auth == GUILD_AUTH.LEADER ? GUILD_JOB.JIANGJUN : hisUserGuild.job }, {}, 'auth'); // 设置权限
const userGuild = await UserGuildModel.updateInfo(memberRoleId, { auth, job: auth == GUILD_AUTH.LEADER ? GUILD_JOB.DAJIANGJUN : hisUserGuild.job }, {}, 'auth'); // 设置权限
if (!userGuild) {
return resResult(STATUS.GUILD_MEMBER_NOT_FOUND);
}
@@ -422,7 +422,7 @@ export class GuildHandler {
const guild = await GuildModel.findByCode(code, serverId, GUILD_SELECT.INVITED_MEMBER);
if (guild.isMemberMax) return resResult(STATUS.GUILD_MEMBER_MAX);
const roleList = await RoleModel.findRoleByField('roleId', roleIds);
const roleList = await RoleModel.findByRoleIds(roleIds);
let result = new Array<string>();
let uids = [];
for (let role of roleList) {
@@ -564,7 +564,7 @@ export class GuildHandler {
await RoleModel.dissmissGuild(members);
await UserGuildApplyModel.deleteApplyByGuild(code);
await this.app.rpc.connector.connectorRemote.setOtherUserGuildSession.toServer(sid, members.map(roleId => { return { roleId, userGuild: null } })); // 更新session
await this.app.rpc.connector.connectorRemote.setOtherUserGuildSession.broadcast(members.map(roleId => { return { roleId, userGuild: null } })); // 更新session
// 删除channel
@@ -641,13 +641,14 @@ export class GuildHandler {
await removeTrainRank(code, roleId, guild.trainId);
let chatSid = await getGuildChannelSid(code);
const { sid } = await getRoleOnlineInfo(roleId);
const { isOnline, sid } = await getRoleOnlineInfo(roleId);
this.app.rpc.chat.guildRemote.memberQuit.toServer(chatSid, code, roleId, guild, sid);
// 添加动态
const rec = await GuildRecModel.createGuildRec(roleId, code, GUILD_REC_TYPE.QUIT_GUILD, [role.roleName]);
this.app.rpc.chat.guildRemote.addRec.toServer(chatSid, rec);
await this.app.rpc.connector.connectorRemote.setOtherUserGuildSession.toServer(sid,[{ roleId: memberRoleId, userGuild }]);
if(isOnline)
await this.app.rpc.connector.connectorRemote.setOtherUserGuildSession.toServer(sid,[{ roleId: memberRoleId, userGuild }]);
await sendMailByContent(MAIL_TYPE.GUILD_BE_KICK, memberRoleId, { sendName: roleName, params: [guild.name] });
reportTAEvent(memberRoleId, TA_EVENT.GUILD_QUIT, { name: guild.name, way: GUILD_QUIT_WAY.KICK });
@@ -697,10 +698,10 @@ export class GuildHandler {
// 交换
let oldLeaderUserGuild = await UserGuildModel.updateInfo(leaderRoleId, { auth: GUILD_AUTH.MEMBER, job: GUILD_JOB.SHIBING }, {}, 'auth'); // 团长撤
await this.app.rpc.connector.connectorRemote.setOtherUserGuildSession.toServer(sid,[{ roleId: leaderRoleId, oldLeaderUserGuild }]); // 更新session
await this.app.rpc.connector.connectorRemote.setOtherUserGuildSession.broadcast([{ roleId: leaderRoleId, userGuild: oldLeaderUserGuild }]); // 更新session
let newLeaderUserGuild = await UserGuildModel.updateInfo(topUserGuild.roleId, { auth: GUILD_AUTH.LEADER, job: GUILD_JOB.JIANGJUN }, {}, 'auth'); // 最高功勋人升
await this.app.rpc.connector.connectorRemote.setOtherUserGuildSession.toServer(sid,[{ roleId: topUserGuild.roleId, newLeaderUserGuild }]); // 更新session
let newLeaderUserGuild = await UserGuildModel.updateInfo(topUserGuild.roleId, { auth: GUILD_AUTH.LEADER, job: GUILD_JOB.DAJIANGJUN }, {}, 'auth'); // 最高功勋人升
await this.app.rpc.connector.connectorRemote.setOtherUserGuildSession.broadcast([{ roleId: topUserGuild.roleId, userGuild: newLeaderUserGuild }]); // 更新session
let managerCntInc = topUserGuild.auth == GUILD_AUTH.MANAGER ? -1 : 0; // 管理人数

19
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 { taflush, treatGuildName } from '../../../services/sdkService';
import { getServerMainten, setServerMainten, stopServerMainten } from '../../../services/gmService';
export default function (app: Application) {
new HandlerService(app, {});
@@ -26,4 +27,20 @@ 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);
}
public taflush() {
return taflush();
}
}

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

@@ -1,6 +1,8 @@
import { Application, ChannelService, HandlerService, } from 'pinus';
import { reloadResources } from '../../../pubUtils/data';
import { settleOrderFromRedisPub } from '../../../services/orderService';
import { getServerMainten, setServerMainten, stopServerMainten } from '../../../services/gmService';
import { taflush } from '../../../services/sdkService';
export default function (app: Application) {
new HandlerService(app, {});
@@ -26,4 +28,20 @@ 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);
}
public taflush() {
return taflush();
}
}

29
game-server/app/servers/role/handler/itemHandler.ts
View File

@@ -1,5 +1,5 @@
import { Application, BackendSession, HandlerService, } from "pinus";
import { STATUS, CONSUME_TYPE, DEBUG_MAGIC_WORD, ITEM_CHANGE_REASON } from "../../../consts";
import { STATUS, CONSUME_TYPE, DEBUG_MAGIC_WORD, GIFT_GENERATE_TYPE, ITEM_CHANGE_REASON } from "../../../consts";
import { RewardInter } from "../../../pubUtils/interface";
import { resResult } from "../../../pubUtils/util";
@@ -12,7 +12,7 @@ import { getAp, setAp, setApBuyTimes } from "../../../services/actionPointServic
import { ActionPointModel } from "../../../db/ActionPoint";
import { GiftCodeDetailModel } from "../../../db/GiftCodeDetail";
import { GiftCodeType, GiftCodeModel } from "../../../db/GiftCode";
import UserGiftCode, { UserGiftCodeModel } from "../../../db/UserGiftCode";
import { nowSeconds } from "../../../pubUtils/timeUtil";
export default function (app: Application) {
new HandlerService(app, {});
@@ -141,6 +141,7 @@ export class ItemHandler {
public async useGiftCode(msg: { code: string }, session: BackendSession) {
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const serverId: number = session.get('serverId');
const sid: string = session.get('sid');
const { code } = msg;
@@ -148,24 +149,28 @@ export class ItemHandler {
if(!giftCodeDetail) {
return resResult(STATUS.GIFT_CODE_NOT_FOUND);
}
let giftCode = <GiftCodeType>giftCodeDetail.giftCode;
let giftCode = await GiftCodeModel.findByGiftId(giftCodeDetail.giftId);
if(!giftCode) {
return resResult(STATUS.GIFT_CODE_NOT_FOUND);
}
if (giftCode.isLimit && giftCodeDetail.usedNum >= giftCode.count) {
return resResult(STATUS.GIFT_CODE_USED_NUM_MAX);
if(giftCode.generateType == GIFT_GENERATE_TYPE.ONE_TO_ONE) { // 一人一条，单条不能被多人使用
if(giftCodeDetail.usedNum > 0) return resResult(STATUS.GIFT_CODE_USED_NUM_MAX);
}
if (giftCode.beginTime > new Date()) return resResult(STATUS.GIFT_CODE_NOT_START);
if (giftCode.endTime < new Date()) return resResult(STATUS.GIFT_CODE_HAS_EXPIRED);
if(!giftCode.isEnable) return resResult(STATUS.GIFT_CODE_HAS_EXPIRED);
if (giftCode.beginTime > nowSeconds()) return resResult(STATUS.GIFT_CODE_NOT_START);
if (giftCode.endTime < nowSeconds()) return resResult(STATUS.GIFT_CODE_HAS_EXPIRED);
let userGiftCode = await UserGiftCodeModel.findByCode(roleId, code);
if (userGiftCode) {
if (giftCodeDetail.roleIds.indexOf(roleId) != -1) {
return resResult(STATUS.YOU_HAVE_USED_THIS_CODE);
}
await UserGiftCode.createCode(roleId, code, giftCode);
await GiftCodeDetailModel.increaseUsedNum(code);
let checkHasUse = await GiftCodeDetailModel.checkHasUsed(roleId, giftCodeDetail.giftId)
if(checkHasUse) {
return resResult(STATUS.YOU_HAVE_USED_THIS_CODE);
}
await GiftCodeDetailModel.increaseUsedNum(code, roleId, roleName, serverId);
await GiftCodeModel.increaseUsedNum(giftCode.id);
let goods = await addItems(roleId, roleName, sid, giftCode.goods, ITEM_CHANGE_REASON.USE_GIFT_CODE);

2
game-server/app/servers/role/handler/mailHandler.ts
View File

@@ -3,7 +3,7 @@ import { MailModel, MailType } from '../../../db/Mail';
import { GroupMailModel, GroupMailType } from '../../../db/GroupMail';
import { resResult } from '../../../pubUtils/util';
import { STATUS } from '../../../consts/statusCode';
import { MAIL_STATUS, MAIL_TEM_TYPE, GM_MAIL_TYPE } from '../../../consts/constModules/mailConst';
import { MAIL_STATUS, GM_MAIL_TYPE } from '../../../consts/constModules/mailConst';
import { addItems } from '../../../services/rewardService';
import { checkMailGoods, getMails } from '../../../services/mailService';
import { ServerMailModel, ServerMailType } from '../../../db/ServerMail';

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

@@ -10,7 +10,9 @@ import { DEFAULT_HEROES } from '../../../consts';
import { Figure } from '../../../domain/dbGeneral';
import { getDefaultRoleInfo } from '../../../services/roleService';
import { PVPConfigType } from '../../../db/SystemConfig';
import { treatRoleName } from '../../../services/sdkService';
import { treatRoleName, taflush } 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,20 @@ 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);
}
public taflush() {
return taflush();
}
}

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

@@ -1,11 +1,14 @@
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';
import { MarqueeType } from '../../../db/Marquee';
import { taflush } from '../../../services/sdkService';
export default function (app: Application) {
return new SystimerRemote(app);
@@ -50,8 +53,8 @@ export class SystimerRemote {
* @description 设置跑马灯配置
* @param code 跑马灯唯一code
*/
public async setMarquee(code: string) {
return await setMarquee(code);
public async setMarquee(marquee: MarqueeType) {
return await setMarquee(marquee);
}
public async cancelMarquee(code: string) {
@@ -89,4 +92,16 @@ 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);
}
public taflush() {
return taflush();
}
}

36
game-server/app/services/activity/activityService.ts
View File

@@ -31,6 +31,7 @@ import { getRandSingleEelm } from '../../pubUtils/util';
import { SignInData } from '../../domain/activityField/signInField';
import { ActivityGroupModel } from '../../db/ActivityGroup';
import { ActivityGroupTypeModel } from '../../db/ActivityGroupType';
import { ServerlistModel } from '../../db/Serverlist';
/**
* 获取活动数据
@@ -260,31 +261,40 @@ export function _getActivities() {
export async function checkActivityEditable(activities: ActivityModelType[]) {
let now = new Date();
if(pinus.app.get('env') == 'production') {
for(let activity of activities) {
if(!activity || (activity.beginTime < now && activity.endTime > now)) {
if(activity.type == ACTIVITY_TYPE.SIGN_IN || activity.type == ACTIVITY_TYPE.SIGN_IN_VIP) {
// 签到活动的不显示期内也可以编辑
let signInObj = new SignInData(activity, 0);
if(signInObj.beginTime < now.getTime() && signInObj.endTime > now.getTime() ) {
return false;
}
} else {
for(let activity of activities) {
if(!activity || (activity.beginTime < now && activity.endTime > now)) {
if(activity.type == ACTIVITY_TYPE.SIGN_IN || activity.type == ACTIVITY_TYPE.SIGN_IN_VIP) {
// 签到活动的不显示期内也可以编辑
let signInObj = new SignInData(activity, 0);
if(signInObj.beginTime < now.getTime() && signInObj.endTime > now.getTime() ) {
return false;
}
} else {
return false;
}
}
}
return true;
}
export async function checkActivityGroupType(groupId: number, activities: ActivityModelType[]) {
export async function checkActivityGroupTypeWithId(groupId: number, activities: ActivityModelType[]) {
let activityGroup = await ActivityGroupModel.findGroupData(groupId);
if(!activityGroup) return false;
if(activityGroup.type != 0) {
let activityGroupType = await ActivityGroupTypeModel.findByGroupType(activityGroup.type);
return await checkActivityGroupType(activityGroup.type, activities);
}
return true
}
export async function checkActivityGroupType(groupType: number, activities: ActivityModelType[]) {
if(groupType != 0) {
let activityGroupType = await ActivityGroupTypeModel.findByGroupType(groupType);
if(!activityGroupType) return false;
let dic = activityGroupType.activityTypes;
for(let { type } of activities) {

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

@@ -297,7 +297,7 @@ export async function recentPrivateChatInfos(roleId: string, roleName: string) {
.splice(CHAT_SYSTEM.RECENT_PRIVATE_CHATS_CNT);
if (!recentPrivateChats || !recentPrivateChats.length) return null;
const roleInfos = await RoleModel.findRoleByField('roleId', recentPrivateChats.map(chat => { return chat.targetRoleId }));
const roleInfos = await RoleModel.findByRoleIds(recentPrivateChats.map(chat => { return chat.targetRoleId }));
const chatInfos = recentPrivateChats.map( chat => {
for (let { roleId: targetRoleId, quitTime, loginTime, roleName: targetRoleName, title, guildName, head, frame, spine, lv } of roleInfos) {
if (targetRoleId === chat.targetRoleId) {

4
game-server/app/services/connectorService.ts
View File

@@ -247,7 +247,7 @@ export async function everydayRefresh() {
setMedianCe();
}
export async function kickUser(app: Application, uid: string) {
export async function kickUser(app: Application, uid: string, message = STATUS.LOGIN_ERR) {
let sessionService = app.get('sessionService');
let sessions = sessionService.getByUid(uid);
if (!!sessions) {
@@ -255,7 +255,7 @@ export async function kickUser(app: Application, uid: string) {
let roleId = session.get('roleId');
let sid = session.get('sid');
let uids = [{ uid: roleId, sid }];
app.get('channelService').pushMessageByUids('onRemoteLogin', resResult(STATUS.LOGIN_ERR), uids);
app.get('channelService').pushMessageByUids('onRemoteLogin', resResult(message), uids);
});
}
await sessionService.akick(uid);

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

@@ -1,30 +1,34 @@
import { MarqueeType, MarqueeModel } from "../db/Marquee";
import { MARQUEE_TYPE, SERVER_STATUS } from "../consts";
import Marquee, { MarqueeType, MarqueeModel } from "../db/Marquee";
import { GM_MAIL_STATUS, GM_MAIL_TYPE, MAIL_TIME_TYPE, MARQUEE_SHOW_TYPE, MARQUEE_TIME_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";
import { CreateServerParam } from "../domain/backEndField/params";
import { RegionModel, RegionType } from "../db/Region";
import { GMMail as StategyMail } from "../db/ServerStategy";
import { uniq } from "underscore";
// —————————————— 跑马灯 —————————————— //
// 初始
export async function initMarquee() {
const marquees = await MarqueeModel.findEffectiveMarque();
const marquees = await MarqueeModel.findEffectiveMarque(pinus.app.get('env'));
for(let marquee of marquees) {
await generateMarqueeSchedule(marquee);
}
}
export async function setMarquee(code: string) {
let marquee = await MarqueeModel.findByCode(code);
if(marquee.type == MARQUEE_TYPE.INSTANT) {
let msgDatas = await createMarqueeMsg(marquee);
await pushMarqueeMsg(msgDatas);
export async function setMarquee(marquee: MarqueeType) {
console.log('******', marquee.timeType, marquee)
if(marquee.timeType == MARQUEE_TIME_TYPE.INSTANT) {
await startMarquee(marquee);
return true;
} else {
return await generateMarqueeSchedule(marquee);
@@ -32,14 +36,14 @@ export async function setMarquee(code: string) {
}
async function generateMarqueeSchedule(marquee: MarqueeType) {
// 定时发送
let setSecondsMarquee = scheduledJobs[`setSeconds${marquee.code}`];
if(setSecondsMarquee) return false; // 已经在运行中了
if(marquee.type != MARQUEE_TYPE.SCHEDULE) return false;
if(marquee.startTime.getTime() >= marquee.endTime.getTime()) return false;
if(marquee.endTime.getTime() < Date.now()) return false;
if(marquee.startTime.getTime() > Date.now()) {
let startJob = scheduleJob(`start${marquee.code}`, marquee.startTime.getTime(), async () => {
if(marquee.timeType != MARQUEE_TIME_TYPE.SCHEDULE) return false;
if(marquee.endTime && marquee.endTime < nowSeconds()) return false;
if(marquee.startTime > nowSeconds()) {
let startJob = scheduleJob(`start${marquee.code}`, marquee.startTime * 1000, async () => {
await startMarquee(marquee, startJob)
});
} else {
@@ -50,37 +54,56 @@ async function generateMarqueeSchedule(marquee: MarqueeType) {
async function startMarquee(marquee: MarqueeType, startJob?: Job) {
console.log('************', `跑马灯定时器 ${marquee.code}开始`, '************');
await MarqueeModel.updateData(marquee.code, { isRunning: true });
let msgDatas = await createMarqueeMsg(marquee);
await pushMarqueeMsg(msgDatas);
let secondsJob = scheduleJob(`setSeconds${marquee.code}`, `*/${marquee.interval} * * * * *`, async () => {
console.log(`*****setSeconds${marquee.code}****`)
if(marquee.showType == MARQUEE_SHOW_TYPE.ONCE) { // 一次性发送
await pushMarqueeMsg(msgDatas);
});
let endJob = scheduleJob(`end${marquee.code}`, marquee.endTime.getTime(), async () => {
if(startJob) {
startJob.cancel();
startJob = undefined;
}
if(secondsJob) {
secondsJob.cancel();
secondsJob = undefined;
}
if(endJob) {
endJob.cancel();
endJob = undefined;
}
await MarqueeModel.updateData(marquee.code, { isRunning: false });
});
} else {
await pushMarqueeMsg(msgDatas);
console.log('***', marquee.interval)
let secondsJob = scheduleJob(`setSeconds${marquee.code}`, `*/${marquee.interval} * * * * *`, async () => {
console.log(`*****setSeconds${marquee.code}****`)
await pushMarqueeMsg(msgDatas);
});
let endJob = scheduleJob(`end${marquee.code}`, marquee.endTime * 1000, async () => {
if(startJob) {
startJob.cancel();
startJob = undefined;
}
if(secondsJob) {
secondsJob.cancel();
secondsJob = undefined;
}
if(endJob) {
endJob.cancel();
endJob = undefined;
}
});
}
}
async function createMarqueeMsg(marquee: MarqueeType) {
let { serverIds, content } = marquee;
let { receivers, content } = marquee;
let msgDatas: GroupMessageType[] = [];
for(let serverId of serverIds) {
let serverIds: number[] = [];
for(let { env, serverId } of receivers) {
if(serverId == 0) {
let servers = await ServerlistModel.findByEnv(env);
for(let { serverId } of servers) {
serverIds.push(serverId);
}
} else {
serverIds.push(serverId);
}
}
for(let serverId of uniq(serverIds)) {
let msgData = await sysCreateMarqueeMsg('', '系统', serverId, content);
msgDatas.push(msgData);
}
return msgDatas;
}
@@ -97,75 +120,65 @@ export async function cancelMarquee(code: string) {
if(startMarquee) startMarquee.cancel();
if(setSecondsMarquee) setSecondsMarquee.cancel();
if(endMarquee) endMarquee.cancel();
await MarqueeModel.updateData(code, { isRunning: false });
return true
}
// —————————————— 停服维护 —————————————— //
// 维护信息
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 sendOpenServerMail(type: 'openMail'|'circleMail', mail: StategyMail, newServer: ServerlistType, uid: number) {
let addParam = new GMMail();
addParam.setByRegionStategy(type, mail, newServer, uid);
let gmmail = await GMMailModel.addMail(addParam, uid);
let needSend = false;
if(mail.timeType == MAIL_TIME_TYPE.CIRCLE) {
let refTimeStr = REF_CIRCLE_MAIL_TIME >= 10? `${REF_CIRCLE_MAIL_TIME}`: `0${REF_CIRCLE_MAIL_TIME}`;
let refTime = moment(moment().format(`YYYY-MM-DD ${refTimeStr}: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;
}
}
// 开启维护
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) {
if(needSend) {
let f = new SendMailFun();
await f.setWithGmMail((<GMMailType>mail)._id);
await f.sendToServer(serverIds);
await f.saveRecord(uid);
await f.setWithGmMail(gmmail);
await f.sendToServer([newServer.id]);
}
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);
}
export async function createNewServer(region: RegionType ,serverId: number, params: CreateServerParam, uid?: number) {
let newServer = await ServerlistModel.newServer(params, region, serverId, uid);
if(params.openMail) await sendOpenServerMail('openMail', params.openMail, newServer, uid);
if(params.circleMail) await sendOpenServerMail('circleMail', params.circleMail, newServer, uid);
await RegionModel.newServer(region.id, newServer);
}

18
game-server/app/services/guildActivityService.ts
View File

@@ -57,16 +57,14 @@ export async function setMedianCe() {
let servers = await ServerlistModel.getAllServerList();
for (let server of servers) {
if (server.serverType == 'official') {
let medianRole = await RoleModel.getMedianRole(server.id);
if (!medianRole) {
await ServerlistModel.updateByServerId(server.id, { medianCe: GUILDACTIVITY.GATEACTIVITY_ENEMYCE });
} else {
let { topLineup } = medianRole;
let topHero = topLineup.sort((a, b) => b.ce - a.ce);
let medianCe = reduceCe(topHero[0].ce);
await ServerlistModel.updateByServerId(server.id, { medianCe });
}
let medianRole = await RoleModel.getMedianRole(server.id);
if (!medianRole) {
await ServerlistModel.updateByServerId(server.id, { medianCe: GUILDACTIVITY.GATEACTIVITY_ENEMYCE });
} else {
let { topLineup } = medianRole;
let topHero = topLineup.sort((a, b) => b.ce - a.ce);
let medianCe = reduceCe(topHero[0].ce);
await ServerlistModel.updateByServerId(server.id, { medianCe });
}
}
return servers;

3
game-server/app/services/guildService.ts
View File

@@ -112,13 +112,12 @@ export async function joinGuild(code: string, guildName: string, lv: number, rol
const { sid } = await getRoleOnlineInfo(roleId);
if (sid) {
await addRoleToGuildChannel(roleId, sid, code);
await pinus.app.rpc.connector.connectorRemote.setOtherUserGuildSession.toServer(sid,[{ roleId, userGuild }]);
}
//成长任务-加入军团
await checkActivityTask(serverId, sid, roleId, TASK_TYPE.GUILD_JOIN, 1);
await pinus.app.rpc.connector.connectorRemote.setOtherUserGuildSession.toServer(sid,[{ roleId, userGuild }]);
return { status: 0, guild, userGuild, roleName: role.roleName, memberCnt: guild.memberCnt, guildCe: guild.guildCe }
}

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

@@ -8,13 +8,14 @@ import { gameData } from "../pubUtils/data";
import { nowSeconds } from '../pubUtils/timeUtil';
import { STATUS } from '../consts/statusCode';
import { resResult } from '../pubUtils/util';
import { GM_MAIL_TYPE, ITID, MAIL_STATUS, MAIL_TYPE, SEND_NAME } from "../consts";
import { GM_MAIL_TYPE, ITID, MAIL_STATUS, MAIL_TIME_TYPE, MAIL_TYPE, SEND_NAME, SEND_TITLE } from "../consts";
import { MailParam } from '../domain/roleField/mail';
import { GMMailType, GMMailModel } from "../db/GMMail";
import { GMMailType, GMMailModel, GMMailTypeParam } from "../db/GMMail";
import { getGuildChannelSid, getWorldChannelSid } from "./chatChannelService";
import { GMMailRecordModel } from "../db/GMMailRecord";
import { BAG } from "../pubUtils/dicParam";
import { GuildModel, GuildType } from "../db/Guild";
import moment = require("moment");
/**
* 获取邮件信息
@@ -73,9 +74,10 @@ export async function sendMailToGuildByContent(contentId: MAIL_TYPE, guildCode:
export class SendMailFun {
private mailType: GM_MAIL_TYPE = GM_MAIL_TYPE.SINGLE; // 邮件类型 1-单人 2-多人 3-全服
private contentId: MAIL_TYPE = MAIL_TYPE.SEND_MAIL; // 0-读GmMail，1以上读dicMail
private params: string[] = [];
private sendName: string = SEND_NAME;
private gmmail: GMMailType;
private title: string = SEND_TITLE;
private content: string = '';
private gmmail: GMMailTypeParam;
private hasGoods: boolean = false; // 是否内含奖励
private goods: RewardInter[] = []; // 发送的奖励
private sendTime: number;
@@ -86,41 +88,44 @@ export class SendMailFun {
private serverMails: ServerMailType[] = [];
// 从dicMail读取数据
public setWithContentId(contentId: MAIL_TYPE, params: { sendName?: string, endTime?: number, params?: string[], goods?: RewardInter[] }) {
public setWithContentId(contentId: MAIL_TYPE, params: { sendName?: string, params?: string[], goods?: RewardInter[] }) {
let dicMail = gameData.mail.get(contentId);
this.contentId = contentId;
this.sendTime = nowSeconds();
this.endTime = this.sendTime + dicMail?.time||0;
this.setParam({ ...params });
this.content = this.getContent(dicMail.content, params.params);
if(dicMail.title) this.title = dicMail.title;
if(dicMail.sendName) this.sendName = dicMail.sendName;
this.hasGoods = params.goods?.length > 0;
this.goods = params.goods||[];
}
getContent(content: string, params: string[]) {
if(!content) content = '%d';
for(let p of params) {
content = content.replace(/%d/, p);
}
return content
}
// 从GMMail表读取数据
public async setWithGmMail(gmmailId: string) {
let gmmail = await GMMailModel.getGmMailById(gmmailId);
if(gmmail) {
this.gmmail = gmmail;
if(gmmail.useTempTime) {
this.sendTime = gmmail.sendTime;
this.endTime = gmmail.endTime;
} else {
this.sendTime = nowSeconds();
this.endTime = this.sendTime + (gmmail.continueHour||0) * 60 * 60;
}
this.setParam({ ...gmmail });
}
}
private setParam(params: { sendName?: string, endTime?: number, params?: string[], goods?: RewardInter[], content?: string }) {
if(params.sendName) this.sendName = params.sendName;
if(params.endTime) this.endTime = params.endTime;
if(params.content) {
this.params.push(params.content);
}
if(params.params) this.params = params.params;
if(params.goods) {
this.hasGoods = params.goods.length > 0;
this.goods = params.goods;
public async setWithGmMail(gmmail: GMMailType) {
this.gmmail = gmmail;
this.contentId = 0;
if(gmmail.timeType == MAIL_TIME_TYPE.IMMEDIATE) {
this.sendTime = nowSeconds();
} else if (gmmail.timeType == MAIL_TIME_TYPE.DELAY) {
this.sendTime = gmmail.startTime;
} else if (gmmail.timeType == MAIL_TIME_TYPE.CIRCLE) {
this.sendTime = moment(moment().format('YYYY-MM-DD ' + gmmail.circleHour)).unix();
}
this.endTime = this.sendTime + gmmail.expire * 60 * 60;
this.sendName = gmmail.sendName;
this.title = gmmail.title;
this.content = gmmail.content;
this.hasGoods = gmmail.hasGoods;
this.goods = gmmail.goods;
return gmmail;
}
private getCreateMailParams() {
@@ -129,9 +134,10 @@ export class SendMailFun {
mail: this.gmmail?._id,
sendTime: this.sendTime,
endTime: this.endTime,
params: this.params,
goods: this.goods,
goods: this.goods,
title: this.title,
sendName: this.sendName,
content: this.content,
hasGoods: this.hasGoods
}
}

1
game-server/app/services/rankService.ts
View File

@@ -925,6 +925,7 @@ export async function setRankRedisFromDb(type: string, args?: { serverId?: numbe
await r.setRankWithGuildInfo(guild.code, guild.activeWeekly, guild.activeUpdateTime, guild);
}
} else if (type == REDIS_KEY.GUILD_LV_RANK) {
let serverId = args.serverId;
let ranks = await GuildModel.getRank(type, serverId);
let r = new Rank(type, { serverId });

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

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

@@ -84,7 +84,7 @@ export async function getSimpleRoleInfo(roleId: string) {
export async function getSimpleRoleInfos(roleIds: string[]) {
if (!roleIds || !roleIds.length) return null;
let roles = await RoleModel.findRoleByField('roleId', roleIds, ROLE_SELECT.SHOW_SIMPLE, true);
let roles = await RoleModel.findByRoleIds(roleIds, ROLE_SELECT.SHOW_SIMPLE, true);
return roles;
}

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

@@ -1,17 +1,17 @@
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 } from '../consts';
import { GUILD_ACTIVITY_TYPE, REFRESH_TIME, SEND_NAME, SERVER_OPEN_TIME, COUNTER, AUCTION_TIME, GM_MAIL_TYPE, SERVER_STATUS, SERVER_TIMER } from '../consts';
import { RoleModel } from '../db/Role';
import { pinus } from 'pinus';
import { indexOf } from 'underscore';
import { PvpSeasonResultModel } from '../db/PvpSeasonResult';
import { settleGuildWeekly } from './guildService';
import { sendMailByContent } from './mailService';
import { sendMailByContent, SendMailFun } from './mailService';
import { getGuildActivityByDic, sendEndMsgToAll, autoDeclare, sendGuildActivityStatus } from './guildActivityService';
import { sendUngotDividendJob, startGuildAuction, startWorldAuction, stopAuction } from './auctionService';
import { DicGuildActivity } from '../pubUtils/dictionary/DicGuildActivity';
@@ -19,29 +19,32 @@ import { dispatch } from '../pubUtils/dispatcher';
import { Rank } from './rankService';
import { checkTask } from './taskService';
import { everydayRefresh } from './connectorService';
import { initMarquee, initMaintenance } from './gmService';
import { createNewServer, 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';
import { RegionModel, RegionType } from '../db/Region';
import { CreateServerParam } from '../domain/backEndField/params';
const PER_SECOND = 1 * 1000;
const PER_DAY = 24 * 60 * 60;
const PER_HOUR = 1 * 60 * 60;
const PER_MINUTE = 1 * 60;
var seasonMakeRewardTimJobId: Job;
var warJobId: Job;
var seasonRefreshTimeJobId: Job;
let guildWeeklyJobId: Job;
let guildActStartJobId: Job; // 军团活动开启后每10(or 1)秒循环的定时任务，到结束活动清除
let guildActSecondsJobId: Job; // 军团活动开启后每10(or 1)秒循环的定时任务，到结束活动清除
let guildActEndJobId: Job; // 军团活动开启后每10(or 1)秒循环的定时任务，到结束活动清除
let pvpMakeRewardInterval = null;
let pvpRefreshInterval = null;
/**
* 服务器启动即开启定时任务，结算时常是23-24点，实际结算的时间点是23：31分钟
* 初始定时器
*/
export async function init() {
@@ -51,7 +54,7 @@ export async function init() {
await setPvpSeason();
// 周功勋结算任务
guildWeeklyJobId = scheduleJob('settleGuildWeekly', '0 0 0 * * 1', settleGuildWeekly);
guildWeeklyJobId = scheduleJob('settleGuildWeekly', '0 0 ? * * 1', settleGuildWeekly);
// 每5分钟汇报在线玩家在线情况
scheduleJob('reportOnline', '0 0/5 * * * *', reportOnlineSchedule);
@@ -59,6 +62,9 @@ export async function init() {
// 每天拉取37词库
scheduleJob('fetchWord', '0 0 4 * * ?', fetch37Words);
// 每天邮件
scheduleJob('circleMail', '0 0 3 * * ?', sendCircleMail);
// 军团活动排行榜
guildActivitySchedule();
@@ -74,8 +80,12 @@ export async function init() {
// 维护信息
await initMaintenance();
// 自动开服
await initAutoCreateServer();
}
// —————————————— PVP 及赛季相关 —————————————— //
function getSeasonContinueDay(seasonNum: number) {
const pvpSeasonDuring = PVP.PVP_SEASON_DAYS.split('|').map(cur => {
let arr = cur.split('&');
@@ -190,7 +200,9 @@ export async function reportOnlineSchedule() {
}
}
// —————————————— PVP 及赛季相关 end —————————————— //
// —————————————— 军团活动 —————————————— //
/**
* 军团活动，每晚8点开启
*/
@@ -336,6 +348,10 @@ export async function raceActivitySeconds() {
}
}
// —————————————— 军团活动 end —————————————— //
// —————————————— 拍卖行 —————————————— //
let startGuildAuctionJobId: Job;
let startWorldAuctionJobId: Job;
let stopAuctionJobId: Job;
@@ -374,4 +390,186 @@ function clearAuctionSchedule() {
sendUngotDividendJobId.cancel();
sendUngotDividendJobId = undefined;
}
}
}
// —————————————— 拍卖行 end —————————————— //
// —————————————— 邮件 —————————————— //
async function sendCircleMail() {
let gmmails = await GMMailModel.findCircleMails(pinus.app.get('env'));
for(let gmmail of gmmails) {
let { receivers, mailType } = gmmail;
let f = new SendMailFun();
await f.setWithGmMail(gmmail);
if (mailType == GM_MAIL_TYPE.SINGLE || mailType == GM_MAIL_TYPE.GROUP) {
let roleIds = receivers.map(cur => cur.roleId);
await f.sendToUsers(mailType, roleIds);
} else {
let serverIds = receivers.map(cur => cur.serverId);
await f.sendToServer(serverIds);
}
}
}
// —————————————— 邮件 end —————————————— //
// —————————————— 维护 —————————————— //
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'));
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);
}
}
// 更新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);
}
// 更新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);
}
// —————————————— 维护 end —————————————— //
// —————————————— 自动开服 —————————————— //
export async function initAutoCreateServer(region?: RegionType) {
if(!region) region = await RegionModel.findRegionByEnv(pinus.app.get('env'));
if(region && region.stategy) {
for(let timer of region.stategy.timers) {
setStategyTimer(timer, region)
}
}
}
function setStategyTimer(timerId: number, region: RegionType) {
if(scheduledJobs[`autoServer${timerId}`]) scheduledJobs[`autoServer${timerId}`].cancel();
let cron = '';
switch(timerId) {
case SERVER_TIMER.FIVE_HALF:
cron = '0 30 5 * * *'; break;
case SERVER_TIMER.TEN_HALF:
cron = '0 30 10 * * *'; break;
case SERVER_TIMER.FIFTEEN_HALF:
cron = '0 30 15 * * *'; break;
case SERVER_TIMER.NINETEEN_HALF:
cron = '0 30 19 * * *'; break;
}
if(cron) {
scheduleJob(`autoServer${timerId}`, cron, () => {
autoCreateServerSchedule(region);
})
}
}
async function autoCreateServerSchedule(region: RegionType) {
console.log('******* createNewServer *******')
let latestServer = await ServerlistModel.findByServerId(region.latestServerUniqId);
if(!latestServer || latestServer.playerCnt >= region.stategy.maxPlayerCnt) {
let params = new CreateServerParam();
params.setByRegionStategy(region, nowSeconds())
await createNewServer(region, (latestServer?.serverId||0) + 1, params);
}
}
// —————————————— 自动开服 end —————————————— //

3
game-server/config.js
View File

@@ -5,9 +5,6 @@ function main (){
return console.log('参数请填写环境变量');
}
let env = args[0];
if(args[0] == 'stable') {
env = 'production';
}
let configObject = {
env: env

9
game-server/config/database.ts
View File

@@ -1,37 +1,44 @@
module.exports = {
'development': {
'mongo': 'mongodb://127.0.0.1/zyz',
'gmmongo': 'mongodb://127.0.0.1/zyzgm',
'redis': '127.0.0.1',
'redispw': 'zyz_2020'
},
'production': {
'stable': {
'mongo': 'mongodb://dbop:zyzdbopbantu@dds-8vbdb47c6fb58a541.mongodb.zhangbei.rds.aliyuncs.com:3717,dds-8vbdb47c6fb58a542.mongodb.zhangbei.rds.aliyuncs.com:3717/zyz?replicaSet=mgset-500808098',
'gmmongo': 'mongodb://dbop:zyzGm2021@dds-8vb9964bb4cc7f241.mongodb.zhangbei.rds.aliyuncs.com:3717,dds-8vb9964bb4cc7f242.mongodb.zhangbei.rds.aliyuncs.com:3717/zyzgm?replicaSet=mgset-507933150',
'redis': 'r-8vb4i2kgl91886fkxd.redis.zhangbei.rds.aliyuncs.com',
'redispw': 'zyz_2020'
},
'alpha': {
'mongo': 'mongodb://dbop:zyzDev2021@dds-8vb5c74ba4263da41.mongodb.zhangbei.rds.aliyuncs.com:3717,dds-8vb5c74ba4263da42.mongodb.zhangbei.rds.aliyuncs.com:3717,dds-8vb5c74ba4263da43.mongodb.zhangbei.rds.aliyuncs.com:3717/zyz?readPreference=secondary&replicaSet=mgset-506991391',
'gmmongo': 'mongodb://dbop:zyzGm2021@dds-8vb9964bb4cc7f241.mongodb.zhangbei.rds.aliyuncs.com:3717,dds-8vb9964bb4cc7f242.mongodb.zhangbei.rds.aliyuncs.com:3717/zyzgm?replicaSet=mgset-507933150',
'redis': 'r-8vbl8okinxn1zhkwh2.redis.zhangbei.rds.aliyuncs.com',
'redispw': 'zyz_alpha_2021'
},
'dev': {
'mongo': 'mongodb://dbop:zyzDev2021@dds-8vb5c74ba4263da41.mongodb.zhangbei.rds.aliyuncs.com:3717,dds-8vb5c74ba4263da42.mongodb.zhangbei.rds.aliyuncs.com:3717,dds-8vb5c74ba4263da43.mongodb.zhangbei.rds.aliyuncs.com:3717/zyz?readPreference=secondary&replicaSet=mgset-506991391',
'gmmongo': 'mongodb://dbop:zyzGm2021@dds-8vb9964bb4cc7f241.mongodb.zhangbei.rds.aliyuncs.com:3717,dds-8vb9964bb4cc7f242.mongodb.zhangbei.rds.aliyuncs.com:3717/zyzgm?replicaSet=mgset-507933150',
'redis': 'r-8vb418l8kkju9sis8k.redis.zhangbei.rds.aliyuncs.com',
'redispw': 'zyz_dev_2021'
},
'isbn': {
'mongo': 'mongodb://root:Bantus123@dds-8vb74337eab84d641.mongodb.zhangbei.rds.aliyuncs.com:3717,dds-8vb74337eab84d642.mongodb.zhangbei.rds.aliyuncs.com:3717/admin?replicaSet=mgset-504694158',
'gmmongo': 'mongodb://dbop:zyzGm2021@dds-8vb9964bb4cc7f241.mongodb.zhangbei.rds.aliyuncs.com:3717,dds-8vb9964bb4cc7f242.mongodb.zhangbei.rds.aliyuncs.com:3717/zyzgm?replicaSet=mgset-507933150',
'redis': 'r-8vbekkbb3z8ru2ckuj.redis.zhangbei.rds.aliyuncs.com',
'redispw': 'zyz_isbn_2021'
},
'monitor': {
'mongo': 'mongodb://dbop:zyzMon2021@dds-8vb7474e31ba7ed41.mongodb.zhangbei.rds.aliyuncs.com:3717,dds-8vb7474e31ba7ed42.mongodb.zhangbei.rds.aliyuncs.com:3717/zyz?replicaSet=mgset-505529944',
'gmmongo': 'mongodb://dbop:zyzGm2021@dds-8vb9964bb4cc7f241.mongodb.zhangbei.rds.aliyuncs.com:3717,dds-8vb9964bb4cc7f242.mongodb.zhangbei.rds.aliyuncs.com:3717/zyzgm?replicaSet=mgset-507933150',
'redis': 'r-8vb130185rp2ir3lqn.redis.zhangbei.rds.aliyuncs.com',
'redispw': 'zyz_monitor_2021'
},
'distribute': {
'mongo': 'mongodb://dbop:zyzDev2021@dds-8vb5c74ba4263da41.mongodb.zhangbei.rds.aliyuncs.com:3717,dds-8vb5c74ba4263da42.mongodb.zhangbei.rds.aliyuncs.com:3717/zyz?replicaSet=mgset-506991391',
'gmmongo': 'mongodb://dbop:zyzGm2021@dds-8vb9964bb4cc7f241.mongodb.zhangbei.rds.aliyuncs.com:3717,dds-8vb9964bb4cc7f242.mongodb.zhangbei.rds.aliyuncs.com:3717/zyzgm?replicaSet=mgset-507933150',
'redis': 'r-8vb418l8kkju9sis8k.redis.zhangbei.rds.aliyuncs.com',
'redispw': 'zyz_dev_2021'
}

5
game-server/config/master.ts
View File

@@ -9,6 +9,11 @@ module.exports = {
'host': '127.0.0.1',
'port': 3005
},
'stable': {
'id': 'master-server-1',
'host': '127.0.0.1',
'port': 3005
},
'alpha': {
'id': 'master-server-1',
'host': '172.26.145.159',

4
game-server/config/serverName.ts
View File

@@ -3,8 +3,8 @@ module.exports = {
'type': 'development',
'name': '本地服'
},
'production': {
'type': 'production',
'stable': {
'type': 'stable',
'name': '正式服'
},
'alpha': {

5
game-server/config/servers.ts
View File

@@ -3,7 +3,8 @@ module.exports = {
'connector': [
{ 'id': 'connector-server-1', 'port': 4050, 'clientHost': '127.0.0.1', 'host': '127.0.0.1', 'clientPort': 3050, 'frontend': true },
{ 'id': 'connector-server-2', 'port': 4051, 'clientHost': '127.0.0.1', 'host': '127.0.0.1', 'clientPort': 3051, 'frontend': true },
{ 'id': 'connector-server-3', 'port': 4052, 'clientHost': '127.0.0.1', 'host': '127.0.0.1', 'clientPort': 3052, 'frontend': true }
{ 'id': 'connector-server-3', 'port': 4052, 'clientHost': '127.0.0.1', 'host': '127.0.0.1', 'clientPort': 3052, 'frontend': true },
{ 'id': 'connector-server-gm', 'port': 4099, 'clientHost': '127.0.0.1', 'host': '127.0.0.1', 'clientPort': 3099, 'frontend': true }
],
'chat': [
{ 'id': 'chat-server-1', 'host': '127.0.0.1', 'port': 6050, "args": " --inspect=9237" }
@@ -49,7 +50,7 @@ module.exports = {
{ 'id': 'order-server-1', 'host': '127.0.0.1', 'port': 6060, "args": " --inspect=9242" },
]
},
'production': {
'stable': {
'connector': [
{ 'id': 'connector-server-1', 'port': 4050, 'clientHost': 'zyz_web.trgame.cn', 'host': '127.0.0.1', 'clientPort': 3050, 'frontend': true },
{ 'id': 'connector-server-2', 'port': 4051, 'clientHost': 'zyz_web.trgame.cn', 'host': '127.0.0.1', 'clientPort': 3051, 'frontend': true },

14
gm-server/app.ts
View File

@@ -2,6 +2,7 @@ import 'reflect-metadata'
import * as mongoose from 'mongoose';
import { Application, IBoot } from 'egg';
import { loadGmDb } from '@db/index';
import { connectRedis } from '@pubUtils/redis';
export default class FooBoot implements IBoot {
private readonly app: Application;
@@ -16,6 +17,12 @@ export default class FooBoot implements IBoot {
// this is the last chance to modify the config.
await this.connectDB(this.app)
await this.connectGMDB(this.app);
await this.connectRedis(this.app);
this.app.config.realEnv = this.app.config.env;
if(this.app.config.env == 'local') {
this.app.config.realEnv = 'development';
}
}
configDidLoad() {
@@ -73,6 +80,13 @@ export default class FooBoot implements IBoot {
}
}
public async connectRedis(app: Application) {
const { url, pw } = app.config.redis
if (url) {
const redisClient = connectRedis(url, pw);
app.context.redisClient = redisClient;
}
}
//#endregion
}

55
gm-server/app/controller/activity.ts
View File

@@ -4,11 +4,16 @@ export default class ActivityController extends Controller {
public async getActivityList() {
const { ctx } = this;
const { page, pageSize, type, groupId, current, activityId, sortField, sortOrder } = ctx.request.body;
const { page, pageSize, type, form: {groupId, current, activityId}, sortField, sortOrder } = ctx.request.body;
ctx.body = await ctx.service.activity.getActivityList(page, pageSize, sortField, sortOrder, type, groupId, current, activityId);
return
}
public async getAllActivities() {
const { ctx } = this;
ctx.body = await ctx.service.activity.getAllActivities();
}
public async updateActivity() {
const { ctx } = this;
const { activityId, groupId, beginTime, endTime, type, data } = ctx.request.body;
@@ -28,18 +33,28 @@ export default class ActivityController extends Controller {
public async getActivityGroupList() {
const { ctx } = this;
const { page, pageSize, serverId, current, groupId } = ctx.request.body;
const { page, pageSize, form: { serverId, current, groupId} } = ctx.request.body;
ctx.body = await ctx.service.activity.getActivityGroupList(page, pageSize, serverId, current, groupId);
return
}
public async getAllActivityGroups() {
const { ctx } = this;
ctx.body = await ctx.service.activity.getAllActivityGroups();
}
public async getActivityGroupTypeList() {
const { ctx } = this;
const { page, pageSize, sortField, sortOrder, groupType, groupTypeName } = ctx.request.body;
const { page, pageSize, sortField, sortOrder, form: {groupType, groupTypeName} } = ctx.request.body;
ctx.body = await ctx.service.activity.getActivityGroupTypeList(page, pageSize, sortField, sortOrder, groupType, groupTypeName);
return
}
public async getAllActivityGroupTypes() {
const { ctx } = this;
ctx.body = await ctx.service.activity.getAllActivityGroupTypes();
}
public async updateActivityGroupType() {
const { ctx } = this;
const { groupType, groupTypeName, activityTypes } = ctx.request.body;
@@ -54,13 +69,6 @@ export default class ActivityController extends Controller {
return
}
public async saveGroupTypeToActivityGroup() {
const { ctx } = this;
const { groupId, groupType } = ctx.request.body;
ctx.body = await ctx.service.activity.saveGroupTypeToActivityGroup(groupId, groupType);
return
}
public async getGroupDataById() {
const { ctx } = this;
const { groupId } = ctx.request.body;
@@ -68,31 +76,10 @@ export default class ActivityController extends Controller {
return
}
public async updateActivityGroupName() {
public async updateActivityGroup() {
const { ctx } = this;
const { groupId, groupName } = ctx.request.body;
ctx.body = await ctx.service.activity.updateActivityGroupName(groupId, groupName);
return
}
public async saveActivitiesToGroup() {
const { ctx } = this;
const { groupId, activities } = ctx.request.body;
ctx.body = await ctx.service.activity.saveActivitiesToGroup(groupId, activities);
return
}
public async saveSingleActivityToGroup() {
const { ctx } = this;
const { groupId, index, activityId } = ctx.request.body;
ctx.body = await ctx.service.activity.saveSingleActivityToGroup(groupId, index, activityId);
return
}
public async saveGroupToServer() {
const { ctx } = this;
const { groupId, serverIds } = ctx.request.body;
ctx.body = await ctx.service.activity.saveGroupToServer(groupId, serverIds);
const { groupId, groupName, activities, serverIds, type } = ctx.request.body;
ctx.body = await ctx.service.activity.updateActivityGroup(groupId, groupName, activities, serverIds, type);
return
}

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

@@ -1,86 +1,141 @@
import { Controller } from 'egg';
import { STATUS } from '@consts';
export default class GameController extends Controller {
public async getServerEnv() {
const { ctx } = this;
ctx.body = await ctx.service.game.getServerEnv();
return
}
// 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);
public async getRegions() {
const { ctx } = this;
ctx.body = await ctx.service.game.getRegions();
return
}
public async getMaintenanceList() {
public async getRegionStategy() {
const { ctx } = this;
const {page, pageSize, sortField, sortOrder, form} = ctx.request.body;
const { id } = ctx.request.body;
ctx.body = await ctx.service.game.getMaintenanceList(page, pageSize, sortField, sortOrder, form);
ctx.body = await ctx.service.game.getRegionStategy(id);
return
}
public async updateMaintenance() {
public async getWhiteList() {
const { ctx } = this;
const {values, marquee, notice, mail} = ctx.request.body;
const { id } = 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
}
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});
ctx.body = await ctx.service.game.getWhiteList(id);
return
}
public async getServerStategyList() {
public async updateWhiteList() {
const { ctx } = this;
const { page, pageSize, sortField, sortOrder, form } = ctx.request.body;
const { id, code, type, content } = ctx.request.body;
ctx.body = await ctx.service.game.getServerStategyList(page, pageSize, sortField, sortOrder, form);
ctx.body = await ctx.service.game.updateWhiteList(id, code, type, content);
return
}
public async updateServerStategy() {
public async deleteWhiteList() {
const { ctx } = this;
const { values } = ctx.request.body;
const { id, code } = ctx.request.body;
ctx.body = await ctx.service.game.updateServerStategy(values);
ctx.body = await ctx.service.game.deleteWhiteList(id, code);
return
}
public async createNewServer() {
public async getServers() {
const { ctx } = this;
const { name, openTime, serverType, stategyId } = ctx.request.body;
ctx.body = await ctx.service.game.createNewServer(name, openTime, serverType, stategyId);
ctx.body = await ctx.service.game.getServers();
return
}
public async updateServer() {
public async stopServerRegister() {
const { ctx } = this;
const { id, name, groupName, serverStatus, } = ctx.request.body;
ctx.body = await ctx.service.game.updateServer(id, name, groupName, serverStatus);
const { id } = ctx.request.body;
ctx.body = await ctx.service.game.stopServerRegister(id);
return
}
public async switchServerStatus() {
const { ctx } = this;
const { id, status } = ctx.request.body;
ctx.body = await ctx.service.game.switchServerStatus(id, status);
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
// }
// 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;
// ctx.body = await ctx.service.game.getServerStategyList(page, pageSize, sortField, sortOrder, form);
// return
// }
// public async updateServerStategy() {
// const { ctx } = this;
// const { values } = ctx.request.body;
// ctx.body = await ctx.service.game.updateServerStategy(values);
// return
// }
// public async createNewServer() {
// const { ctx } = this;
// const { name, openTime, serverType, stategyId } = ctx.request.body;
// ctx.body = await ctx.service.game.createNewServer(name, openTime, serverType, stategyId);
// return
// }
// public async updateServer() {
// const { ctx } = this;
// const { id, name, groupName, serverStatus, } = ctx.request.body;
// ctx.body = await ctx.service.game.updateServer(id, name, groupName, serverStatus);
// return
// }
public async getNoticeList() {
const { ctx } = this;
const { page, pageSize, sortField, sortOrder, form } = ctx.request.body;
@@ -153,4 +208,10 @@ export default class GameController extends Controller {
ctx.body = await ctx.service.game.getDicTaskType();
return
}
public async getServerName() {
const { ctx } = this;
ctx.body = await ctx.service.game.getServerName();
return
}
}

57
gm-server/app/controller/mail.ts
View File

@@ -1,7 +1,33 @@
import { Controller } from 'egg';
import { STATUS } from '@consts';
import { GM_MAIL_TYPE, STATUS } from '@consts';
import { UpdateMailParams } from '@domain/backEndField/params';
export default class MailController extends Controller {
public async getSingleMail() {
const { ctx } = this;
const { page, pageSize, sortField, sortOrder, form } = ctx.request.body;
ctx.body = await ctx.service.mail.getGMMailList(page, pageSize, sortField, sortOrder, {...form, mailType: GM_MAIL_TYPE.SINGLE, hasGoods: true });
return
}
public async getSingleMailTxt() {
const { ctx } = this;
const { page, pageSize, sortField, sortOrder, form } = ctx.request.body;
ctx.body = await ctx.service.mail.getGMMailList(page, pageSize, sortField, sortOrder, {...form, mailType: GM_MAIL_TYPE.SINGLE, hasGoods: false });
return
}
public async getServerMail() {
const { ctx } = this;
const { page, pageSize, sortField, sortOrder, form } = ctx.request.body;
ctx.body = await ctx.service.mail.getGMMailList(page, pageSize, sortField, sortOrder, {...form, mailType: GM_MAIL_TYPE.SERVER, hasGoods: true });
return
}
public async getServerMailTxt() {
const { ctx } = this;
const { page, pageSize, sortField, sortOrder, form } = ctx.request.body;
ctx.body = await ctx.service.mail.getGMMailList(page, pageSize, sortField, sortOrder, {...form, mailType: GM_MAIL_TYPE.SERVER, hasGoods: false });
return
}
public async getGMMailList() {
const { ctx } = this;
const { page, pageSize, sortField, sortOrder, form } = ctx.request.body;
@@ -9,22 +35,29 @@ export default class MailController extends Controller {
return
}
public async findRoleByIdOrName() {
const { ctx } = this;
const { serverId, roleId, roleName }: { serverId: number, roleId?: string, roleName?: string } = ctx.request.body;
if(!serverId || (!roleId && !roleName)) return ctx.body = ctx.service.utils.resResult(STATUS.WRONG_PARMS);
ctx.body = await ctx.service.mail.findRoleByIdOrName(serverId, roleId, roleName);
return
}
public async updateGMMail() {
const { ctx } = this;
const { _id, content, sendName, sendTime, endTime, useTempTime, continueHour, goods } = ctx.request.body;
if(!_id) return ctx.body = ctx.service.utils.resResult(STATUS.WRONG_PARMS);
if(useTempTime) {
if(!sendTime || !endTime) return ctx.body = ctx.service.utils.resResult(STATUS.WRONG_PARMS);
const msg = ctx.request.body;
let params = new UpdateMailParams(msg);
let check = params.checkParams();
if(!check) return ctx.body = ctx.service.utils.resResult(STATUS.WRONG_PARMS);
if(msg._id == 'new') {
ctx.body = await ctx.service.mail.createGmMail(params);
} else if(msg._id) {
ctx.body = await ctx.service.mail.updateGMMail(msg._id, params);
} else {
if(!continueHour) return ctx.body = ctx.service.utils.resResult(STATUS.WRONG_PARMS);
}
let updateGoods = [];
try{
updateGoods = JSON.parse(goods);
} catch(e) {
return ctx.body = ctx.service.utils.resResult(STATUS.WRONG_PARMS);
}
ctx.body = await ctx.service.mail.updateGMMail(_id, content, sendName, useTempTime, sendTime, endTime, continueHour, updateGoods);
return
}

24
gm-server/app/controller/upload.ts
View File

@@ -14,9 +14,9 @@ const hotUpdateAddr = `/root/${folderName}`;
const publishPath = '/root/hot_update_backup';
import {exec} from 'child_process'
import { reloadResources } from '@pubUtils/data';
import { decodeArrayStr } from '@pubUtils/util';
const sendToWormhole = require('stream-wormhole');
export default class UploadController extends Controller {
private deleteFolder (path) {
@@ -148,7 +148,7 @@ export default class UploadController extends Controller {
// 解压上传文件的stream
var unzipExtractor = unzip.Extract({ path: dirPath });
unzipExtractor.on('close', function() {
resolve();
resolve(null);
});
unzipExtractor.on('close', function(e) {
@@ -170,26 +170,30 @@ export default class UploadController extends Controller {
public async uploadJson() {
const { ctx } = this;
const parts = ctx.multipart({ });
const files = [];
try {
let stream;
let writeStream;
while ((stream = await parts()) != null) {
console.log('******', stream);
const filename = stream.filename;
let filenameWithoutEx = filename?filename.split('.')[0]:'';
if (stream.mimeType == 'application/json') {
if (filenameWithoutEx.match(/^\d{1,}$/)) {
let target1 = path.join(this.config.baseDir, this.warjsonFolder, filename);
let target2 = path.join(this.config.baseDir, this.distWarjsonFolder, filename);
const writeStream = fs.createWriteStream(target1);
writeStream = fs.createWriteStream(target1);
await pump(stream, writeStream);
fs.copyFileSync(target1, target2);
files.push(filename);
} else {
let target1 = path.join(this.config.baseDir, this.jsonFolder, filename);
let target2 = path.join(this.config.baseDir, this.distJsonFolder, filename);
const writeStream = fs.createWriteStream(target1);
writeStream = fs.createWriteStream(target1);
await pump(stream, writeStream);
fs.copyFileSync(target1, target2);
files.push(filename);
@@ -197,13 +201,23 @@ export default class UploadController extends Controller {
} else if (stream.mimeType == 'application/octet-stream') {
let target1 = path.join(this.config.baseDir, this.tsFolder, 'dicParam.js');
let target2 = path.join(this.config.baseDir, this.distTsFolder, filename);
const writeStream = fs.createWriteStream(target1);
writeStream = fs.createWriteStream(target1);
await pump(stream, writeStream);
fs.copyFileSync(target1, target2);
files.push(filename);
}
let envs = decodeArrayStr(ctx.request.headers.env||'', ',');
if(envs.length > 0) { // 转发
for(let env of envs) {
if(env == ctx.app.config.realEnv) continue;
await ctx.service.utils.transmit(env, ctx.request.url, writeStream);
}
}
sendToWormhole(stream);
}
}catch(e) {
console.error(e);
}

116
gm-server/app/controller/users.ts
View File

@@ -1,12 +1,11 @@
import { Controller } from 'egg';
import { STATUS } from '@consts';
export default class UserController extends Controller {
public async getuserlist() {
const { ctx } = this;
const { field, value } = ctx.request.body;
ctx.body = await ctx.service.users.getuserlist(field, value);
const { page, pageSize, sortField, sortOrder, form } = ctx.request.body;
ctx.body = await ctx.service.users.getuserlist(page, pageSize, sortField, sortOrder, form);
}
public async createRole() {
@@ -15,11 +14,11 @@ export default class UserController extends Controller {
ctx.body = await ctx.service.users.createRole(uid, serverId, roleName);
}
public async addAuth() {
const { ctx } = this;
const { uid, auth } = ctx.request.body;
ctx.body = await ctx.service.users.addAuth(uid, auth);
}
// public async addAuth() {
// const { ctx } = this;
// const { uid, auth } = ctx.request.body;
// ctx.body = await ctx.service.users.addAuth(uid, auth);
// }
public async fixSms() {
const { ctx } = this;
@@ -35,32 +34,14 @@ export default class UserController extends Controller {
public async getrolelist() {
const { ctx } = this;
const { field, value } = ctx.request.body;
ctx.body = await ctx.service.users.getrolelist(field, value);
const { page, pageSize, sortField, sortOrder, form } = ctx.request.body;
ctx.body = await ctx.service.users.getrolelist(page, pageSize, sortField, sortOrder, form);
}
public async createRoleData() {
public async setWar() {
const { ctx } = this;
const { hid, hlv, eid, ecount, itemid, itemcount, count, lv, skinid, selectedRowKeys: uids, optType, ehid, war } = ctx.request.body;
if(optType == 'hero') {
ctx.body = await ctx.service.users.createHero(uids, hid, hlv);
} else if(optType == 'equip') {
ctx.body = await ctx.service.users.createEquip(uids, eid, ecount, ehid);
} else if (optType == 'item') {
ctx.body = await ctx.service.users.createItem(uids, itemid, itemcount);
} else if (optType == 'gold') {
ctx.body = await ctx.service.users.addGold(uids, count);
} else if (optType == 'coin') {
ctx.body = await ctx.service.users.addCoin(uids, count);
} else if (optType == 'lv') {
ctx.body = await ctx.service.users.levelUp(uids, lv);
} else if (optType == 'skin') {
ctx.body = await ctx.service.users.addSkin(uids, skinid);
} else if (optType == 'war') {
ctx.body = await ctx.service.users.setWarRecord(uids, war);
} else {
ctx.body = ctx.service.utils.resResult(STATUS.WRONG_PARMS);
}
const { roleId, warId } = ctx.request.body;
ctx.body = await ctx.service.users.setWarRecord(roleId, warId);
}
@@ -72,14 +53,14 @@ export default class UserController extends Controller {
public async getHeroList() {
const { ctx } = this;
const { field, value } = ctx.request.body;
ctx.body = await ctx.service.users.getHeroList(field, value);
const { page, pageSize, sortField, sortOrder, form } = ctx.request.body;
ctx.body = await ctx.service.users.getHeroList(page, pageSize, sortField, sortOrder, form);
}
public async deleteHero() {
const { ctx } = this;
const { selectedRowKeys: roleIdAndHids } = ctx.request.body;
ctx.body = await ctx.service.users.deleteHero(roleIdAndHids);
const { roleId, hid } = ctx.request.body;
ctx.body = await ctx.service.users.deleteHero(roleId, parseInt(hid));
}
public async setHeroLv() {
@@ -114,14 +95,26 @@ export default class UserController extends Controller {
public async getEquipList() {
const { ctx } = this;
const { field, value } = ctx.request.body;
ctx.body = await ctx.service.users.getEquipList(field, value);
const { page, pageSize, sortField, sortOrder, form } = ctx.request.body;
ctx.body = await ctx.service.users.getEquipList(page, pageSize, sortField, sortOrder, form);
}
public async getItemList() {
const { ctx } = this;
const { field, value } = ctx.request.body;
ctx.body = await ctx.service.users.getItemList(field, value);
const { page, pageSize, sortField, sortOrder, form } = ctx.request.body;
ctx.body = await ctx.service.users.getItemList(page, pageSize, sortField, sortOrder, form);
}
public async getGuildList() {
const { ctx } = this;
const { page, pageSize, sortField, sortOrder, form } = ctx.request.body;
ctx.body = await ctx.service.users.getGuildList(page, pageSize, sortField, sortOrder, form);
}
public async getMembersByGuildCode() {
const { ctx } = this;
const { code } = ctx.request.body;
ctx.body = await ctx.service.users.getMembersByGuildCode(code);
}
public async deleteEquip() {
@@ -148,37 +141,40 @@ export default class UserController extends Controller {
ctx.body = await ctx.service.users.getGiftCodeList(page, pageSize, sortField, sortOrder, form);
}
public async createAndGenerateGift() {
const { ctx } = this;
const params = ctx.request.body;
ctx.body = await ctx.service.users.createAndGenerateGift(params, params.generateCnt);
}
public async updateGiftCode() {
const { ctx } = this;
const { id, values } = ctx.request.body;
ctx.body = await ctx.service.users.updateGiftCode(id, values);
const params = ctx.request.body;
ctx.body = await ctx.service.users.updateGiftCode(params.id, params.values);
}
public async generateGiftCode() {
const { ctx } = this;
const { id, generateType, code, generateNum, codeLen } = ctx.request.body;
if(generateType == 1) {
if(!generateNum) {
ctx.body = ctx.service.utils.resResult(STATUS.WRONG_PARMS);
return
}
} else if (generateType == 2) {
if(!code) {
ctx.body = ctx.service.utils.resResult(STATUS.WRONG_PARMS);
return
}
} else {
ctx.body = ctx.service.utils.resResult(STATUS.WRONG_PARMS);
return
}
ctx.body = await ctx.service.users.generateGiftCode(id, generateType, code, generateNum, codeLen);
const params = ctx.request.body;
ctx.body = await ctx.service.users.generateGiftCode(params.id, params.count);
}
public async getGiftCodeDetails() {
public async cancelGiftCode() {
const { ctx } = this;
const params = ctx.request.body;
ctx.body = await ctx.service.users.cancelGiftCode(params.id, !!params.isEnable);
}
public async getGiftCodeDetailList() {
const { ctx } = this;
const { page, pageSize, sortField, sortOrder, form } = ctx.request.body;
ctx.body = await ctx.service.users.getGiftCodeDetailList(page, pageSize, sortField, sortOrder, form);
}
public async getGiftCodeDetailFile() {
const { ctx } = this;
const { id } = ctx.params;
ctx.body = await ctx.service.users.getGiftCodeDetails(parseInt(id));
ctx.body = await ctx.service.users.getGiftCodeDetailFile(parseInt(id));
return
}
}

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

@@ -8,7 +8,7 @@ export default (app: Application) => {
router.post('/api/login/account', controller.login.login);
router.post('/api/login/changeMyPass', tokenParser, controller.login.changeMyPass);
router.post('/api/get_route', controller.login.getMenu);
router.get('/api/currentUser', tokenParser, controller.login.currentUser);
router.post('/api/currentUser', tokenParser, controller.login.currentUser);
router.post('/api/upload/hotupdate', tokenParser, controller.upload.upload);
router.post('/api/upload/uploadjson', tokenParser, controller.upload.uploadJson);
router.post('/api/upload/reloadresource', tokenParser, controller.upload.reloadResource);
@@ -25,48 +25,60 @@ export default (app: Application) => {
router.post('/api/users/getuserlist',tokenParser, controller.users.getuserlist);
router.post('/api/users/createrole',tokenParser, controller.users.createRole);
router.post('/api/users/addauth', tokenParser, controller.users.addAuth);
// router.post('/api/users/createrole',tokenParser, controller.users.createRole);
// router.post('/api/users/addauth', tokenParser, controller.users.addAuth);
router.post('/api/users/fixsms', tokenParser, controller.users.fixSms);
router.post('/api/users/deleterole',tokenParser, controller.users.deleteRole);
router.post('/api/users/getrolelist',tokenParser, controller.users.getrolelist);
router.post('/api/users/createroledata',tokenParser, controller.users.createRoleData);
router.post('/api/users/deleterole',tokenParser, controller.users.deleteRole);
router.post('/api/users/setwar', controller.users.setWar);
router.post('/api/users/getpvpdefense',tokenParser, controller.users.getPveDefense);
router.post('/api/users/getherolist',tokenParser, controller.users.getHeroList);
router.post('/api/users/deletehero', tokenParser, controller.users.deleteHero);
router.post('/api/users/setherolv', tokenParser, controller.users.setHeroLv);
router.post('/api/users/setheroparam', controller.users.setHeroParam);
router.post('/api/users/setherojob', controller.users.setHeroJob);
// router.post('/api/users/setherolv', tokenParser, controller.users.setHeroLv);
// router.post('/api/users/setheroparam', controller.users.setHeroParam);
// router.post('/api/users/setherojob', controller.users.setHeroJob);
// router.post('/api/users/saveherotodefense',tokenParser, controller.users.saveHeroToDefense);
// router.post('/api/users/removeherofromdefense',tokenParser, controller.users.removeHeroFromDefense);
router.post('/api/users/getequiplist', tokenParser, controller.users.getEquipList);
router.post('/api/users/getitemlist', tokenParser, controller.users.getItemList);
router.post('/api/users/getguildlist', controller.users.getGuildList);
router.post('/api/users/getmembersbyguildcode', controller.users.getMembersByGuildCode);
router.post('/api/users/deleteequip', tokenParser, controller.users.deleteEquip);
router.post('/api/users/deleteitem', tokenParser, controller.users.deleteItem);
router.post('/api/users/setitemcount', tokenParser, controller.users.setItemCount);
router.post('/api/users/getgiftcodelist', controller.users.getGiftCodeList);
router.post('/api/users/createandgenerategift', controller.users.createAndGenerateGift)
router.post('/api/users/updategiftcode', controller.users.updateGiftCode);
router.post('/api/users/generategiftcode', controller.users.generateGiftCode);
// router.post('/api/users/delgiftCode', controller.users.delGiftCode);
router.get('/api/users/getgiftcodedetails/:id/:filename', controller.users.getGiftCodeDetails);
router.post('/api/users/cancelgiftCode', controller.users.cancelGiftCode);
router.post('/api/users/getgiftcodedetaillist', controller.users.getGiftCodeDetailList);
router.get('/api/users/getgiftcodedetailfile/:id/:filename', controller.users.getGiftCodeDetailFile);
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/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);
router.post('/api/game/getwhitelist', controller.game.getWhiteList);
router.post('/api/game/updatewhitelist', controller.game.updateWhiteList);
router.post('/api/game/deletewhitelist', controller.game.deleteWhiteList);
router.post('/api/game/stopserverregister', controller.game.stopServerRegister);
router.post('/api/game/swicthserverstatus', controller.game.switchServerStatus);
router.post('/api/game/getmaintenancelist', controller.game.getMaintenanceList);
router.post('/api/game/updatemaintenance', controller.game.updateMaintenance);
// 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);
router.post('/api/game/getdicactivitytype', tokenParser, controller.game.getDicActivityType);
router.post('/api/game/getdictasktype', tokenParser, controller.game.getDicTaskType);
router.post('/api/game/getservername', controller.game.getServerName)
router.post('/api/game/getserverstategylist', controller.game.getServerStategyList);
router.post('/api/game/updateserverstategy', controller.game.updateServerStategy);
router.post('/api/game/createnewserver', controller.game.createNewServer);
router.post('/api/game/updateserver', controller.game.updateServer);
// router.post('/api/game/getserverstategylist', controller.game.getServerStategyList);
// router.post('/api/game/updateserverstategy', controller.game.updateServerStategy);
// router.post('/api/game/createnewserver', controller.game.createNewServer);
// router.post('/api/game/updateserver', controller.game.updateServer);
router.post('/api/game/getnoticelist', controller.game.getNoticeList);
router.post('/api/game/updatenotice', controller.game.updateNotice);
router.post('/api/game/delnotice', controller.game.delNotice);
@@ -75,26 +87,36 @@ export default (app: Application) => {
router.post('/api/game/getaccuse', controller.game.getAccuse);
router.post('/api/activity/getactivitylist', tokenParser, controller.activity.getActivityList);
router.post('/api/activity/getallactivities', controller.activity.getAllActivities);
router.post('/api/activity/updateactivity', tokenParser, controller.activity.updateActivity);
router.post('/api/activity/deleteactivity', tokenParser, controller.activity.deleteActivity);
router.post('/api/activity/getactivitygrouplist', tokenParser, controller.activity.getActivityGroupList);
router.post('/api/activity/updateactivitygroupname', controller.activity.updateActivityGroupName);
// router.post('/api/activity/saveactivitiestogroup', tokenParser, controller.activity.saveActivitiesToGroup);
// router.post('/api/activity/savesingleactivitytogroup', controller.activity.saveSingleActivityToGroup);
// router.post('/api/activity/savegrouptoserver', tokenParser, controller.activity.saveGroupToServer);
router.post('/api/activity/getallactivitygroups', controller.activity.getAllActivityGroups);
router.post('/api/activity/updateactivitygroup', controller.activity.updateActivityGroup);
router.post('/api/activity/creategroup', tokenParser, controller.activity.createGroup);
router.post('/api/activity/deletegroup', tokenParser, controller.activity.deleteGroup);
router.post('/api/activity/getactivitygrouptypelist', controller.activity.getActivityGroupTypeList);
router.post('/api/activity/getallactivitygrouptypes', controller.activity.getAllActivityGroupTypes);
router.post('/api/activity/saveactivitygrouptypelist', controller.activity.updateActivityGroupType);
router.post('/api/activity/deleteactivitygrouptype', controller.activity.deleteActivityGroupType);
router.post('/api/activity/saveactivitygrouptype', controller.activity.saveGroupTypeToActivityGroup);
router.post('/api/activity/getgroupdatabyid', controller.activity.getGroupDataById);
// router.post('/api/activity/getgroupdatabyid', controller.activity.getGroupDataById);
router.post('/api/activity/getactivitytaskpoint', controller.activity.getActivityTaskPoint);
router.post('/api/activity/createtasktoactivity', controller.activity.createTaskToActivity);
router.post('/api/activity/updateactivitytaskpoint', controller.activity.updateActivityTaskPoint);
router.post('/api/activity/delactivitytaskpoint', controller.activity.delActivityTaskPoint);
router.post('/api/mail/getgmmaillist', controller.mail.getGMMailList);
router.post('/api/mail/updategmmail', controller.mail.updateGMMail);
router.post('/api/mail/getcreatesinglemail', controller.mail.getSingleMail);
router.post('/api/mail/getcreatesinglemailtxt', controller.mail.getSingleMailTxt);
router.post('/api/mail/getcreateservermail', controller.mail.getServerMail);
router.post('/api/mail/getcreateservermailtxt', controller.mail.getServerMailTxt);
router.post('/api/mail/getviewsinglemail', controller.mail.getSingleMail);
router.post('/api/mail/getviewsinglemailtxt', controller.mail.getSingleMailTxt);
router.post('/api/mail/getviewservermail', controller.mail.getServerMail);
router.post('/api/mail/getviewservermailtxt', controller.mail.getServerMailTxt);
router.post('/api/mail/findrolebyidorname', controller.mail.findRoleByIdOrName);
router.post('/api/mail/updatesinglemail', controller.mail.updateGMMail);
router.post('/api/mail/updatesinglemailtxt', controller.mail.updateGMMail);
router.post('/api/mail/updateservermail', controller.mail.updateGMMail);
router.post('/api/mail/updateservermailtxt', controller.mail.updateGMMail);
router.post('/api/mail/getgmmailrecords', controller.mail.getGMMailRecords);
};

127
gm-server/app/service/Activity.ts
View File

@@ -25,30 +25,50 @@ export default class Activity extends Service {
return ctx.service.utils.resResult(STATUS.SUCCESS, {
list: list.map(cur => {
return {
...cur, beginTime: cur.beginTime.getTime(), endTime: cur.endTime.getTime()
...cur, beginTime: cur.beginTime.getTime(), endTime: cur.endTime.getTime(), env: ctx.app.config.realEnv
}
}), total
});
}
public async getAllActivities() {
const { ctx } = this;
let list = await ActivityModel.findAllActivities();
return ctx.service.utils.resResult(STATUS.SUCCESS, { list });
}
public async getAllActivityGroups() {
const { ctx } = this;
let list = await ActivityGroupModel.findAllActivityGroups();
return ctx.service.utils.resResult(STATUS.SUCCESS, { list });
}
public async getAllActivityGroupTypes() {
const { ctx } = this;
// console.log('***', page, pageSize, type, serverId, current, activityId)
const list = await ActivityGroupTypeModel.findAllActivityGroupTypes();
return ctx.service.utils.resResult(STATUS.SUCCESS, {
list
});
}
public async checkActivityEditable(activityId: number) {
let now = new Date();
let activity = await ActivityModel.findActivity(activityId);
if(this.app.config.env == 'production') {
if(!activity || (activity.beginTime < now && activity.endTime > now)) {
if(!activity || (activity.beginTime < now && activity.endTime > now)) {
if(activity.type == ACTIVITY_TYPE.SIGN_IN || activity.type == ACTIVITY_TYPE.SIGN_IN_VIP) {
// 签到活动的不显示期内也可以编辑
let signInObj = new SignInData(activity, 0);
if(signInObj.beginTime < now.getTime() && signInObj.endTime > now.getTime() ) {
return this.ctx.service.utils.resResult(STATUS.GM_CAN_NOT_EDIT_ACT);
}
} else {
if(activity.type == ACTIVITY_TYPE.SIGN_IN || activity.type == ACTIVITY_TYPE.SIGN_IN_VIP) {
// 签到活动的不显示期内也可以编辑
let signInObj = new SignInData(activity, 0);
if(signInObj.beginTime < now.getTime() && signInObj.endTime > now.getTime() ) {
return this.ctx.service.utils.resResult(STATUS.GM_CAN_NOT_EDIT_ACT);
}
} else {
return this.ctx.service.utils.resResult(STATUS.GM_CAN_NOT_EDIT_ACT);
}
}
return 0
}
@@ -101,7 +121,7 @@ export default class Activity extends Service {
})
} catch (e) {
return ctx.service.utils.resResult(STATUS.INTERNAL_ERR, null, e.stack);
return ctx.service.utils.resResult(STATUS.INTERNAL_ERR, null, (<Error>e).stack);
}
}
@@ -126,7 +146,7 @@ export default class Activity extends Service {
return ctx.service.utils.resResult(STATUS.SUCCESS, {
list: list.map(cur => {
return {
...cur, beginTime: cur.beginTime?.getTime(), endTime: cur.endTime?.getTime()
...cur, beginTime: cur.beginTime?.getTime(), endTime: cur.endTime?.getTime(), env: ctx.app.config.realEnv
}
}), total
});
@@ -135,74 +155,20 @@ export default class Activity extends Service {
/**
* 更新活动组
*/
public async updateActivityGroupName(groupId: number, groupName: string) {
public async updateActivityGroup(groupId: number, groupName: string, activityIds: number[], serverIds: number[], type: number) {
const { ctx } = this;
try {
await ActivityGroupModel.updateGroup(groupId, {groupName}, ctx.user?.uid);
} catch(e) {
return ctx.service.utils.resResult(STATUS.INTERNAL_ERR, null, e.stack);
}
return ctx.service.utils.resResult(STATUS.SUCCESS)
}
let groupTypeObj = await ActivityGroupTypeModel.findByGroupType(type);
if(!groupTypeObj) return ctx.service.utils.resResult(STATUS.GM_ACTIVITY_GROUP_TYPE_NOT_FOUND);
await ActivityGroupModel.updateGroup(groupId, {groupName, type}, ctx.user?.uid);
/**
* 选择活动组内的活动
*/
public async saveActivitiesToGroup(groupId: number, activityIds: number[]) {
const { ctx } = this;
try {
// 更新activities
let checkResult = await this.checkActivityGroupType(groupId, activityIds, ctx);
if(checkResult) return checkResult;
await ActivityGroupModel.setActivitiesToGroupData(groupId, activityIds, ctx.user?.uid);
} catch(e) {
return ctx.service.utils.resResult(STATUS.INTERNAL_ERR, null, e.stack);
}
return ctx.service.utils.resResult(STATUS.SUCCESS)
}
/**
* 选择活动组内的活动
*/
public async saveSingleActivityToGroup(groupId: number, index: number, activityId: number) {
console.log(groupId, index, activityId);
const { ctx } = this;
try {
let checkResult = await this.checkActivityGroupType(groupId, [activityId], ctx);
if(checkResult) return checkResult;
let activityGroup = await ActivityGroupModel.findGroupData(groupId);
if(!activityGroup) return ctx.service.utils.resResult(STATUS.GM_ACTIVITY_GROUP_NOT_FOUND);
let activity = await ActivityModel.findActivity(activityId);
if(!activity) return ctx.service.utils.resResult(STATUS.ACTIVITY_MISSING);
if(activityGroup.type != 0) {
let activityGroupType = await ActivityGroupTypeModel.findByGroupType(activityGroup.type);
if(!activityGroupType) return ctx.service.utils.resResult(STATUS.GM_ACTIVITY_GROUP_TYPE_NOT_FOUND);
let dic = activityGroupType.activityTypes;
let curDic = dic.find(cur => cur.index == index);
console.log(dic, curDic)
if(curDic.activityType != activity.type) return ctx.service.utils.resResult(STATUS.GM_ACTIVITY_NOT_FIT_GROUP_TYPE)
}
let activityIds = activityGroup.activities||[];
if(activityIds.indexOf(activityId) == -1) activityIds.push(activityId);
await ActivityGroupModel.setActivitiesToGroupData(groupId, activityIds, ctx.user?.uid);
} catch(e) {
return ctx.service.utils.resResult(STATUS.INTERNAL_ERR, null, e.stack);
}
return ctx.service.utils.resResult(STATUS.SUCCESS)
}
/**
* 将活动组添加入服务器内
*/
public async saveGroupToServer(groupId: number, serverIds: number[]) {
const { ctx } = this;
try {
// 封信servers
await ServerlistModel.pullByGroupId(groupId);
let servers = await ServerlistModel.findServerByIds(serverIds);
for(let server of servers) {
@@ -214,8 +180,9 @@ export default class Activity extends Service {
await ServerlistModel.updateActivityGroup(server._id, pushArr, pullArr);
}
await ActivityGroupModel.updateServerData(groupId, serverIds, ctx.user?.uid);
} catch(e) {
return ctx.service.utils.resResult(STATUS.INTERNAL_ERR, null, e.stack);
return ctx.service.utils.resResult(STATUS.INTERNAL_ERR, null, (<Error>e).stack);
}
return ctx.service.utils.resResult(STATUS.SUCCESS)
}
@@ -228,7 +195,7 @@ export default class Activity extends Service {
try {
await ActivityGroupModel.createGroup(ctx.user?.uid);
} catch(e) {
return ctx.service.utils.resResult(STATUS.INTERNAL_ERR, null, e.stack);
return ctx.service.utils.resResult(STATUS.INTERNAL_ERR, null, (<Error>e).stack);
}
return ctx.service.utils.resResult(STATUS.SUCCESS)
}
@@ -244,7 +211,7 @@ export default class Activity extends Service {
await ActivityGroupModel.deleteGroup(groupId);
}
} catch(e) {
return ctx.service.utils.resResult(STATUS.INTERNAL_ERR, null, e.stack);
return ctx.service.utils.resResult(STATUS.INTERNAL_ERR, null, (<Error>e).stack);
}
return ctx.service.utils.resResult(STATUS.SUCCESS)
}
@@ -279,14 +246,6 @@ export default class Activity extends Service {
await ActivityGroupTypeModel.deleteActivityGroupType(groupType);
return ctx.service.utils.resResult(STATUS.SUCCESS);
}
public async saveGroupTypeToActivityGroup(groupId: number, groupType: number) {
const { ctx } = this;
let groupTypeObj = await ActivityGroupTypeModel.findByGroupType(groupType);
if(!groupTypeObj) return ctx.service.utils.resResult(STATUS.GM_ACTIVITY_GROUP_TYPE_NOT_FOUND);
await ActivityGroupModel.updateGroup(groupId, { type: groupType }, ctx.user?.uid);
return ctx.service.utils.resResult(STATUS.SUCCESS);
}
public async getGroupDataById(groupId: number) {
const { ctx } = this;

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

@@ -1,18 +1,22 @@
import { Service } from 'egg';
import { STATUS, MARQUEE_TYPE } from '@consts';
import { GameModel } from '@db/Game';
import { ServerlistModel, ServerlistUpdate } from '@db/Serverlist';
import { STATUS } from '@consts';
// import { GameModel } from '@db/Game';
import { ServerlistModel } from '@db/Serverlist';
import { gameData } from '@pubUtils/data';
import { DicHero } from '@pubUtils/dictionary/DicHero';
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, NoticeType } from '@db/Notice';
import { MarqueeModel, MarqueeParam, MarqueeType } from '@db/Marquee';
import { MaintenanceModel, MaintenanceTypeParam } from '@db/Maintenance';
import { GMMailTypeParam, GMMailModel, GMMailType } from '@db/GMMail';
import { NoticeModel, NoticeTypeParam } from '@db/Notice';
import Marquee, { MarqueeModel } from '@db/Marquee';
import { AccuseRecModel } from '@db/AccuseRec';
import { RegionModel } from '@db/Region';
import { ActivityGroupModel } from '@db/ActivityGroup';
import { nowSeconds } from '@pubUtils/timeUtil';
import { WhiteListModel } from '@db/RegionWhiteList';
import { RoleModel } from '@db/Role';
import { SearchMarqueeParam } from '@domain/backEndField/search';
import { DicServerName } from '@pubUtils/dictionary/DicServerName';
/**
* Test Service
@@ -22,141 +26,210 @@ export default class Game extends Service {
/**
* 获取正式服，测试服，开发服等环境
*/
public async getServerEnv() {
const { ctx, app } = this;
const list = await GameModel.getServerEnvList();
// 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,
env: app.config.env
});
}
// return ctx.service.utils.resResult(STATUS.SUCCESS, {
// list
// });
// }
/**
* 获取正式服，测试服，开发服等环境
*/
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 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
// });
// }
public async getRegions() {
const { ctx } = this;
const list = await RegionModel.getAllRegion();
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 } = {}) {
public async getServers() {
const { ctx } = this;
const list = await ServerlistModel.findByCondition(page, pageSize, sortField, sortOrder, form);
const total = await ServerlistModel.countByCondition( form )
const list = await ServerlistModel.getAllServerList();
console.log('******', list)
return ctx.service.utils.resResult(STATUS.SUCCESS, {
list, total
list
});
}
public async getMaintenanceList(page: number, pageSize: number, sortField: string, sortOrder: string, form: { isOpen?: boolean } = {}) {
public async stopServerRegister(id: number) {
const { ctx } = this;
const server = await ServerlistModel.updateByServerId(id, { stopRegisterTime: nowSeconds() - 1 });
if(!server) return ctx.service.utils.resResult(STATUS.WRONG_PARMS);
return ctx.service.utils.resResult(STATUS.SUCCESS);
}
public async switchServerStatus(id: number, status: number) {
const { ctx } = this;
const server = await ServerlistModel.updateByServerId(id, { serverStatus: status });
if(!server) return ctx.service.utils.resResult(STATUS.WRONG_PARMS);
return ctx.service.utils.resResult(STATUS.SUCCESS);
}
public async getRegionStategy(id: number) {
const { ctx } = this;
let region = await RegionModel.findRegionById(id);
if(!region) return ctx.service.utils.resResult(STATUS.WRONG_PARMS);
let activityGroups = await ActivityGroupModel.findAllActivityGroup();
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
region, activityGroups
});
}
public async updateMaintenance(values: MaintenanceTypeParam, marquee: MarqueeParam, notice: NoticeTypeParam, mail: GMMailTypeParam) {
public async getWhiteList(id: number) {
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: false }, ctx.user?.uid);
let mailResult = await GMMailModel.addMail({ ...mail, useTempTime: true }, ctx.user?.uid);
await MaintenanceModel.createData(values, marqueeResult, noticeResult, mailResult);
let region = await RegionModel.findRegionById(id);
if(!region) return ctx.service.utils.resResult(STATUS.WRONG_PARMS);
let whitelist = await WhiteListModel.findByRegionId(id);
return ctx.service.utils.resResult(STATUS.SUCCESS, {
whitelist
});
}
public async updateWhiteList(id: number, code: string, type: number, content: string) {
const { ctx } = this;
let region = await RegionModel.findRegionById(id);
if(!region) return ctx.service.utils.resResult(STATUS.WRONG_PARMS);
if(type == 1) {
let whitelist = await WhiteListModel.updateWhiteList(code, { type, regionId: region.id, env: region.env, ip: content });
return ctx.service.utils.resResult(STATUS.SUCCESS, { whitelist });
} else if(type == 2) {
let role = await RoleModel.findByRoleId(content, 'roleId userInfo serverId roleName');
let whitelist = await WhiteListModel.updateWhiteList(code, { type, regionId: region.id, env: region.env, uid: role.userInfo.uid, serverId: role.serverId, roleId: role.roleId, roleName: role.roleName });
return ctx.service.utils.resResult(STATUS.SUCCESS, { whitelist });
} 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.WRONG_PARMS);
}
return ctx.service.utils.resResult(STATUS.SUCCESS);
}
public async getServerStategyList(page: number, pageSize: number, sortField: string, sortOrder: string, form: { id?: number, name?: string }) {
public async deleteWhiteList(id: number, code: string) {
const { ctx } = this;
const list = await ServerStategyModel.findByCondition(page, pageSize, sortField, sortOrder, form);
const total = await ServerStategyModel.countByCondition( form )
return ctx.service.utils.resResult(STATUS.SUCCESS, {
list, total
});
let region = await RegionModel.findRegionById(id);
if(!region) return ctx.service.utils.resResult(STATUS.WRONG_PARMS);
let whitelist = await WhiteListModel.deleteWhiteList(code);
return ctx.service.utils.resResult(STATUS.SUCCESS, { whitelist });
}
public async updateServerStategy(values: ServerStategyTypeParam & {id: string|number}) {
const { ctx } = this;
// public async getMaintenanceList(page: number, pageSize: number, sortField: string, sortOrder: string, form: { isOpen?: boolean } = {}) {
// const { ctx } = this;
try {
await ServerStategyModel.updateServerStategy(values, ctx.user?.uid);
// 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, 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);
} catch(e) {
return ctx.service.utils.resResult(STATUS.INTERNAL_ERR, null, e.stack);
}
return ctx.service.utils.resResult(STATUS.SUCCESS);
}
// 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: false }, ctx.user?.uid);
// // let mailResult = await GMMailModel.addMail(mail, ctx.user?.uid);
// await MaintenanceModel.createData(values, marqueeResult, noticeResult, null);
// } 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 createNewServer(name: string, openTime: number, serverType: string, stategyId: number ) {
const { ctx } = this;
// public async getServerStategyList(page: number, pageSize: number, sortField: string, sortOrder: string, form: { id?: number, name?: string }) {
// const { ctx } = this;
try {
let stategy = await ServerStategyModel.findBySId(stategyId);
if(!stategy) return ctx.service.utils.resResult(STATUS.GM_STATEGY_NOT_FOUND);
// const list = await ServerStategyModel.findByCondition(page, pageSize, sortField, sortOrder, form);
// const total = await ServerStategyModel.countByCondition( form )
// return ctx.service.utils.resResult(STATUS.SUCCESS, {
// list, total
// });
// }
await ServerlistModel.newServer({ name, openTime: new Date(openTime), serverType }, stategy, ctx.user?.uid);
// public async updateServerStategy(values: ServerStategyTypeParam & {id: string|number}) {
// const { ctx } = this;
// try {
// await ServerStategyModel.updateServerStategy(values, ctx.user?.uid);
} catch(e) {
return ctx.service.utils.resResult(STATUS.INTERNAL_ERR, null, e.stack);
}
return ctx.service.utils.resResult(STATUS.SUCCESS);
}
// } catch(e) {
// return ctx.service.utils.resResult(STATUS.INTERNAL_ERR, null, (<Error>e).stack);
// }
// return ctx.service.utils.resResult(STATUS.SUCCESS);
// }
public async updateServer(id: number, name: string, groupName: string, serverStatus: number ) {
const { ctx } = this;
// public async createNewServer(name: string, openTime: number, serverType: string, stategyId: number ) {
// const { ctx } = this;
try {
let server = await ServerlistModel.findByServerId(id);
if(!server) return ctx.service.utils.resResult(STATUS.GM_SERVER_NOT_FOUND);
// try {
// let stategy = await ServerStategyModel.findBySId(stategyId);
// if(!stategy) return ctx.service.utils.resResult(STATUS.GM_STATEGY_NOT_FOUND);
if(server.groupName != groupName) {
await ServerlistModel.updateGroupName(server.groupId, groupName);
}
let update: ServerlistUpdate = {};
if(name) update['name'] = name;
if(groupName) update['groupName'] = groupName;
if(serverStatus) update['serverStatus'] = serverStatus;
await ServerlistModel.updateByServerId(id, update);
// await ServerlistModel.newServer({ name, openTime: new Date(openTime), serverType }, stategy, ctx.user?.uid);
} catch(e) {
return ctx.service.utils.resResult(STATUS.INTERNAL_ERR, null, e.stack);
}
return ctx.service.utils.resResult(STATUS.SUCCESS);
}
// } catch(e) {
// return ctx.service.utils.resResult(STATUS.INTERNAL_ERR, null, (<Error>e).stack);
// }
// return ctx.service.utils.resResult(STATUS.SUCCESS);
// }
// public async updateServer(id: number, name: string, groupName: string, serverStatus: number ) {
// const { ctx } = this;
// try {
// let server = await ServerlistModel.findByServerId(id);
// if(!server) return ctx.service.utils.resResult(STATUS.GM_SERVER_NOT_FOUND);
// if(server.groupName != groupName) {
// await ServerlistModel.updateGroupName(server.groupId, groupName);
// }
// let update: ServerlistUpdate = {};
// if(name) update['name'] = name;
// if(groupName) update['groupName'] = groupName;
// if(serverStatus) update['serverStatus'] = serverStatus;
// await ServerlistModel.updateByServerId(id, update);
// } catch(e) {
// return ctx.service.utils.resResult(STATUS.INTERNAL_ERR, null, (<Error>e).stack);
// }
// return ctx.service.utils.resResult(STATUS.SUCCESS);
// }
public async getDicHero() {
let list: DicHero[] = [];
@@ -206,21 +279,29 @@ export default class Game extends Service {
})
}
public async getNoticeList(page: number, pageSize: number, sortField: string, sortOrder: string, form: { type?: number, content?: string }) {
public async getServerName() {
let list: DicServerName[] = [];
for(let [_, serverName] of gameData.serverNames) {
list.push(serverName);
}
return this.ctx.service.utils.resResult(STATUS.SUCCESS, {
list
})
}
public async getNoticeList(page: number, pageSize: number, sortField: string, sortOrder: string, form: { content?: string }) {
const { ctx } = this;
const list = await NoticeModel.findByCondition(page, pageSize, sortField, sortOrder, form);
const total = await NoticeModel.countByCondition( form )
return ctx.service.utils.resResult(STATUS.SUCCESS, {
list: list.map(cur => {
return { ...cur, startTime: cur.startTime.getTime(), endTime: cur.endTime.getTime(), showEndTime: cur.showEndTime.getTime(), showStartTime: cur.showStartTime.getTime()}
return { ...cur, showEndTime: cur.showEndTime.getTime(), showStartTime: cur.showStartTime.getTime(), env: this.app.config.realEnv }
}), total
});
}
public async updateNotice(id: string|number, params: NoticeTypeParam) {
const { ctx } = this;
if(params.startTime) params.startTime = new Date(params.startTime);
if(params.endTime) params.endTime = new Date(params.endTime);
if(params.showStartTime) params.showStartTime = new Date(params.showStartTime);
if(params.showEndTime) params.showEndTime = new Date(params.showEndTime);
let result = await NoticeModel.updateNotice(id, params);
@@ -236,21 +317,20 @@ export default class Game extends Service {
}
public async getMarqueeList(page: number, pageSize: number, sortField: string, sortOrder: string, form: { type?: number, current?: boolean, content?: string }) {
public async getMarqueeList(page: number, pageSize: number, sortField: string, sortOrder: string, form: SearchMarqueeParam) {
const { ctx } = this;
const list = await MarqueeModel.findByCondition(page, pageSize, sortField, sortOrder, form);
const total = await MarqueeModel.countByCondition( form )
return ctx.service.utils.resResult(STATUS.SUCCESS, {
list: list.map(cur => {
return { ...cur, startTime: cur.startTime?.getTime()||0, endTime: cur.endTime?.getTime()||0 }
}), total
list, total
});
}
public async updateMarquee(code: string, params: MarqueeParam) {
public async updateMarquee(code: string, values: any) {
const { ctx } = this;
if(params.startTime) params.startTime = new Date(params.startTime);
if(params.endTime) params.endTime = new Date(params.endTime);
let params = new Marquee();
params.setByForm(values);
let result;
if(code == 'new') {
result = await MarqueeModel.createData(params);
@@ -258,7 +338,7 @@ export default class Game extends Service {
result = await MarqueeModel.updateData(code, params);
}
if(!result) return ctx.service.utils.resResult(STATUS.WRONG_PARMS);
return ctx.service.utils.resResult(STATUS.SUCCESS);
return ctx.service.utils.resResult(STATUS.SUCCESS, { code: result.code });
}
public async getAccuse(page: number, pageSize: number, sortField: string, sortOrder: string, form: {}) {

36
gm-server/app/service/Mail.ts
View File

@@ -1,13 +1,15 @@
import { Service } from 'egg';
import { GMMailModel } from '@db/GMMail';
import { GMMailModel, } from '@db/GMMail';
import { STATUS } from '@consts';
import { GMMailRecordModel } from '@db/GMMailRecord';
import { RewardInter } from '@pubUtils/interface';
import { SearchMailParam } from '@domain/backEndField/search';
import { UpdateMailParams } from '@domain/backEndField/params';
import { RoleModel, RoleType } from '@db/Role';
export default class Mail extends Service {
public async getGMMailList(page: number, pageSize: number, sortField: string, sortOrder: string, form: {}) {
public async getGMMailList(page: number, pageSize: number, sortField: string, sortOrder: string, form: SearchMailParam) {
const { ctx } = this;
const list = await GMMailModel.findByCondition(page, pageSize, sortField, sortOrder, form);
const total = await GMMailModel.countByCondition( form )
@@ -16,13 +18,29 @@ export default class Mail extends Service {
});
}
public async updateGMMail(_id: string, content: string, sendName: string, useTempTime: boolean, sendTime: number, endTime: number, continueHour: number, goods: RewardInter[]) {
const { ctx } = this;
if(_id == 'new') {
await GMMailModel.addMail({ content, sendName, useTempTime, sendTime, endTime, continueHour, goods });
} else {
await GMMailModel.updateMailById(_id, { content, sendName, useTempTime, sendTime, endTime, continueHour, goods });
public async findRoleByIdOrName(serverId: number, roleId: string, roleName: string) {
let role: RoleType;
if(roleId) {
role = await RoleModel.findByRoleId(roleId);
}
if(roleName) {
role = await RoleModel.findByRoleName(roleName);
}
if(!role || role.serverId != serverId) return this.ctx.service.utils.resResult(STATUS.WRONG_PARMS);
return this.ctx.service.utils.resResult(STATUS.SUCCESS, { env: this.ctx.app.config.realEnv, serverId, roleId: role.roleId, roleName: role.roleName })
}
public async createGmMail(params: UpdateMailParams) {
const { ctx } = this;
await GMMailModel.addMail(params, ctx.user?.uid);
return ctx.service.utils.resResult(STATUS.SUCCESS);
}
public async updateGMMail(_id: string, params: UpdateMailParams) {
const { ctx } = this;
await GMMailModel.updateMailById(_id, params, ctx.user?.uid);
return ctx.service.utils.resResult(STATUS.SUCCESS);
}

14
gm-server/app/service/Utils.ts
View File

@@ -72,4 +72,18 @@ export default class Utils extends Service {
log.error(`${message}`);
}
}
public async transmit(env: string, route: string, stream: any) {
const { ctx } = this;
console.log('****transmit', stream);
const result = await ctx.curl(`http://127.0.0.1:7002${route}`, {
method: 'POST',
files: stream,
headers: {
token: ctx.request.headers.token
}
});
console.log(env, result)
}
}

402
gm-server/app/service/users.ts
View File

@@ -6,7 +6,7 @@ import { PvpDefenseModel } from '@db/PvpDefense';
import { Service } from 'egg';
import Counter from '@db/Counter';
import { STATUS, HERO_SYSTEM_TYPE } from '@consts';
import { STATUS, HERO_SYSTEM_TYPE, ITEM_CHANGE_REASON, REDIS_KEY, WAR_TYPE } from '@consts';
import { ITID, COUNTER } from '@consts';
import { ItemModel } from '@db/Item';
import { gameData, getExpByLv } from '@pubUtils/data';
@@ -21,6 +21,14 @@ import { CreateHeroes, deletRole } from '@pubUtils/roleUtil';
import { RScriptRecordModel } from '@db/RScriptRecord';
import { DicWar } from '@pubUtils/dictionary/DicWar';
import { SkinModel } from '@db/Skin';
import { SearchEquipParam, SearchHeroParam, SearchUserParam, SearchGiftCodeParam, SearchGiftCodeDetailParam, SearchItemParam, SearchGuildParam } from '@domain/backEndField/search';
import { CreateGiftCode, UpdateGiftCode } from '@domain/backEndField/params';
import { isNumber } from 'util';
import { GuildModel } from '@db/Guild';
import { RedisClient } from 'redis';
import { UserGuildModel } from '@db/UserGuild';
import { TowerRecordModel } from '@db/TowerRecord';
import { HangUpRecordModel } from '@db/HangUpRecord';
// import { resResult } from '@pubUtils/util';
@@ -34,49 +42,22 @@ export default class GMUsers extends Service {
/**
* 根据类型等搜索玩家
*/
public async getuserlist(field: string = 'all', value: string = '') {
public async getuserlist(page: number, pageSize: number, sortField: string, sortOrder: string, form: SearchUserParam) {
const { ctx } = this;
let arr = new Array(), flag = 0;
if (value == '') field = 'all';
let valueArr = value.split(',');
for (let i of valueArr) {
if (field == 'uid') {
let d = parseInt(i);
if (isNaN(d)) {
flag = 1; break;
} else {
arr.push(d);
}
} else if (field == 'username' || field == 'tel') {
arr.push(i);
} else if (field == 'all') {
break;
} else {
flag = 1; break;
}
const users = await UserModel.findByCondition(page, pageSize, sortField, sortOrder, form);
const total = await UserModel.countByCondition( form )
let list = [];
for (let user of users) {
let role = await RoleModel.findAllByUid(user.uid);
let sms = await smsModel.findByTel(user.tel);
list.push({ ...user, role, isFixed: sms ? sms.isFixed : false, code: sms ? sms.code : "", env: ctx.app.config.realEnv });
}
if (flag) {
return ctx.service.utils.resResult(STATUS.WRONG_PARMS);
}
return ctx.service.utils.resResult(STATUS.SUCCESS, { list, total })
let users = await UserModel.findUserByField(field, valueArr);
if (users) {
let list = new Array();
for (let user of users) {
let role = await RoleModel.findAllByUid(user.uid);
let sms = await smsModel.findByTel(user.tel);
list.push({ ...user, role, isFixed: sms ? sms.isFixed : false, code: sms ? sms.code : "" });
}
return ctx.service.utils.resResult(STATUS.SUCCESS, { list })
} else {
console.error('userlist not found');
return ctx.service.utils.resResult(STATUS.INTERNAL_ERR);
}
}
public async createRole(uid: number, serverId: number, roleName: string) {
@@ -95,18 +76,18 @@ export default class GMUsers extends Service {
}
}
public async addAuth(uid: number, auth: number) {
console.log('enter Auth addAuth');
const ctx = this.ctx;
// public async addAuth(uid: number, auth: number) {
// console.log('enter Auth addAuth');
// const ctx = this.ctx;
const user = await UserModel.addAuth(uid, auth);
if (user) {
return ctx.service.utils.resResult(STATUS.SUCCESS);
} else {
console.error('add auth error');
return ctx.service.utils.resResult(STATUS.INTERNAL_ERR);
}
}
// const user = await UserModel.addAuth(uid, auth);
// if (user) {
// return ctx.service.utils.resResult(STATUS.SUCCESS);
// } else {
// console.error('add auth error');
// return ctx.service.utils.resResult(STATUS.INTERNAL_ERR);
// }
// }
public checkTelNo(telNo: string) {
if (!isString(telNo)) {
@@ -142,65 +123,30 @@ export default class GMUsers extends Service {
return ctx.service.utils.resResult(STATUS.SUCCESS);
}
/**
* 根据类型等搜索玩家
*/
public async getrolelist(field: string = 'all', value: string = '') {
public async getrolelist(page: number, pageSize: number, sortField: string, sortOrder: string, form: SearchUserParam) {
const { ctx } = this;
let arr = new Array(), flag = 0;
let valueArr = value.split(',');
if (value == '') field = 'all';
for (let i of valueArr) {
if (field == 'uid') {
let d = parseInt(i);
if (isNaN(d)) {
flag = 1; break;
} else {
arr.push(d);
}
field = 'userInfo.uid';
} else if (field == 'roleName') {
arr.push(i);
} else if (field == 'tel') {
arr.push(i);
field = 'userInfo.tel';
} else if (field == 'all') {
break;
} else {
flag = 1; break;
}
const roles = await RoleModel.findByCondition(page, pageSize, sortField, sortOrder, form);
const total = await RoleModel.countByCondition( form )
let list = [];
for (let role of roles) {
let heroCount = await HeroModel.count({ roleId: role.roleId }).lean();
let equipCount = await EquipModel.count({ roleId: role.roleId }).lean();
let itemCount = await ItemModel.count({ roleId: role.roleId }).lean();
let { roleId, roleName, serverId, lv, vLv, gold, coin, ce, blockType = 0, blockReason = '' } = role;
let { uid, tel } = role.userInfo;
list.push({
key: roleId, roleId, roleName, serverId, lv, vLv, uid, tel, heroCount, equipCount, itemCount, gold, coin, ce, blockType, blockReason,
env: ctx.app.config.realEnv
});
}
if (flag) {
return ctx.service.utils.resResult(STATUS.WRONG_PARMS);
}
let roles = await RoleModel.findRoleByField(field, valueArr);
if (roles) {
let result = new Array();
for (let role of roles) {
let heroCount = await HeroModel.count({ roleId: role.roleId }).lean();
let equipCount = await EquipModel.count({ roleId: role.roleId }).lean();
let itemCount = await ItemModel.count({ roleId: role.roleId }).lean();
let defense = await PvpDefenseModel.findByRoleId(role.roleId);
let { roleId, roleName, serverId, lv, vLv, gold, coin } = role;
let { uid, tel } = role.userInfo;
result.push({
key: roleId, roleId, roleName, serverId, lv, vLv, uid, tel, heroCount, equipCount, itemCount, gold, coin,
hasDefense: defense ? '是' : '否', defCe: 0
});
}
return ctx.service.utils.resResult(STATUS.SUCCESS, { list: result });
} else {
console.error('role list not found');
return ctx.service.utils.resResult(STATUS.INTERNAL_ERR);
}
return ctx.service.utils.resResult(STATUS.SUCCESS, { list, total })
}
public async createHero(uids: Array<string>, _hid: string, _hlv: string) {
@@ -259,7 +205,7 @@ export default class GMUsers extends Service {
weapons.push({ id: eid, hid: ehid });
}
}
await addEquips(roleId, role.roleName, weapons);
await addEquips(roleId, role.roleName, weapons, ITEM_CHANGE_REASON.DEBUG);
} else {
flag = 1, msg = '未找到角色' + roleId;
}
@@ -300,7 +246,7 @@ export default class GMUsers extends Service {
for (let roleId of uids) {
let role = await RoleModel.findByRoleId(roleId);
if (role) {
await addBags(roleId, role.roleName, datas);
await addBags(roleId, role.roleName, datas, ITEM_CHANGE_REASON.DEBUG);
} else {
flag = 1, msg = '未找到角色' + roleId;
}
@@ -451,51 +397,42 @@ export default class GMUsers extends Service {
/**
* 根据类型等搜索玩家
*/
public async getHeroList(field: string, value: (string | number)) {
public async getHeroList(page: number, pageSize: number, sortField: string, sortOrder: string, form: SearchHeroParam) {
const { ctx } = this;
let heroes = await HeroModel.findByField(field, value);
const heroes = await HeroModel.findByCondition(page, pageSize, sortField, sortOrder, form);
const total = await HeroModel.countByCondition( form )
if (heroes) {
let roleMap = new Map<string, CeAttrDataRole[]>();
for(let { roleId } of heroes) {
if(!roleMap.has(roleId)) {
let role = await RoleModel.findByRoleId(roleId, 'attr');
roleMap.set(roleId, role.attr);
}
let roleMap = new Map<string, CeAttrDataRole[]>();
for(let { roleId } of heroes) {
if(!roleMap.has(roleId)) {
let role = await RoleModel.findByRoleId(roleId, 'attr');
roleMap.set(roleId, role.attr);
}
let list = heroes.map(cur => {
let cal = new AttributeCal();
cal.setByDbData(roleMap.get(cur.roleId), cur.attr);
return {...cur, calculatedAttr: cal.getReduceAttributesToArr()}
})
return ctx.service.utils.resResult(STATUS.SUCCESS, { list });
} else {
console.error('role list not found');
return ctx.service.utils.resResult(STATUS.INTERNAL_ERR);
}
let list = heroes.map(cur => {
let cal = new AttributeCal();
cal.setByDbData(roleMap.get(cur.roleId), cur.attr);
return {...cur, calculatedAttr: cal.getReduceAttributesToArr(), env: ctx.app.config.realEnv}
})
return ctx.service.utils.resResult(STATUS.SUCCESS, { list, total })
}
public async deleteHero(roleIdAndHids: string[]) {
public async deleteHero(roleId: string, hid: number) {
console.log('enter Auth deleteRole');
const ctx = this.ctx;
for (let roleIdAndHid of roleIdAndHids) {
let [roleId, hidStr] = roleIdAndHid.split('|');
if (isNaN(parseInt(hidStr))) return ctx.service.utils.resResult(STATUS.WRONG_PARMS);
let hid = parseInt(hidStr);
let hero = await HeroModel.findByHidAndRole(hid, roleId);
if (!hero) return ctx.service.utils.resResult(STATUS.WRONG_PARMS);
let hero = await HeroModel.findByHidAndRole(hid, roleId);
if (!hero) continue;
await HeroModel.deleteHero(roleId, hid);
await SkinModel.deleteByHero(roleId, hid);
let role = await RoleModel.findByRoleId(roleId);
await calculatetopLineup(role, hid, 0, null);
await PvpDefenseModel.deleteHero(roleId, hid);
await RoleModel.updateRoleInfo(roleId, { topLineup: role.topLineup, topLineupCe: role.topLineupCe, ce: role.ce - hero.ce });
}
await HeroModel.deleteHero(roleId, hid);
await SkinModel.deleteByHero(roleId, hid);
let role = await RoleModel.findByRoleId(roleId);
await calculatetopLineup(role, hid, 0, null);
await PvpDefenseModel.deleteHero(roleId, hid);
await RoleModel.updateRoleInfo(roleId, { topLineup: role.topLineup, topLineupCe: role.topLineupCe, ce: role.ce - hero.ce });
return ctx.service.utils.resResult(STATUS.SUCCESS);
}
@@ -602,7 +539,7 @@ export default class GMUsers extends Service {
return ctx.service.utils.resResult(STATUS.SUCCESS);
} catch (e) {
console.error(e.stack)
console.error((<Error>e).stack)
}
}
@@ -625,7 +562,7 @@ export default class GMUsers extends Service {
return ctx.service.utils.resResult(STATUS.SUCCESS);
} catch (e) {
console.error(e.stack)
console.error((<Error>e).stack)
}
}
@@ -649,109 +586,130 @@ export default class GMUsers extends Service {
return ctx.service.utils.resResult(STATUS.SUCCESS);
} catch (e) {
console.error(e.stack)
console.error((<Error>e).stack)
}
}
/**
* 根据类型等搜索装备
*/
public async getEquipList(field: string, value: (string | number)) {
public async getEquipList(page: number, pageSize: number, sortField: string, sortOrder: string, form: SearchEquipParam) {
const { ctx } = this;
let equips = await EquipModel.findByField(field, value);
const equips = await EquipModel.findByCondition(page, pageSize, sortField, sortOrder, form);
const total = await EquipModel.countByCondition( form )
if (equips) {
let list = equips.map(cur => {
return {...cur, env: ctx.app.config.realEnv}
})
return ctx.service.utils.resResult(STATUS.SUCCESS, { list: equips });
} else {
console.error('role list not found');
return ctx.service.utils.resResult(STATUS.INTERNAL_ERR);
}
return ctx.service.utils.resResult(STATUS.SUCCESS, { list, total })
}
/**
* 根据类型等搜索道具
*/
public async getItemList(field: string, value: (string | number)) {
public async getItemList(page: number, pageSize: number, sortField: string, sortOrder: string, form: SearchItemParam) {
const { ctx } = this;
let items = await ItemModel.findByField(field, value);
const items = await ItemModel.findByCondition(page, pageSize, sortField, sortOrder, form);
const total = await ItemModel.countByCondition( form )
if (items) {
let list = items.map(cur => {
return {...cur, env: ctx.app.config.realEnv}
})
return ctx.service.utils.resResult(STATUS.SUCCESS, { list: items });
} else {
console.error('role list not found');
return ctx.service.utils.resResult(STATUS.INTERNAL_ERR);
}
return ctx.service.utils.resResult(STATUS.SUCCESS, { list, total })
}
public async getGiftCodeList(page: number, pageSize: number, sortField: string, sortOrder: string, form: { name?: string, current?: boolean, } = {}) {
public async getGuildList(page: number, pageSize: number, sortField: string, sortOrder: string, form: SearchGuildParam) {
const { ctx } = this;
let redisClient: RedisClient = ctx.app.context.redisClient;
const guilds = await GuildModel.findByCondition(page, pageSize, sortField, sortOrder, form);
const total = await GuildModel.countByCondition( form )
let list = [];
for(let guild of guilds) {
let rank = await redisClient.zrevrankAsync(`${REDIS_KEY.GUILD_LV_RANK}:${guild.serverId}`, guild.code);
list.push({ ...guild, rank: rank == undefined? '未上榜': rank + 1, env: ctx.app.config.realEnv })
}
return ctx.service.utils.resResult(STATUS.SUCCESS, { list, total })
}
public async getMembersByGuildCode(code: string) {
const { ctx } = this;
let guild = await GuildModel.findByCode(code);
if(!guild) return ctx.service.utils.resResult(STATUS.GUILD_NOT_FOUND);
let userGuilds = await UserGuildModel.getListByGuild(code);
let list = userGuilds.map(userGuild => ({ ...userGuild, env: ctx.app.config.realEnv }))
return ctx.service.utils.resResult(STATUS.SUCCESS, { list })
}
public async getGiftCodeList(page: number, pageSize: number, sortField: string, sortOrder: string, form: SearchGiftCodeParam = {}) {
const { ctx } = this;
const list = await GiftCodeModel.findByCondition(page, pageSize, sortField, sortOrder, form);
const total = await GiftCodeModel.countByCondition( form )
return ctx.service.utils.resResult(STATUS.SUCCESS, {
list: list.map(cur => {
return { ...cur, beginTime: cur.beginTime.getTime(), endTime: cur.endTime.getTime() }
}), total
list: list.map(cur => ({...cur, env: ctx.app.config.realEnv })), total
});
}
public async updateGiftCode(id: string|number, params: any) {
public async createAndGenerateGift(obj: any, count: number = 1) {
const { ctx } = this;
if(params.beginTime) params.beginTime = new Date(params.beginTime);
if(params.endTime) params.endTime = new Date(params.endTime);
let params = new CreateGiftCode(obj);
if(!isNumber(count) || !params.checkParams()) return ctx.service.utils.resResult(STATUS.WRONG_PARMS);
let giftCode = await GiftCodeModel.createData(params);
await GiftCodeDetailModel.generateMany(giftCode, count, ctx.user?.uid);
return ctx.service.utils.resResult(STATUS.SUCCESS, giftCode);
}
public async updateGiftCode(id: number, obj: any) {
const { ctx } = this;
let params = new UpdateGiftCode(id, obj);
if(!params.checkParams()) return ctx.service.utils.resResult(STATUS.WRONG_PARMS);
try{
params.goods = JSON.parse(params.goods);
} catch(e) {
console.error(e);
return ctx.body = ctx.service.utils.resResult(STATUS.WRONG_PARMS);
}
const result = await GiftCodeModel.updateData(id, params, ctx.user?.uid);
if(!result) return ctx.service.utils.resResult(STATUS.INTERNAL_ERR);
return ctx.service.utils.resResult(STATUS.SUCCESS);
}
public async generateGiftCode(id: number, generateType: 1|2, code: string, generateNum: number, codeLen: number = 8) {
public async generateGiftCode(id: number, count: number) {
const { ctx } = this;
let giftCode = await GiftCodeModel.findData(id);
if(!giftCode) return ctx.service.utils.resResult(STATUS.WRONG_PARMS);
if(!isNumber(id) || !isNumber(count)) return ctx.service.utils.resResult(STATUS.WRONG_PARMS);
let length = 0, isLimit = false, count = 0, generateCode = '';
if(generateType == 1) {
let generateResult = await GiftCodeDetailModel.generateMany(giftCode, generateNum, codeLen, ctx.user?.uid);
length = generateResult.length;
isLimit = true;
count = 1;
} else if (generateType == 2) {
let generateResult = await GiftCodeDetailModel.generateOne(giftCode, code, ctx.user?.uid);
length = generateResult.length;
generateCode = code;
}
if(length <= 0) return ctx.service.utils.resResult(STATUS.INTERNAL_ERR);
giftCode = await GiftCodeModel.updateData(id, { generateCnt: giftCode.generateCnt + length, generateType, isLimit, count, generateCode }, ctx.user?.uid);
return ctx.service.utils.resResult(STATUS.SUCCESS, { giftCode })
let giftCode = await GiftCodeModel.findByGiftId(id);
if(!giftCode) return ctx.service.utils.resResult(STATUS.DB_DATA_NOT_FOUND);
await GiftCodeDetailModel.generateMany(giftCode, count, ctx.user?.uid);
return ctx.service.utils.resResult(STATUS.SUCCESS, giftCode);
}
public async getGiftCodeDetails(id: number) {
public async cancelGiftCode(id: number, isEnable: boolean) {
const { ctx } = this;
if(!isNumber(id)) return ctx.service.utils.resResult(STATUS.WRONG_PARMS);
let giftCode = await GiftCodeModel.findByGiftId(id);
if(!giftCode) return ctx.service.utils.resResult(STATUS.DB_DATA_NOT_FOUND);
await GiftCodeModel.updateData(id, { isEnable }, ctx.user?.uid);
return ctx.service.utils.resResult(STATUS.SUCCESS, giftCode);
}
public async getGiftCodeDetailFile(id: number) {
const { ctx } = this;
let giftCode = await GiftCodeModel.findData(id);
let giftCode = await GiftCodeModel.findByGiftId(id);
if(!giftCode) return ctx.service.utils.resResult(STATUS.WRONG_PARMS);
let { generateCnt } = giftCode;
let limit = 1000;
let n = Math.ceil(generateCnt / limit);
let codes: string[] = [];
for(let i = 0; i < n; i++) {
let giftCodeDetails = await GiftCodeDetailModel.findByGiftCode(giftCode);
for(let {code} of giftCodeDetails) {
codes.push(code);
}
let giftCodeDetails = await GiftCodeDetailModel.findAllCodeByGiftId(giftCode.id, giftCode.generateCnt);
for(let {code} of giftCodeDetails) {
codes.push(code);
}
console.log(id, codes.join())
@@ -760,22 +718,46 @@ export default class GMUsers extends Service {
return Buffer.from(codes.join('\n'));
}
public async setWarRecord(roleIds: string[], _warId: string) {
public async getGiftCodeDetailList(page: number, pageSize: number, sortField: string, sortOrder: string, form: SearchGiftCodeDetailParam = {}) {
const { ctx } = this;
let warId = parseInt(_warId);
if(warId < 104) return ctx.service.utils.resResult(STATUS.WRONG_PARMS, null, '不可跳到序章以前')
const list = await GiftCodeDetailModel.findByCondition(page, pageSize, sortField, sortOrder, form);
const total = await GiftCodeDetailModel.countByCondition( form )
return ctx.service.utils.resResult(STATUS.SUCCESS, {
list: list.map(cur => ({...cur, env: ctx.app.config.realEnv })), total
});
}
public async setWarRecord(roleId: string, warId: number) {
const { ctx } = this;
if(!isNumber(warId)) return ctx.service.utils.resResult(STATUS.WRONG_PARMS);
if(warId < 104) return ctx.service.utils.resResult(STATUS.WRONG_PARMS, '不可以跳到序章以前')
let dicWar = gameData.war.get(warId);
if(!dicWar) return ctx.service.utils.resResult(STATUS.WRONG_PARMS);
for(let roleId of roleIds) {
await this.setSingleWarRecord(roleId, dicWar);
await this.setWarStarAndScript(roleId, dicWar);
if(dicWar.warType == WAR_TYPE.TOWER) {
await this.setTowerWar(roleId, dicWar);
}
return ctx.service.utils.resResult(STATUS.SUCCESS);
}
private async setSingleWarRecord(roleId: string, dicWar: DicWar) {
private async setTowerWar(roleId: string, dicWar: DicWar) {
let towerLv = 1;
for(let [lv, dicTower] of gameData.tower) {
if(dicTower.warArray.indexOf(dicWar.war_id) != -1) {
towerLv = lv; break;
}
}
let role = await RoleModel.updateRoleInfo(roleId, { towerLv });
await TowerRecordModel.deleteAccount(roleId);
await TowerRecordModel.insertTowerRec(roleId, towerLv);
await HangUpRecordModel.updateRec(roleId, role.roleName, towerLv, new Date(), []);
}
private async setWarStarAndScript(roleId: string, dicWar: DicWar) {
let { warStar } = await RoleModel.findByRoleId(roleId);
let deleteIds: number[] = [], myMaxWarId = 0, insertParams: DicWar[] = [];
let deleteIds: number[] = [], myMaxWarId = 0;
for(let i = 0; i < warStar.length; i++) {
let { id, warType } = warStar[i];
if(warType == dicWar.warType) {
@@ -795,7 +777,6 @@ export default class GMUsers extends Service {
let _dicWar = gameData.war.get(id)
if(_dicWar && _dicWar.warType == dicWar.warType) {
newWarStar.push({ id, warType: _dicWar.warType, star: 0, stars: [] });
insertParams.push(_dicWar);
}
}
}
@@ -805,12 +786,17 @@ export default class GMUsers extends Service {
let _dicWar = gameData.war.get(dicWar.previousGk);
newWarStar.push({ id: _dicWar.war_id, warType: _dicWar.warType, star: 0, stars: [] });
}
await RScriptRecordModel.deleteByWarType(roleId, dicWar.warType);
let insertParams: DicWar[] = [];
for(let [_, obj] of gameData.war) {
if(dicWar.warType == obj.warType && obj.war_id < dicWar.war_id) {
insertParams.push(obj);
}
}
if(insertParams.length > 0) {
await RScriptRecordModel.insertScripts(roleId, insertParams);
}
if(deleteIds.length > 0) {
await RScriptRecordModel.deleteByWarId(roleId, deleteIds);
}
let role = await RoleModel.updateRoleInfo(roleId, { warStar: newWarStar });
return role;
}

4
gm-server/config/config.alpha.ts
View File

@@ -11,6 +11,10 @@ export default (appInfo: EggAppInfo) => {
options: { useNewUrlParser: true, useUnifiedTopology: true },
};
config.redis = {
url: 'r-8vbl8okinxn1zhkwh2.redis.zhangbei.rds.aliyuncs.com', // 内网
pw: 'zyz_alpha_2021'
};
// the return config will combines to EggAppConfig
return {
...defaultConfig(appInfo),

22
gm-server/config/config.default.ts
View File

@@ -29,6 +29,10 @@ export default (appInfo: EggAppInfo) => {
url: 'mongodb://dbop:zyzGm2021@dds-8vb9964bb4cc7f241.mongodb.zhangbei.rds.aliyuncs.com:3717,dds-8vb9964bb4cc7f242.mongodb.zhangbei.rds.aliyuncs.com:3717/zyzgm?replicaSet=mgset-507933150', // 内网
options: { useNewUrlParser: true, useUnifiedTopology: true },
};
config.redis = {
url: 'r-8vb4i2kgl91886fkxd.redis.zhangbei.rds.aliyuncs.com', // 内网
pw: 'zyz_2020'
};
config.security = {
csrf: {
@@ -72,14 +76,15 @@ export default (appInfo: EggAppInfo) => {
maxFileSize: 1024,
};
config.bigServers = [ // 大区数据
{ id: 1, env: 'stable', name: "常山少年", domain: 'http://pinus_gm_test.trgame.cn' },
{ id: 2, env: 'alpha', name: "测试服", domain: 'http://zyz_gm.trgame.cn' },
let regions = [ // 大区数据
{ id: 1, env: 'stable', name: "常山少年", domain: 'http://zyz_gm.trgame.cn' },
{ id: 2, env: 'alpha', name: "测试服", domain: 'http://pinus_gm_test.trgame.cn' },
{ id: 3, env: 'dev', name: "开发服", domain: 'http://zyzdev_gm.trgame.cn' }
];
config.regions = regions;
let httpProxy: any = {};
for(let { env, domain } of config.bigServers) {
for(let { env, domain } of regions) {
httpProxy[`/api/${env}`] = {
target: domain,
changeOrigin: true,
@@ -89,6 +94,15 @@ export default (appInfo: EggAppInfo) => {
return path.replace(`/api/${env}`, '/api')
}
}
httpProxy[`/web/${env}`] = {
target: domain,
changeOrigin: true,
secure: true,
pathRewrite: function(path) {
console.log('proxy', path, path.replace(`/web/${env}`, '/web'))
return path.replace(`/web/${env}`, '/web')
}
}
}
config.proxy = httpProxy;

4
gm-server/config/config.dev.ts
View File

@@ -10,6 +10,10 @@ export default (appInfo: EggAppInfo) => {
url: 'mongodb://dbop:zyzDev2021@dds-8vb5c74ba4263da41.mongodb.zhangbei.rds.aliyuncs.com:3717,dds-8vb5c74ba4263da42.mongodb.zhangbei.rds.aliyuncs.com:3717,dds-8vb5c74ba4263da43.mongodb.zhangbei.rds.aliyuncs.com:3717/zyz?readPreference=secondary&replicaSet=mgset-506991391', // 内网
options: { useNewUrlParser: true, useUnifiedTopology: true },
};
config.redis = {
url: 'r-8vb418l8kkju9sis8k.redis.zhangbei.rds.aliyuncs.com', // 内网
pw: 'zyz_dev_2021'
};
// the return config will combines to EggAppConfig
return {

4
gm-server/config/config.isbn.ts
View File

@@ -10,6 +10,10 @@ export default (appInfo: EggAppInfo) => {
url: 'mongodb://root:Bantus123@dds-8vb74337eab84d641.mongodb.zhangbei.rds.aliyuncs.com:3717,dds-8vb74337eab84d642.mongodb.zhangbei.rds.aliyuncs.com:3717/admin?replicaSet=mgset-504694158', // 内网
options: { useNewUrlParser: true, useUnifiedTopology: true },
};
config.redis = {
url: 'r-8vbekkbb3z8ru2ckuj.redis.zhangbei.rds.aliyuncs.com', // 内网
pw: 'zyz_isbn_2021'
};
// the return config will combines to EggAppConfig
return {

24
gm-server/config/config.local.ts
View File

@@ -18,7 +18,29 @@ export default (appInfo: EggAppInfo) => {
url: 'mongodb://127.0.0.1:27017/zyzgm', // 内网
options: { useNewUrlParser: true, useUnifiedTopology: true },
};
config.proxy = {};
config.redis = {
url: '127.0.0.1', // 内网
pw: ''
};
let regions = [ // 大区数据
{ id: 1, env: 'test', name: "测试", domain: 'http://127.0.0.1:7002' },
];
config.regions = regions;
let httpProxy: any = {};
for(let { env, domain } of regions) {
httpProxy[`/api/${env}`] = {
target: domain,
changeOrigin: true,
secure: true,
pathRewrite: function(path) {
console.log('proxy', path, path.replace(`/api/${env}`, '/api'))
return path.replace(`/api/${env}`, '/api')
}
}
}
config.proxy = httpProxy;
// the return config will combines to EggAppConfig
return {

28
gm-server/config/config.stable.ts Normal file
View File

@@ -0,0 +1,28 @@
import { EggAppConfig, EggAppInfo, PowerPartial } from 'egg';
import defaultConfig from './config.default';
export default (appInfo: EggAppInfo) => {
const config = {} as PowerPartial<EggAppConfig>;
config.mongoose = {
url: 'mongodb://dbop:zyzdbopbantu@dds-8vbdb47c6fb58a541.mongodb.zhangbei.rds.aliyuncs.com:3717,dds-8vbdb47c6fb58a542.mongodb.zhangbei.rds.aliyuncs.com:3717/zyz?replicaSet=mgset-500808098', // 内网
options: { useNewUrlParser: true, useUnifiedTopology: true },
};
config.redis = {
url: 'r-8vb4i2kgl91886fkxd.redis.zhangbei.rds.aliyuncs.com', // 内网
pw: 'zyz_2020'
};
config.xtransit = {
server: 'ws://172.26.117.35:9092',
appId: 3,
appSecret: 'a48ad5ca44e2d02cbd7f4c0326fa3101',
error_log: [ '/root/logs/zyz/zyz-web.log', '/root/logs/zyz/common-error.log', '/root/logs/zyz/egg-agent.log' ],
};
// the return config will combines to EggAppConfig
return {
...defaultConfig(appInfo),
...config
};
};

45
gm-server/package-lock.json generated
View File

@@ -1039,8 +1039,7 @@
"asynckit": {
"version": "0.4.0",
"resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
"integrity": "sha1-x57Zf380y48robyXkLzDZkdLS3k=",
"dev": true
"integrity": "sha1-x57Zf380y48robyXkLzDZkdLS3k="
},
"atob": {
"version": "2.1.2",
@@ -2894,7 +2893,6 @@
"version": "1.0.8",
"resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz",
"integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==",
"dev": true,
"requires": {
"delayed-stream": "~1.0.0"
}
@@ -3291,8 +3289,7 @@
"delayed-stream": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz",
"integrity": "sha1-3zrhmayt+31ECqrgsp4icrJOxhk=",
"dev": true
"integrity": "sha1-3zrhmayt+31ECqrgsp4icrJOxhk="
},
"delegates": {
"version": "1.0.0",
@@ -5471,13 +5468,12 @@
"integrity": "sha1-gQaNKVqBQuwKxybG4iAMMPttXoA="
},
"form-data": {
"version": "2.5.1",
"resolved": "https://registry.npmjs.org/form-data/-/form-data-2.5.1.tgz",
"integrity": "sha512-m21N3WOmEEURgk6B9GLOE4RuWOFf28Lhh9qGYeNlGq4VDXUlJy2th2slBNU8Gp8EzloYZOibZJ7t5ecIrFSjVA==",
"dev": true,
"version": "4.0.0",
"resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.0.tgz",
"integrity": "sha512-ETEklSGi5t0QMZuiXoA/Q6vcnxcLQP5vdugSpuAyi6SVGi2clPPp+xgEhuMaHC+zGgn31Kd235W35f7Hykkaww==",
"requires": {
"asynckit": "^0.4.0",
"combined-stream": "^1.0.6",
"combined-stream": "^1.0.8",
"mime-types": "^2.1.12"
}
},
@@ -5488,13 +5484,20 @@
"dev": true
},
"formstream": {
"version": "1.1.0",
"resolved": "https://registry.npmjs.org/formstream/-/formstream-1.1.0.tgz",
"integrity": "sha1-UfOXDyYTbrCtRDBN5M67UCB7RHk=",
"version": "1.1.1",
"resolved": "https://registry.npmjs.org/formstream/-/formstream-1.1.1.tgz",
"integrity": "sha512-yHRxt3qLFnhsKAfhReM4w17jP+U1OlhUjnKPPtonwKbIJO7oBP0MvoxkRUwb8AU9n0MIkYy5X5dK6pQnbj+R2Q==",
"requires": {
"destroy": "^1.0.4",
"mime": "^1.3.4",
"mime": "^2.5.2",
"pause-stream": "~0.0.11"
},
"dependencies": {
"mime": {
"version": "2.6.0",
"resolved": "https://registry.npmjs.org/mime/-/mime-2.6.0.tgz",
"integrity": "sha512-USPkMeET31rOMiarsBNIHZKLGgvKc/LrjofAnBlOttf5ajRvqiRA8QsenbcooctK6d6Ts6aqZXBA+XbkKthiQg=="
}
}
},
"fragment-cache": {
@@ -7123,7 +7126,8 @@
"mime": {
"version": "1.6.0",
"resolved": "https://registry.npmjs.org/mime/-/mime-1.6.0.tgz",
"integrity": "sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg=="
"integrity": "sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==",
"dev": true
},
"mime-db": {
"version": "1.44.0",
@@ -10445,6 +10449,17 @@
"ms": "^2.1.1"
}
},
"form-data": {
"version": "2.5.1",
"resolved": "https://registry.npmjs.org/form-data/-/form-data-2.5.1.tgz",
"integrity": "sha512-m21N3WOmEEURgk6B9GLOE4RuWOFf28Lhh9qGYeNlGq4VDXUlJy2th2slBNU8Gp8EzloYZOibZJ7t5ecIrFSjVA==",
"dev": true,
"requires": {
"asynckit": "^0.4.0",
"combined-stream": "^1.0.6",
"mime-types": "^2.1.12"
}
},
"isarray": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz",

6
gm-server/package.json
View File

@@ -21,7 +21,9 @@
"lint": "eslint . --ext .ts",
"clean": "ets clean",
"local": "EGG_SERVER_ENV=local npm run dev",
"prod": "EGG_SERVER_ENV=prod npm run dev"
"prod": "EGG_SERVER_ENV=prod npm run dev",
"deve": "EGG_SERVER_ENV=dev npm run dev",
"dis": "EGG_SERVER_ENV=dis npm run dev"
},
"dependencies": {
"await-stream-ready": "^1.0.1",
@@ -34,6 +36,8 @@
"egg-cors": "^2.2.3",
"egg-http-proxy-middleware": "^1.0.3",
"egg-scripts": "^2.6.0",
"form-data": "^4.0.0",
"formstream": "^1.1.1",
"moment": "^2.29.0",
"pump": "^3.0.0",
"reflect-metadata": "^0.1.13",

17
shared/consts/constModules/mailConst.ts
View File

@@ -5,9 +5,17 @@ export enum MAIL_STATUS {
RECEIVED = 2,
};
export const MAIL_TEM_TYPE = {
GAMEMAIL: 1,
GMTYPE: 2,
export enum MAIL_TIME_TYPE {
IMMEDIATE = 1, // 即时邮件
DELAY = 2, // 延时邮件
CIRCLE = 3, // 循环邮件
};
export enum GM_MAIL_STATUS {
CREATE = 0, // 创建
PASS = 1, // 审批通过
NOT_PASS = -1, // 审批不通过
};
export enum GM_MAIL_TYPE {
@@ -43,4 +51,5 @@ export enum MAIL_TYPE {
TREAT_GUILD_INFO = 22, // 月卡奖品
};
export const SEND_NAME = '系统';
export const SEND_NAME = '系统';
export const SEND_TITLE = '系统邮件';

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

@@ -21,6 +21,7 @@ export const TEEN_DAILY_MAX_TIME = 1.5 * 60 * 60; // 未成年人工作日每天
export const GUEST_DAY = 15; // 同一设备15天内不得重复体验游客模式
export const REFRESH_TIME = 5; // 统一一天刷新时间
export const REF_CIRCLE_MAIL_TIME = 3; // 统一一天刷新定期邮件时间
export const PUSH_BATCH = 100; // 推送分批人数
export const PUSH_INTERVAL = 5 * 1000; // 分批时间，5秒一批
export enum TIME_OUTPUT_TYPE {
@@ -47,6 +48,7 @@ export const COUNTER = {
NOTICE: { name: 'notice', def: 1 },
GIFT_CODE: { name: 'giftCode', def: 1 },
PVP_SEASON_NUM: { name: 'pvpSeason', def: 1 },
REGION: { name: 'region', def: 1 }
};
export const DEFAULT_HEROES = [19, 53,];
@@ -695,7 +697,14 @@ export enum GACHA_CONTENT_TYPE {
export const GACHA_OCCUPY_HID = 9999; // 抽卡里占位的武将
export enum MARQUEE_TYPE {
// 跑马灯显示类型
export enum MARQUEE_SHOW_TYPE {
ONCE = 1, // 一次性
CIRCLE = 2, // 循环
}
// 推送时间类型
export enum MARQUEE_TIME_TYPE {
INSTANT = 1, // 发送后立刻推送
SCHEDULE = 2, // 定时器
}
@@ -705,11 +714,12 @@ export enum SERVER_STATUS {
HOT = 2, // 火爆
WILL_OPEN = 3, // 即将开启
MAINTENANCE = 4, // 维护中
HIDE = 0, // 隐藏
}
export enum WHITE_LIST_TYPE {
IP = 1, // ip地址
TEL = 2, // 玩家手机号
UID = 2, // 玩家账号
}
// 获取道具类型
@@ -748,6 +758,25 @@ export enum THINKING_DATA_MODE_LIST {
}
export let THINKING_DATA_MODE = THINKING_DATA_MODE_LIST.DEBUG;
export enum BLOCK_TYPE {
NOT = 0,
BAN = 1,
BLOCK = 2,
}
export enum SERVER_TIMER {
FIVE_HALF = 1, // 5:30
TEN_HALF = 2, // 10:30
FIFTEEN_HALF = 3, // 15:30
NINETEEN_HALF = 4, // 19:30
}
export enum GIFT_GENERATE_TYPE {
ONE_TO_ONE = 1, // 一人一码，一条码只能被用一次
ONE_TO_MANY = 2, // 通码，一条码能被多人使用，每个人只能用一次
}
export enum ITEM_CHANGE_REASON {
DEBUG = 0, // debug接口、后台
RENAME = 1, // 重命名

7
shared/consts/statusCode.ts
View File

@@ -10,6 +10,8 @@ export const STATUS = {
SERVER_MAINTENANCE: { code: 7, simStr: '服务器维护中' },
VERSION_ERR: { code: 8, simStr: '版本号太低，请更新' },
BLOCK_WORDS: { code: 9, simStr: '内容有不合法词汇' },
BLOCKED: { code: 10, simStr: '您已被封禁' },
BANNED: { code: 11, simStr: '您已被禁言' },
GLOBAL_ERR: { code: 1003, simStr: '服务器内部错误' },
// http请求
REQUEST_TIME_OUT: { code: 2000, simStr: '请求超时' },
@@ -35,6 +37,7 @@ export const STATUS = {
ROLE_EXIST: { code: 10017, simStr: '账号已存在' },
CHANNEL_ERR: { code: 10018, simStr: '无此渠道' },
VALIDATE_ERR: { code: 10019, simStr: '渠道校验错误' },
SERVER_STOP_REGISTER: { code: 10020, simStr: '服务器已停止注册' },
// 战斗相关状态 20000 - 29999
// 战斗通用 20000 - 20099
BATTLE_MISS_INFO: { code: 20001, simStr: '缺少关卡信息' },
@@ -184,6 +187,7 @@ export const STATUS = {
HAS_RECEIVE_WISH_GOOD: { code: 20930, simStr: '玩家已经收到许愿物品' },
NOT_WISH_THE_QUALITY_GOODS: { code: 20931, simStr: '不能够许愿该品质的物品' },
GUILD_PAY_CONDITION: { code: 20932, simStr: '充值金额不足' },
GUILD_USER_IS_LEADER: { code: 20933, simStr: '该成员已经是团长' },
GUILD_SCRIPT_IS_OPENED_TODAY: { code: 20950, simStr: '今日已开启过演武场' },
GUILD_SCRIPT_NOT_OPENED: { code: 20951, simStr: '演武场未开启' },
@@ -241,6 +245,7 @@ export const STATUS = {
ROLE_IS_NOT_INIT: { code: 30006, simStr: '玩家未初始化' },
AP_BUY_TIMES_LACK: { code: 30007, simStr: '购买次数不足' },
CONSUME_TYPE_ERR: { code: 30008, simStr: '道具类型错误' },
DB_DATA_NOT_FOUND: { code: 30009, simStr: '数据库数据未找到' },
// 武将养成通用 30100 - 30199
@@ -437,6 +442,8 @@ export const STATUS = {
GM_ACTIVITY_NOT_FIT_GROUP_TYPE: { code: 60021, simStr: '该活动不满足该活动组类型' },
GM_MARQUEE_ERR: { code: 60022, simStr: '跑马灯定时设置错误' },
GM_MARQUEE_CANCEL_ERR: { code: 60023, simStr: '取消失败' },
GM_MAIL_NOT_FOUND: { code: 60024, simStr: '未找到该邮件' },
GM_MAIL_HAS_SENT: { code: 60025, simStr: '邮件已经审批过了' },
// 支付相关状态 70000 - 79999
NO_PRODUCT_ID: { code: 70001, simStr: '无效商品' },
NO_PAY_TYPE: { code: 70002, simStr: '无效支付类型' },

4
shared/db/AccuseRec.ts
View File

@@ -37,7 +37,8 @@ export default class AccuseRec extends BaseModel {
}
private static getSearchObj(form: {}) {
let searchObj = form;
let searchObj = {};
console.log(form);
return searchObj
}
@@ -52,6 +53,7 @@ export default class AccuseRec extends BaseModel {
sort[sortField] = -1;
}
}
console.log('page', page, 'pageSize', pageSize, 'sort', sort)
const result: AccuseRecType[] = await AccuseRecModel.find(searchObj).limit(pageSize).skip((page - 1) * pageSize).sort(sort).lean({ getters: true, virtuals: true });
return result;

15
shared/db/Activity.ts
View File

@@ -107,6 +107,21 @@ export default class Activity extends BaseModel {
return result;
}
public static async findAllActivities() {
let all: ActivityModelType[] = [];
let createdAt;
for(let i = 0; i < 9999; i++) { // 防死循环
let condition = {};
if(createdAt) condition['createdAt'] = { $gt: createdAt }
let cur: ActivityModelType[] = await ActivityModel.find(condition).limit(1000).sort({ createdAt: 1 }).lean();
if(cur.length == 0) break;
createdAt = cur[cur.length - 1].createdAt;
all.push(...cur);
}
return all;
}
//查询
public static async findByCondition(page: number, pageSize: number, sortField: string = 'updatedAt', sortOrder: string = 'descend', type: number = 0, groupId: number = 0, current: boolean = false, activityId: number = 0) {
let searchObj = {};

20
shared/db/ActivityGroup.ts
View File

@@ -107,6 +107,12 @@ export default class Activity_Group extends BaseModel {
return result;
}
//获取所有活动组
public static async findAllActivityGroup() {
let result: ActivityGroupModelType[] = await ActivityGroupModel.find({}).lean();
return result;
}
//删除组
public static async deleteGroup(groupId: number) {
let result = await ActivityGroupModel.deleteMany({ groupId });
@@ -138,6 +144,20 @@ export default class Activity_Group extends BaseModel {
const result = await ActivityGroupModel.count(searchObj);
return result;
}
public static async findAllActivityGroups() {
let all: ActivityGroupModelType[] = [];
let createdAt;
for(let i = 0; i < 9999; i++) { // 防死循环
let condition = {};
if(createdAt) condition['createdAt'] = { $gt: createdAt }
let cur = await ActivityGroupModel.find(condition).limit(1000).sort({ createdAt: 1 }).lean();
if(cur.length == 0) break;
createdAt = cur[cur.length - 1].createdAt;
all.push(...cur);
}
return all;
}
}
export const ActivityGroupModel = getModelForClass(Activity_Group);

13
shared/db/ActivityGroupType.ts
View File

@@ -89,6 +89,19 @@ export default class Activity_GroupType extends BaseModel {
return result;
}
public static async findAllActivityGroupTypes() {
let all: ActivityGroupTypeInter[] = [];
let createdAt;
for(let i = 0; i < 9999; i++) { // 防死循环
let condition = {};
if(createdAt) condition['createdAt'] = { $gt: createdAt }
let cur: ActivityGroupTypeInter[] = await ActivityGroupTypeModel.find(condition).limit(1000).sort({ createdAt: 1 }).lean();
if(cur.length == 0) break;
createdAt = cur[cur.length - 1].createdAt;
all.push(...cur);
}
return all;
}
}
export const ActivityGroupTypeModel = getModelForClass(Activity_GroupType);

2
shared/db/Api.ts
View File

@@ -38,7 +38,7 @@ export default class Api extends BaseModel {
}
export let ApiModel: ReturnModelType<typeof Api, {}> = getModelForClass(Api);
export let ApiModel: ReturnModelType<typeof Api, {}>;
export function loadApiModel(connect: mongoose.Connection) {
ApiModel = getModelForClass(Api, {
existingConnection: connect

40
shared/db/CounterAll.ts Normal file
View File

@@ -0,0 +1,40 @@
import BaseModel from './BaseModel';
import { index, getModelForClass, prop, DocumentType, ReturnModelType, mongoose } from '@typegoose/typegoose';
/**
* 自增 ID
*/
@index({ name: 1 })
export default class CounterAll extends BaseModel {
@prop({ required: true })
name: string;
@prop({ required: true, default: 1 })
seq: number;
public static async getNewCounter(param:{name: string, def: number}, lean = true) {
let {name, def:defaultVal} = param;
let counter: CounterType = await CounterAllModal.findOneAndUpdate({ name }, { $inc: { seq: 1 } }, { new: true, upsert: true }).lean(lean);
if(!counter || (counter&&counter.seq == 1) && defaultVal != 1) {
counter = await CounterAllModal.findOneAndUpdate({ name }, { $set: { seq: defaultVal } }, { new: true, upsert: true }).lean(lean);
}
return counter?.seq;
}
public static async getCounter(param:{name: string, def: number}, lean = true) {
let {name, def:defaultVal} = param;
let counter: CounterType = await CounterAllModal.findOne({ name }).lean(lean);
return counter?.seq||defaultVal;
}
}
export let CounterAllModal: ReturnModelType<typeof CounterAll, {}>;
export function loadCounterModal(connect: mongoose.Connection) {
CounterAllModal = getModelForClass(CounterAll, {
existingConnection: connect
});
}
export interface CounterType extends Pick<DocumentType<CounterAll>, keyof CounterAll>{};

31
shared/db/Equip.ts
View File

@@ -4,6 +4,7 @@ import { COUNTER } from '../consts';
import { CounterModel } from './Counter';
import { HeroModel } from './Hero';
import { RoleModel } from './Role';
import { SearchEquipParam } from '../domain/backEndField/search';
export class RandSe {
@prop({ required: true })
@@ -193,6 +194,36 @@ export default class Equip extends BaseModel {
return result;
}
private static getSearchObj(form: SearchEquipParam) {
let searchObj = {};
if(form.roleId) searchObj['roleId'] = form.roleId;
if(form.roleName) searchObj['roleName'] = { $regex: new RegExp(form.roleName.toString(), 'i') };
if(form.id) searchObj['id'] = form.id;
return searchObj
}
public static async findByCondition(page: number, pageSize: number, sortField: string = 'updatedAt', sortOrder: string = 'descend', form: SearchEquipParam = {}) {
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: EquipType[] = await EquipModel.find(searchObj).limit(pageSize).skip((page - 1) * pageSize).sort(sort).lean({ getters: true, virtuals: true });
return result;
}
public static async countByCondition(form: SearchEquipParam = {}) {
let searchObj = this.getSearchObj(form);
const result = await EquipModel.count(searchObj);
return result;
}
}
export const EquipModel = getModelForClass(Equip);

2
shared/db/GMGroup.ts
View File

@@ -74,7 +74,7 @@ export default class GMGroup extends BaseModel {
}
export let GMGroupModel: ReturnModelType<typeof GMGroup, {}> = getModelForClass(GMGroup);
export let GMGroupModel: ReturnModelType<typeof GMGroup, {}>;
export function loadGMGroupModel(connect: mongoose.Connection) {
GMGroupModel = getModelForClass(GMGroup, {
existingConnection: connect

144
shared/db/GMMail.ts
View File

@@ -2,8 +2,13 @@
* 邮件的模板，在GM后台能看到的邮件列表
*/
import BaseModel from './BaseModel';
import { getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
import { nowSeconds } from '../pubUtils/timeUtil';
import { getModelForClass, prop, DocumentType, mongoose, ReturnModelType } from '@typegoose/typegoose';
import { GM_MAIL_STATUS, GM_MAIL_TYPE, MAIL_TIME_TYPE } from '../consts';
import { SearchMailParam } from '../domain/backEndField/search';
import { getCurDay, nowSeconds } from '../pubUtils/timeUtil';
import { GMMail as StategyMail } from './ServerStategy';
import { ServerlistType } from './Serverlist';
import moment = require('moment');
class Reward {
@prop({ required: true })
@@ -12,28 +17,111 @@ class Reward {
count: number;
}
export class Receiver {
@prop({ required: true })
env: string;
@prop({ required: true })
serverId: number;
@prop({ required: true })
roleId?: string;
@prop({ required: true })
roleName?: string;
}
export default class GMMail extends BaseModel {
@prop({ required: false})
hasGoods: boolean; // 有效时间，单位小时
@prop({ required: true, type: Reward, default: [], _id: false })
goods: Reward[];
@prop({ required: true, default: true })
useTempTime: boolean; // 生成邮件是否按照模板时间
timeType: MAIL_TIME_TYPE; // 邮件时间类型
@prop({ required: false})
continueHour: number; // 如果不按模板时间，sendTime为生成单独邮件的时候，endTime为sendTime+continueHour，单位小时
expire: number; // 有效时间，单位小时
@prop({ required: true })
sendTime: number; // 如果按照模板时间，发送时间，10位时间戳
startTime: number; // 发送时间，延时邮件使用
@prop({ required: true })
endTime: number; // 如果按照模板时间，过期时间，10位时间戳
circleStart: number; // 循环邮件开始循环时间
@prop({ required: true })
circleEnd: number; // 循环邮件结束循环时间
@prop({ required: true })
circleDay: number; // 循环时间，每周几，0表示每天
@prop({ required: true })
circleHour: string; // 几点发送
@prop({ required: true })
title: string;
@prop({ required: true })
content: string;
@prop({ required: true })
sendName: string;
@prop({ required: true })
mailType: GM_MAIL_TYPE; // 收件人类型
@prop({ required: true, type: Receiver, _id: false })
receivers: Receiver[];
@prop({ required: true })
reason: string; // 原因
@prop({ required: true, default: false })
isSp: boolean; // 特殊邮件
@prop({ required: true, default: 0 })
status: GM_MAIL_STATUS; // 邮件状态
@prop({ required: true })
viewBy: number; // 审核人
@prop({ required: true })
viewAt: Date; // 审核时间
@prop({ required: true })
sendTime: string; // 发送时间
public setByRegionStategy(type: 'openMail'|'circleMail', gmmail: StategyMail, newServer: ServerlistType, uid) {
this.hasGoods = !!gmmail.goods?.length;
this.goods = gmmail.goods;
this.timeType = type == 'openMail'? MAIL_TIME_TYPE.DELAY: MAIL_TIME_TYPE.CIRCLE;
this.expire = gmmail.expire;
if(type == 'openMail') {
this.startTime = nowSeconds();
} else {
this.circleStart = nowSeconds();
this.circleEnd = nowSeconds() + gmmail.circleContinueDay * 24 * 60 * 60;
this.circleDay = gmmail.circleDay;
this.circleHour = gmmail.circleHour;
}
this.title = gmmail.title;
this.content = gmmail.content;
this.sendName = gmmail.sendName;
this.mailType = GM_MAIL_TYPE.SERVER;
this.receivers = [{
env: newServer.env,
serverId: newServer.id
}];
this.reason = gmmail.reason;
this.isSp = gmmail.isSp;
this.status = GM_MAIL_STATUS.PASS;
this.viewBy = uid;
this.viewAt = new Date();
if (type == 'openMail') {
this.sendTime = moment(this.startTime * 1000).format('YYYY-MM-DD HH:mm:ss');
} else {
this.sendTime = (this.circleDay == 0?'每天': '每周'+this.circleDay) + ' ' + this.circleHour;
}
}
public static async addMail(params: GMMailTypeParam, uid = 1) {
const doc = new GMMailModel();
@@ -52,25 +140,21 @@ export default class GMMail extends BaseModel {
return result;
}
public static async getMail(updatedMailAt: number, lean = true) {
const result: GMMailType[] = await GMMailModel.find({ $or: [{updatedAt: { $gte: new Date(updatedMailAt) }}, {sendTime: { $lte: nowSeconds() }}], endTime: { $gte: nowSeconds()} }).lean(lean);
return result;
}
public static async getMails( lean = true) {
const result: GMMailType[] = await GMMailModel.find({ endTime: { $gte: nowSeconds() }}).lean(lean);
return result;
}
private static getSearchObj(form: {_id?: string, content?: string}) {
private static getSearchObj(form: SearchMailParam) {
let searchObj = {};
if(form['_id']) searchObj['_id'] = form._id;
if(form['content']) searchObj['context'] = { $regex: new RegExp(form.content.toString(), 'i') }
if(form.createTimeStart) searchObj['createdAt'] = { $gt: new Date(form.createTimeStart * 1000) };
if(form.createTimeEnd) searchObj['createdAt'] = { $lt: new Date(form.createTimeEnd * 1000) };
if(form.serverId) searchObj['receivers.serverId'] = form.serverId;
if(form.roleId) searchObj['receivers.roleId'] = form.roleId;
if(form.roleName) searchObj['receivers.roleName'] = { $regex: new RegExp(form.roleName.toString(), 'i') }
if(form.status) searchObj['status'] = form.status;
if(form.mailType) searchObj['mailType'] = form.mailType;
if(form.hasGoods != undefined) searchObj['hasGoods'] = form.hasGoods;
if(form.title) searchObj['title'] = { $regex: new RegExp(form.title.toString(), 'i') }
return searchObj
}
public static async findByCondition(page: number, pageSize: number, sortField: string, sortOrder: string, form: {_id?: string, content?: string} = {}) {
public static async findByCondition(page: number, pageSize: number, sortField: string, sortOrder: string, form: SearchMailParam = {}) {
let searchObj = this.getSearchObj(form);
let sort = {};
@@ -86,17 +170,31 @@ export default class GMMail extends BaseModel {
}
public static async countByCondition(form: {_id?: string, content?: string} = {}) {
public static async countByCondition(form: SearchMailParam = {}) {
let searchObj = this.getSearchObj(form);
const result = await GMMailModel.count(searchObj);
return result;
}
public static async findCircleMails(env: string) {
const result: GMMailType[] = await GMMailModel.find({
timeType: MAIL_TIME_TYPE.CIRCLE,
circleStart: { $lt: nowSeconds() }, circleEnd: { $gte: nowSeconds() },
circleDay: { $in: [0, getCurDay(true)] }, 'receivers.env': env,
status: GM_MAIL_STATUS.PASS
});
return result;
}
}
export const GMMailModel = getModelForClass(GMMail);
export let GMMailModel: ReturnModelType<typeof GMMail, {}>;
export function loadGMMailModel(connect: mongoose.Connection) {
GMMailModel = getModelForClass(GMMail, {
existingConnection: connect
});
}
export interface GMMailType extends Pick<DocumentType<GMMail>, keyof GMMail> { };

2
shared/db/GMRecord.ts
View File

@@ -28,7 +28,7 @@ export default class GMRecord extends BaseModel {
}
export let GMRecordModel: ReturnModelType<typeof GMRecord, {}> = getModelForClass(GMRecord);
export let GMRecordModel: ReturnModelType<typeof GMRecord, {}>;
export function loadGMRecordModel(connect: mongoose.Connection) {
GMRecordModel = getModelForClass(GMRecord, {
existingConnection: connect

2
shared/db/GMUser.ts
View File

@@ -85,7 +85,7 @@ export default class GMUser extends BaseModel {
}
}
export let GMUserModel: ReturnModelType<typeof GMUser, {}> = getModelForClass(GMUser);
export let GMUserModel: ReturnModelType<typeof GMUser, {}>;
export function loadGMUserModel(connect: mongoose.Connection) {
GMUserModel = getModelForClass(GMUser, {
existingConnection: connect

2
shared/db/GMUserGroup.ts
View File

@@ -32,7 +32,7 @@ export default class GMUserGroup extends BaseModel {
}
}
export let GMUserGroupModel: ReturnModelType<typeof GMUserGroup, {}> = getModelForClass(GMUserGroup);
export let GMUserGroupModel: ReturnModelType<typeof GMUserGroup, {}>;
export function loadGMUserGroupModel(connect: mongoose.Connection) {
GMUserGroupModel = getModelForClass(GMUserGroup, {
existingConnection: connect

79
shared/db/GiftCode.ts
View File

@@ -1,7 +1,8 @@
import BaseModel from './BaseModel';
import { getModelForClass, prop, DocumentType, modelOptions } from '@typegoose/typegoose';
import { CounterModel } from './Counter';
import { COUNTER } from '../consts';
import { COUNTER, GIFT_GENERATE_TYPE } from '../consts';
import { SearchGiftCodeParam } from '../domain/backEndField/search';
class Rewards {
@prop({ required: true })
@@ -15,81 +16,84 @@ class Rewards {
**/
@modelOptions({ schemaOptions: { id: false } })
export default class GiftCode extends BaseModel {
@prop({ required: true, default: '' })
@prop({ required: true })
id: number; // 唯一id
@prop({ required: true, default: '' })
name: string; // 礼包码名
@prop({ required: true, default: false })
isLimit: boolean; // 每个码是否有使用次数限制
@prop({ required: true, default: 0 })
count: number; // 每个码可使用次数
@prop({ required: true, type: Rewards, _id: false })
goods: Rewards[]; // 奖励
@prop({ required: true })
beginTime: Date; // 开始时间
beginTime: number; // 开始时间
@prop({ required: true })
endTime: Date; // 结束时间
endTime: number; // 结束时间
@prop({ required: true, default: 0 })
codeLen: number; // 礼包码位数
@prop({ required: true, default: '' })
remark: string; // 备注
@prop({ required: true, default: 0 })
generateType: number; // 生成类型
@prop({ required: true, default: 0, enum: GIFT_GENERATE_TYPE })
generateType: GIFT_GENERATE_TYPE; // 生成类型
@prop({ required: true, default: 0 })
generateCnt: number; // 已生成条数，giftCodeDetail的数量
@prop({ required: true, default: '' })
generateCode: string; // 单条的生成的那一个code
generateCnt: number; // 生成条数，giftCodeDetail的数量
@prop({ required: true, default: 0 })
usedNum: number; // 使用次数
public static async findData(id: number) {
@prop({ required: true, default: true })
isEnable: boolean; // 是否可以使用
public static async findByGiftId(id: number) {
let rec: GiftCodeType = await GiftCodeModel.findOne({ id }).lean();
return rec;
}
public static async updateData(id: string|number, values: GiftCodeParam, uid = 1) {
if(id == 'new') {
id = await CounterModel.getNewCounter(COUNTER.GIFT_CODE);
}
public static async createData(values: GiftCodeParam, uid = 1) {
let id = await CounterModel.getNewCounter(COUNTER.GIFT_CODE);
let doc = new GiftCodeModel();
let createObj = doc.toJSON();
delete values.id;
delete createObj._id;
delete createObj.id;
for(let key in values) {
delete createObj[key];
}
let obj = doc.toJSON();
let update = Object.assign(obj, values, { id });
let rec: GiftCodeType = await GiftCodeModel.findOneAndUpdate({ id }, { $set: {...values, updatedBy: uid}, $setOnInsert: { ...createObj, createdBy: uid } },
let rec: GiftCodeType = await GiftCodeModel.findOneAndUpdate({ id }, { $set: { updatedBy: uid}, $setOnInsert: { ...update, createdBy: uid } },
{ new: true, upsert: true }).lean(true);
return rec;
}
public static async updateData(id: number, values: GiftCodeParam, uid = 1) {
let rec: GiftCodeType = await GiftCodeModel.findOneAndUpdate({ id }, { $set: {...values, updatedBy: uid} },
{ new: true }).lean(true);
return rec;
}
public static async increaseUsedNum(id: number) {
let result: GiftCodeType = await GiftCodeModel.findOneAndUpdate({ id }, { $inc: { usedNum: 1 } }, { new: true }).lean();
return result;
}
private static getSearchObj(form: { name?: string, current?: boolean }) {
public static async increateGenerateNum(id: number, count: number) {
let result: GiftCodeType = await GiftCodeModel.findOneAndUpdate({ id }, { $inc: { generateCnt: count } }, { new: true }).lean();
return result;
}
private static getSearchObj(form: SearchGiftCodeParam) {
let searchObj = {};
if(form.id) searchObj['id'] = form.id;
if (form.name != undefined) searchObj['name'] = { $regex: new RegExp(form.name.toString(), 'i') };
if (form.current) {
searchObj['beginTime'] = { $lte: new Date };
searchObj['endTime'] = { $gte: new Date };
if (form.createTimeStart && form.createTimeEnd) {
searchObj['createdAt'] = { $lte: new Date(form.createTimeEnd * 1000), $gte: new Date(form.createTimeStart * 100) };
}
return searchObj
}
public static async findByCondition(page: number, pageSize: number, sortField: string, sortOrder: string, form: { name?: string, current?: boolean } = {}) {
public static async findByCondition(page: number, pageSize: number, sortField: string, sortOrder: string, form:SearchGiftCodeParam = {}) {
let searchObj = this.getSearchObj(form);
let sort = {};
@@ -105,7 +109,7 @@ export default class GiftCode extends BaseModel {
}
public static async countByCondition(form: { name?: string, current?: boolean } = {}) {
public static async countByCondition(form: SearchGiftCodeParam = {}) {
let searchObj = this.getSearchObj(form);
const result = await GiftCodeModel.count(searchObj);
@@ -113,7 +117,6 @@ export default class GiftCode extends BaseModel {
}
}
export const GiftCodeModel = getModelForClass(GiftCode);
export let GiftCodeModel = getModelForClass(GiftCode);
export interface GiftCodeType extends Pick<DocumentType<GiftCode>, keyof GiftCode> { }
export type GiftCodeParam = Partial<GiftCodeType>;

105
shared/db/GiftCodeDetail.ts
View File

@@ -1,7 +1,24 @@
import BaseModel from './BaseModel';
import { index, getModelForClass, prop, DocumentType, modelOptions, Ref, mongoose } from '@typegoose/typegoose';
import GiftCode, { GiftCodeType } from './GiftCode';
import { index, getModelForClass, prop, DocumentType, modelOptions } from '@typegoose/typegoose';
import { GIFT_GENERATE_TYPE } from '../consts';
import { GiftCodeModel, GiftCodeType } from './GiftCode';
import { nowSeconds } from '../pubUtils/timeUtil';
import { genCode } from '../pubUtils/util';
import { SearchGiftCodeDetailParam } from '../domain/backEndField/search';
class RoleRecord {
@prop({ required: true, default: '' })
roleId: string;
@prop({ required: true, default: '' })
roleName: string;
@prop({ required: true, default: 0 })
serverId: number;
@prop({ required: true, default: 0 })
time: number;
}
/**
* 举报记录
@@ -9,43 +26,101 @@ import { genCode } from '../pubUtils/util';
@modelOptions({ schemaOptions: { id: false } })
@index({ code: 1 })
export default class GiftCodeDetail extends BaseModel {
@prop({ required: true, default: '' })
giftId: number; // giftCode表的id
@prop({ required: true, default: '' })
giftName: string; // giftCode表的name
@prop({ required: true, default: 0, enum: GIFT_GENERATE_TYPE })
generateType: GIFT_GENERATE_TYPE; // 一人一码or通码
@prop({ required: true, default: '' })
code: string; // 兑换码
@prop({ ref: 'GiftCode', type: mongoose.Schema.Types.ObjectId })
giftCode: Ref<GiftCode>;
@prop({ required: true, default: '' })
usedNum: number; // 该码使用次数
@prop({ required: true, type: String })
roleIds: string[];
@prop({ required: true, type: RoleRecord, _id: false })
record: RoleRecord[];
// 根据code
public static async findByCode(code: string) {
let result: GiftCodeDetailType = await GiftCodeDetailModel.findOne({ code }).populate('giftCode').lean(true);
let result: GiftCodeDetailType = await GiftCodeDetailModel.findOne({ code }).lean(true);
return result;
}
public static async findByGiftCode(giftCode: GiftCodeType) {
let result: GiftCodeDetailType[] = await GiftCodeDetailModel.find({ giftCode: giftCode._id }).lean();
public static async checkHasUsed(roleId: string, id: number) {
let result = await GiftCodeDetailModel.exists({ giftId: id, 'record.roleId': roleId });
return result;
}
public static async increaseUsedNum(code: string) {
let result: GiftCodeDetailType = await GiftCodeDetailModel.findOneAndUpdate({ code }, { $inc: { usedNum: 1 } }, { new: true }).lean();
public static async findAllCodeByGiftId(id: number, cnt: number) {
let n = Math.ceil(cnt/1000);
let result: GiftCodeDetailType[] = [];
for(let i = 0; i < n; i++) {
let codes = await GiftCodeDetailModel.find({ giftId: id }).limit(1000).skip(i * 1000).sort({ _id: 1 }).lean();
result.push(...codes);
}
return result;
}
public static async generateOne(giftCode: GiftCodeType, code: string, uid = 1 ) {
let result = await GiftCodeDetailModel.insertMany([{ giftCode: giftCode._id, code, usedNum: 0, createdBy: uid, updatedBy: uid }]);
public static async increaseUsedNum(code: string, roleId: string, roleName: string, serverId: number) {
let result: GiftCodeDetailType = await GiftCodeDetailModel.findOneAndUpdate({ code }, {
$inc: { usedNum: 1 }, $push: { roleIds: roleId, record: { roleId, roleName, serverId, time: nowSeconds() } }
}, { new: true }).lean();
return result;
}
public static async generateMany(giftCode: GiftCodeType, generateNum: number, codeLen: number, uid = 1) {
public static async generateMany(giftCode: GiftCodeType, count = 1, uid = 1) {
let insertArr: GiftCodeDetailParam[] = [];
for(let i = 0; i < generateNum; i++) {
insertArr.push({ giftCode: giftCode._id, code: genCode(codeLen), usedNum: 0, createdBy: uid, updatedBy: uid });
for(let i = 0; i < count; i++) {
insertArr.push({
giftId: giftCode.id, giftName: giftCode.name, generateType: giftCode.generateType,
code: genCode(giftCode.codeLen), usedNum: 0, createdBy: uid, updatedBy: uid
});
}
let result = await GiftCodeDetailModel.insertMany(insertArr);
await GiftCodeModel.increateGenerateNum(giftCode.id, count);
return result;
}
private static getSearchObj(form: SearchGiftCodeDetailParam) {
let searchObj = {};
if(form.giftId) searchObj['giftId'] = form.giftId;
if (form.giftName != undefined) searchObj['giftName'] = { $regex: new RegExp(form.giftName.toString(), 'i') };
if(form.generateType) searchObj['generateType'] = form.generateType;
if(form.code) searchObj['code'] = form.code;
if(form.roleId) searchObj['record.roleId'] = form.roleId;
if (form.roleName != undefined) searchObj['record.roleName'] = { $regex: new RegExp(form.roleName.toString(), 'i') };
return searchObj
}
public static async findByCondition(page: number, pageSize: number, sortField: string, sortOrder: string, form:SearchGiftCodeDetailParam = {}) {
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: GiftCodeDetailType[] = await GiftCodeDetailModel.find(searchObj, { _id: 0 }).limit(pageSize).skip((page - 1) * pageSize).sort(sort).lean({ getters: true, virtuals: true });
return result;
}
public static async countByCondition(form: SearchGiftCodeDetailParam = {}) {
let searchObj = this.getSearchObj(form);
const result = await GiftCodeDetailModel.count(searchObj);
return result;
}

39
shared/db/Guild.ts
View File

@@ -5,6 +5,7 @@ import { GUILD_STRUCTURE, GUILD_STATUS, GUILD_PER_PAGE, GUILD_SELECT, REDIS_KEY,
import { getZeroPoint, getZeroPointD, nowSeconds } from '../pubUtils/timeUtil';
import { reduceCe } from '../pubUtils/util';
import { gameData } from '../pubUtils/data';
import { SearchGuildParam } from '../domain/backEndField/search';
class Structure {
@prop({ required: true })
@@ -132,7 +133,7 @@ export default class Guild extends BaseModel {
return result;
}
public static async findByCondition(page: number, showPeopleMax: boolean, name: string, serverId: number) {
public static async getGuildList(page: number, showPeopleMax: boolean, name: string, serverId: number) {
const condition = { status: GUILD_STATUS.RUNNING, serverId };
if(!showPeopleMax) {
condition['isMemberMax'] = false;
@@ -193,6 +194,7 @@ export default class Guild extends BaseModel {
public static async dismiss(code: string, serverId: number) {
const result: GuildType = await GuildModel.findOneAndUpdate({ code, status: GUILD_STATUS.RUNNING, serverId }, { status: GUILD_STATUS.DISMISSED }, { new: true })
.populate('leader', {roleId: 1, _id: 0}, 'Role')
.select('+members').lean();
return result;
}
@@ -277,6 +279,41 @@ export default class Guild extends BaseModel {
const role: RoleType = await GuildModel.findOneAndUpdate({ code, serverId }, { $set: { sdkMark: true } }, { new: true }).select(select).lean({ getters, virtuals: true });
return role;
}
private static getSearchObj(form: SearchGuildParam) {
let searchObj = {};
if (form.serverId) searchObj['serverId'] = form.serverId;
if (form.name) searchObj['name'] = { $regex: new RegExp(form.name.toString(), 'i') };
return searchObj
}
public static async findByCondition(page: number, pageSize: number, sortField: string = 'updatedAt', sortOrder: string = 'descend', form: SearchGuildParam = {}) {
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: GuildType[] = await GuildModel
.find(searchObj).limit(pageSize).skip((page - 1) * pageSize).sort(sort)
.select('-_id -__v -updatedAt +serverId')
.populate('leader', { roleId: 1, roleName: 1, _id: 0 }, 'Role')
.lean({ getters: true, virtuals: true });
return result;
}
public static async countByCondition(form: SearchGuildParam = {}) {
let searchObj = this.getSearchObj(form);
const result = await GuildModel.count(searchObj);
return result;
}
}
export const GuildModel = getModelForClass(Guild);

2
shared/db/HangUpRecord.ts
View File

@@ -57,7 +57,7 @@ export default class HangUpRecord extends BaseModel {
}
public static async updateRec(roleId: string, roleName: string, endLv: number, endTime: Date, needReceiveGoods: Array<{gid:number, count: number}>, lean = true) {
await HangUpRecordModel.findOneAndUpdate({roleId, received: false}, {endLv, endTime, received: true, notReceivedGoods: needReceiveGoods}).lean(lean);
await HangUpRecordModel.updateMany({roleId, received: false}, {endLv, endTime, received: true, notReceivedGoods: needReceiveGoods});
const recDoc = new HangUpRecordModel();
const update = Object.assign(recDoc.toJSON(), {roleId, roleName, startTime: endTime, startLv: endLv});
delete update._id;

46
shared/db/Hero.ts
View File

@@ -5,6 +5,7 @@ import { CounterModel } from './Counter';
import { COUNTER, EQUIP_TYPE, HERO_CE_RATIO } from '../consts';
import { reduceCe } from '../pubUtils/util';
import Skin from './Skin';
import { SearchHeroParam } from '../domain/backEndField/search';
type CeAttrUpdate = Partial<CeAttrData>;
export class CeAttrData {
@@ -300,20 +301,6 @@ export default class Hero extends BaseModel {
return hero;
}
public static async findByField(field: string, value?: number | string, lean = true) {
let searchObj = {};
if (field != 'all') {
if (field == 'roleName') {
searchObj['roleName'] = { $regex: new RegExp(value.toString(), 'i') }
} else {
searchObj[field] = value;
}
}
//.select('uid tel username')
const user: HeroType[] = await HeroModel.find(searchObj, {_id: 0}).lean(lean);
return user;
}
public static async getAllRank(serverId: number, select?: string, limit = 200) {
let result: HeroType[] = await HeroModel.find({ serverId }, { _id: false }).select(select).limit(limit).sort({ ce: -1, updatedAt: 1 }).lean({ getters: true });
return result;
@@ -328,6 +315,37 @@ export default class Hero extends BaseModel {
let result: HeroType[] = await HeroModel.find({ serverId, hid }, { _id: false }).select(select).limit(limit).lean({ getters: true });
return result;
}
private static getSearchObj(form: SearchHeroParam) {
let searchObj = {};
if(form.roleId) searchObj['roleId'] = form.roleId;
if(form.roleName) searchObj['roleName'] = { $regex: new RegExp(form.roleName.toString(), 'i') };
if(form.hid) searchObj['hid'] = form.hid;
return searchObj
}
public static async findByCondition(page: number, pageSize: number, sortField: string = 'updatedAt', sortOrder: string = 'descend', form: SearchHeroParam = {}) {
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: HeroType[] = await HeroModel.find(searchObj).limit(pageSize).skip((page - 1) * pageSize).sort(sort).lean({ getters: true, virtuals: true });
return result;
}
public static async countByCondition(form: SearchHeroParam = {}) {
let searchObj = this.getSearchObj(form);
const result = await HeroModel.count(searchObj);
return result;
}
}
export const HeroModel = getModelForClass(Hero);

36
shared/db/Item.ts
View File

@@ -2,6 +2,7 @@ import BaseModel from './BaseModel';
import { index, getModelForClass, prop, DocumentType, modelOptions } from '@typegoose/typegoose';
import { findIndex } from 'underscore';
import { BAG } from '../pubUtils/dicParam';
import { SearchItemParam } from '../domain/backEndField/search';
// const Transaction = require("mongoose-transactions");
@index({ roleId: 1, id: 1 })
@index({ seqId: 1 })
@@ -101,18 +102,35 @@ export default class Item extends BaseModel {
return result;
}
public static async findByField(field: string, value?: number|string, lean = true) {
private static getSearchObj(form: SearchItemParam) {
let searchObj = {};
if(field != 'all') {
if(field == 'roleName') {
searchObj['roleName'] = { $regex: new RegExp(value.toString(), 'i') }
} else {
searchObj[field] = value;
if (form.roleId) searchObj['roleId'] = form.roleId;
if (form.roleName) searchObj['roleName'] = { $regex: new RegExp(form.roleName.toString(), 'i') };
if (form.id) searchObj['id'] = form.id;
return searchObj
}
public static async findByCondition(page: number, pageSize: number, sortField: string = 'updatedAt', sortOrder: string = 'descend', form: SearchItemParam = {}) {
let searchObj = this.getSearchObj(form);
let sort = {};
if (sortField && sortOrder) {
if (sortOrder == 'ascend') {
sort[sortField] = 1;
} else if (sortOrder == 'descend') {
sort[sortField] = -1;
}
}
//.select('uid tel username')
const user: ItemType[] = await ItemModel.find(searchObj).lean(lean);
return user;
const result: ItemType[] = await ItemModel.find(searchObj).limit(pageSize).skip((page - 1) * pageSize).sort(sort).select('-_id -__v -createdAt -updatedAt').lean({ getters: true, virtuals: true });
return result;
}
public static async countByCondition(form: SearchItemParam = {}) {
let searchObj = this.getSearchObj(form);
const result = await ItemModel.count(searchObj);
return result;
}
}

16
shared/db/MailTemp.ts
View File

@@ -1,6 +1,5 @@
import BaseModel from './BaseModel';
import { prop, Ref, mongoose } from '@typegoose/typegoose';
import GMMail from './GMMail';
import { prop } from '@typegoose/typegoose';
class Reward {
@prop({ required: true })
@@ -12,10 +11,10 @@ class Reward {
export default class MailTemp extends BaseModel {
@prop({ required: true })
contentId: number; // dic_email_content.json中的id
gmmailId: string;
@prop({ ref: 'GMMail', type: mongoose.Schema.Types.ObjectId })
mail: Ref<GMMail>;
@prop({ required: true })
contentId: number; // dic_email_content.json中的id
@prop({ required: true })
sendTime: number;
@@ -23,12 +22,15 @@ export default class MailTemp extends BaseModel {
@prop({ required: true })
endTime: number;
@prop({ required: true, type: String, _id: false})
params: string[];
@prop({ required: true })
title: string; // 标题
@prop({ required: true })
sendName: string; // 发件人
@prop({ required: true })
content: string; // 内容
@prop({ required: true })
hasGoods: boolean;

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

107
shared/db/Marquee.ts
View File

@@ -1,36 +1,74 @@
import BaseModel from './BaseModel';
import { index, getModelForClass, prop, DocumentType, modelOptions } from '@typegoose/typegoose';
import { MARQUEE_TYPE } from '../consts';
import { index, getModelForClass, prop, DocumentType, modelOptions, ReturnModelType, mongoose } from '@typegoose/typegoose';
import { MARQUEE_SHOW_TYPE, MARQUEE_TIME_TYPE } from '../consts';
import { genCode } from '../pubUtils/util';
import { SearchMarqueeParam } from '../domain/backEndField/search';
import { nowSeconds } from '../pubUtils/timeUtil';
/**
* 跑马灯
**/
class Receiver {
@prop({ required: true })
regionId: number;
@prop({ required: true })
env: string;
@prop({ required: true })
serverId: number;
}
@modelOptions({ schemaOptions: { id: false } })
@index({ code: 1 })
export default class Marquee extends BaseModel {
@prop({ required: true })
code: string; // 跑马灯唯一标识
@prop({ required: true, type: Number })
serverIds: number[]; // 推送服务器
@prop({ required: true, enum: MARQUEE_TYPE })
type: MARQUEE_TYPE; // 推送类型
@prop({ required: true })
startTime: Date; // 活动开始时间
receiverType: number; // 推送目标
@prop({ required: true })
endTime: Date; // 活动结束时间
@prop({ required: true, type: Receiver, _id: false })
receivers: Receiver[]; // 推送服务器
@prop({ required: true })
interval: number; // 活动结束时间
@prop({ required: true, enum: MARQUEE_TIME_TYPE })
timeType: MARQUEE_TIME_TYPE; // 推送时间类型，立刻/定时
@prop({ required: true, enum: MARQUEE_SHOW_TYPE })
showType: MARQUEE_SHOW_TYPE; // 推送显示类型，一次性/循环
@prop({ required: true, default: 0 })
startTime: number; // 循环开始时间/定时开始时间
@prop({ required: true, default: 0 })
endTime: number; // 循环结束时间
@prop({ required: true, default: 0 })
interval: number; // 推送间隔
@prop({ required: true })
content: string; // 广播内容
@prop({ required: true })
isRunning: boolean; // 当前正在发布
@prop({ required: true, default: true })
isEnable: boolean; // 当前正在发布
setByForm(obj: any) {
this.code = obj.code;
this.receiverType = obj.receiverType;
this.receivers = obj.receivers;
this.timeType = obj.timeType;
this.showType = obj.showType;
if(this.timeType == MARQUEE_TIME_TYPE.INSTANT) {
this.startTime = nowSeconds();
} else {
this.startTime = obj.startTime;
}
if(this.showType == MARQUEE_SHOW_TYPE.CIRCLE) {
this.endTime = this.startTime + obj.continueMinute * 60;
this.interval = obj.interval;
}
this.content = obj.content;
}
/**
* 创建跑马灯
@@ -38,7 +76,7 @@ export default class Marquee extends BaseModel {
* @param uid 后台操作人
*/
public static async createData(params: MarqueeParam, uid = 1) {
const code = genCode(10);
const code = genCode(6);
const doc = new MarqueeModel();
const update = Object.assign(doc.toJSON(), params, { code, createdBy: uid, updatedBy: uid });
const result: MarqueeType = await MarqueeModel.findOneAndUpdate({ code }, { $setOnInsert: update }, { new: true, upsert: true }).lean();
@@ -69,21 +107,33 @@ export default class Marquee extends BaseModel {
/**
* 查询所有生效中的跑马灯
*/
public static async findEffectiveMarque() {
const result: MarqueeType[] = await MarqueeModel.find({ type: MARQUEE_TYPE.SCHEDULE, startTime: { $lte: new Date() }, endTime: { $gte: new Date() } }).lean();
public static async findEffectiveMarque(env: string) {
const result: MarqueeType[] = await MarqueeModel.find({
$or: [
{ showType: MARQUEE_SHOW_TYPE.CIRCLE, startTime: { $lte: nowSeconds() }, endTime: { $gte: nowSeconds() }},
{ showType: MARQUEE_SHOW_TYPE.ONCE, startTime: { $lte: nowSeconds() }}
],
isEnable: true,
'receivers.env': env
}).lean();
return result;
}
private static getSearchObj(form: { type?: number, current?: boolean, content?: string }) {
private static getSearchObj(form: SearchMarqueeParam) {
let searchObj = {};
if(form['type']) searchObj['type'] = form.type;
if(form['current']) searchObj['isRunning'] = form.current
if(form['content']) searchObj['content'] = { $regex: new RegExp(form.content.toString(), 'i') };
if(form.code) searchObj['code'] = form.code;
if(form.createdBy) searchObj['createdBy'] = form.createdBy
if(form.createTimeStart && form.createTimeEnd) {
searchObj['createdAt'] = { $gt: new Date(form.createTimeStart * 1000), $lt: new Date(form.createTimeEnd * 1000) };
}
if(form.sendTimeStart && form.sendTimeEnd) {
searchObj['startTime'] = { $gt: form.sendTimeStart, $lt: form.sendTimeEnd }
}
return searchObj
}
public static async findByCondition(page: number, pageSize: number, sortField: string = 'updatedAt', sortOrder: string = 'descend', form: { type?: number, current?: boolean, content?: string } = {}) {
public static async findByCondition(page: number, pageSize: number, sortField: string = 'updatedAt', sortOrder: string = 'descend', form: SearchMarqueeParam = {}) {
let searchObj = this.getSearchObj(form);
let sort = {};
@@ -94,12 +144,12 @@ export default class Marquee extends BaseModel {
sort[sortField] = -1;
}
}
const result: MarqueeType[] = await MarqueeModel.find(searchObj).limit(pageSize).skip((page - 1) * pageSize).sort(sort).select('+sort +showStartTime +showEndTime +serverType +isEnable').lean({ getters: true, virtuals: true });
const result: MarqueeType[] = await MarqueeModel.find(searchObj).limit(pageSize).skip((page - 1) * pageSize).sort(sort).lean({ getters: true, virtuals: true });
return result;
}
public static async countByCondition(form: { type?: number, current?: boolean, content?: string } = {}) {
public static async countByCondition(form: SearchMarqueeParam = {}) {
let searchObj = this.getSearchObj(form);
const result = await MarqueeModel.count(searchObj);
@@ -108,7 +158,12 @@ export default class Marquee extends BaseModel {
}
export const MarqueeModel = getModelForClass(Marquee);
export let MarqueeModel: ReturnModelType<typeof Marquee, {}>;
export function loadMarqueeModel(connect: mongoose.Connection) {
MarqueeModel = getModelForClass(Marquee, {
existingConnection: connect
});
}
export interface MarqueeType extends Pick<DocumentType<Marquee>, keyof Marquee> {};
export type MarqueeParam = Partial<MarqueeType>;

23
shared/db/Notice.ts
View File

@@ -2,7 +2,6 @@ import BaseModel from './BaseModel';
import { index, getModelForClass, prop, DocumentType, modelOptions } from '@typegoose/typegoose';
import { COUNTER } from '../consts'
import { CounterModel } from './Counter';
import moment = require('moment');
/**
* 游戏字段接口
@@ -23,17 +22,7 @@ export default class Notice extends BaseModel {
content: string; // 公告内容
@prop({ required: true })
timeStr: string; // 时间显示
@prop({ required: true })
startTime: Date; // 活动开始时间
@prop({ required: true })
endTime: Date; // 活动结束时间
public get time() {
let startTime = moment(this.startTime).format('YYYY/MM/DD');
let endTime = moment(this.endTime).format('YYYY/MM/DD');
return this.timeStr.replace(/%startTime/g, startTime).replace(/%endTime/g, endTime);
}
time: string; // 时间显示
@prop({ required: true, select: false })
sort: number;
@@ -42,15 +31,14 @@ export default class Notice extends BaseModel {
showStartTime: Date;
@prop({ required: true, select: false })
showEndTime: Date;
@prop({ required: true, select: false })
serverType: string; // 服务器类型
@prop({ required: true, select: false })
isEnable: boolean;
public static async getAllNotice(serverType: string) {
public static async getAllNotice() {
let curTime = new Date();
let notices: NoticeType[] = await NoticeModel.find({ showStartTime: { $lte: curTime }, showEndTime: { $gte: curTime }, isEnable: true, serverType })
let notices: NoticeType[] = await NoticeModel.find({ showStartTime: { $lte: curTime }, showEndTime: { $gte: curTime }, isEnable: true })
.sort({ sort: -1, createTime: -1 })
.lean({ virtuals: true });
return notices;
@@ -73,7 +61,6 @@ export default class Notice extends BaseModel {
private static getSearchObj(form: { type?: number, content?: string }) {
let searchObj = {};
if(form['type']) searchObj['type'] = form.type;
if(form['content']) searchObj['content'] = { $regex: new RegExp(form.content.toString(), 'i') };
return searchObj
}
@@ -89,7 +76,7 @@ export default class Notice extends BaseModel {
sort[sortField] = -1;
}
}
const result: NoticeType[] = await NoticeModel.find(searchObj).limit(pageSize).skip((page - 1) * pageSize).sort(sort).select('+sort +showStartTime +showEndTime +serverType +isEnable').lean({ getters: true, virtuals: true });
const result: NoticeType[] = await NoticeModel.find(searchObj).limit(pageSize).skip((page - 1) * pageSize).sort(sort).select('+sort +showStartTime +showEndTime +isEnable').lean({ getters: true, virtuals: true });
return result;
}

3
shared/db/RScriptRecord.ts
View File

@@ -41,6 +41,9 @@ export default class RScriptRecord extends BaseModel {
return items;
}
public static async deleteByWarType(roleId: string, warType: number) {
return await RScriptRecordModel.deleteMany({ roleId, warType });
}
public static async deleteByWarId(roleId: string, battleId: number[]) {
return await RScriptRecordModel.deleteMany({ roleId, battleId: { $in: battleId } });
}

94
shared/db/Region.ts Normal file
View File

@@ -0,0 +1,94 @@
import { COUNTER } from './../consts';
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';
/**
* 大区数据
*/
@index({ id: 1 })
export default class Region extends BaseModel {
@prop({ required: true })
id: number; // 大区id
@prop({ required: true })
name: string; // 大区名
@prop({ required: true })
prefix: string; // 区名前缀
@prop({ required: true })
env: string; // 环境变量
@prop({ required: true })
gmLink: string; // 短链接地址
@prop({ required: true })
gameHost: string; // 长链接地址
@prop({ required: true })
gmPort: number; // 长链接地址
@prop({ required: true })
latestServer: number; // 最新服
@prop({ required: true })
latestServerUniqId: number; // 最新服唯一id
@prop({ required: true })
serverCount: number; // 总数
@prop({ required: true })
remark: string; // 备注
@prop({ required: true, type: () => ServerStategy, _id: false })
stategy: ServerStategy; // 策略配置
public static async createNewRegion(params: RegionUpdate, uid = 1) {
let id = await CounterModel.getNewCounter(COUNTER.REGION);
const rec: RegionType = await RegionModel.findOneAndUpdate({ id }, { $setOnInsert: { ...params, createdBy: uid}, $set: { updatedBy: uid } }, { new: true, upsert: true }).lean();
return rec;
}
public static async updateRegion(id: number, params: RegionUpdate, uid = 1) {
const rec: RegionType = await RegionModel.findOneAndUpdate({ id }, { $set: { ...params, updatedBy: uid } }, { new: true }).lean();
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;
}
public static async findRegionById(id: number) {
const rec: RegionType = await RegionModel.findOne({ id }).select('-_id').lean();
return rec;
}
public static async findRegionByEnv(env: string) {
const rec: RegionType = await RegionModel.findOne({ env }).select('-_id').lean();
return rec;
}
}
export let RegionModel: ReturnModelType<typeof Region, {}>;
export function loadRegionModel(connect: mongoose.Connection) {
RegionModel = getModelForClass(Region, {
existingConnection: connect
});
}
export interface RegionType extends Pick<DocumentType<Region>, keyof Region> { };
export type RegionUpdate = Partial<RegionType>; // 将所有字段变成可选项

63
shared/db/RegionWhiteList.ts Normal file
View File

@@ -0,0 +1,63 @@
import BaseModel from './BaseModel';
import { prop, DocumentType, getModelForClass } from '@typegoose/typegoose';
import { WHITE_LIST_TYPE } from '../consts';
export default class RegionWhiteList extends BaseModel {
@prop({ required: true })
code: string; // 编码
@prop({ required: true })
regionId: number; // 大区区号
@prop({ required: true })
env: string; // 环境变量
@prop({ required: true, enum: WHITE_LIST_TYPE })
type: WHITE_LIST_TYPE; // 环境变量
@prop({ required: true })
ip: string; // ip
@prop({ required: true })
serverId: number; // 小区id
@prop({ required: true })
uid: number; // 玩家uid
@prop({ required: true })
roleId: string; // 玩家角色id
@prop({ required: true })
roleName: string; // 玩家角色名
public static async checkIp(env: string, ip: string) {
const rec = await WhiteListModel.exists({ env, ip });
return rec;
}
public static async checkUid(env: string, serverId: number, uid: number) {
const rec = await WhiteListModel.exists({ env, serverId, uid });
return rec;
}
public static async findByRegionId(regionId: number) {
const rec: WhiteListModelType[] = await WhiteListModel.find({ regionId });
return rec;
}
public static async updateWhiteList(code: string, params: WhiteListModelTypeParam) {
const rec: WhiteListModelType = await WhiteListModel.findOneAndUpdate({ code }, params, { new: true, upsert: true }).lean();
return rec;
}
public static async deleteWhiteList(code: string) {
const rec: WhiteListModelType = await WhiteListModel.findOneAndDelete({ code }).lean();
return rec;
}
}
export let WhiteListModel = getModelForClass(RegionWhiteList)
export interface WhiteListModelType extends Pick<DocumentType<RegionWhiteList>, keyof RegionWhiteList> { }
export type WhiteListModelTypeParam = Partial<WhiteListModelType>; // 将所有字段变成可选项

63
shared/db/Role.ts
View File

@@ -1,4 +1,4 @@
import { ROLE_TERAPH, ROLE_SELECT, ABI_TYPE, HERO_CE_RATIO } from './../consts';
import { ROLE_TERAPH, ROLE_SELECT, ABI_TYPE, HERO_CE_RATIO, BLOCK_TYPE } from './../consts';
import BaseModel from './BaseModel';
import { index, getModelForClass, prop, DocumentType, Ref, mongoose } from '@typegoose/typegoose';
import User from './User';
@@ -7,6 +7,7 @@ import { nowSeconds, getTimeFunD } from '../pubUtils/timeUtil';
import { Figure } from '../domain/dbGeneral';
import * as dicParam from '../pubUtils/dicParam';
import Hero from './Hero';
import { SearchRoleParam } from '../domain/backEndField/search';
type CeAttrUpdate = Partial<CeAttrDataRole>;
// role表属性格式
@@ -146,8 +147,10 @@ export default class Role extends BaseModel {
serverType: string; // 服务器类型
@prop({ required: true })
serverId: number; // 区服 id
@prop({ required: true, default: false })
blocked: boolean; // 是否屏蔽
@prop({ required: true, default: 0 })
blockType: BLOCK_TYPE; // 封禁类型 1-封言 2-封禁
@prop({ required: true, default: '' })
blockReason: string; // 封禁理由
@prop({ required: true })
code: string; // 邀请码
@prop({ required: true, default: false })
@@ -359,6 +362,15 @@ export default class Role extends BaseModel {
const role: RoleType = await RoleModel.findOne({ roleId }).select(select).lean({ getters, virtuals });
return role;
}
public static async findByRoleIds(roleIds: string[], select?: string, getters = false, virtuals = true) {
const role: RoleType[] = await RoleModel.find({ roleId: { $in: roleIds } }).select(select).lean({ getters, virtuals });
return role;
}
public static async findByRoleName(roleName: string, select?: string, getters = false, virtuals = true) {
const role: RoleType = await RoleModel.findOne({ roleName }).select(select).lean({ getters, virtuals });
return role;
}
public static async createRole(uid: number, serverId: number, roleInfo: { roleId: string; roleName: string; seqId: number; code: string, lv?: number, exp?: number }, lean = true) {
const user = await User.findUserByUid(uid);
@@ -370,19 +382,6 @@ export default class Role extends BaseModel {
return role;
}
public static async findRoleByField(field: string, value?: Array<number | string>, select?: string, getters = false) {
let searchObj = {};
if (field != 'all') {
searchObj[field] = {
$in: value
};
}
const user: RoleType[] = await RoleModel.find(searchObj).select(select).lean({ getters, virtuals: true });
return user;
}
public static async setEventStatus(roleId: string, eventStatus: number, lean = true) {
let role: RoleType = await RoleModel.findOneAndUpdate({ roleId }, { eventStatus }, { new: true }).lean(lean);
return role;
@@ -742,6 +741,38 @@ export default class Role extends BaseModel {
return role;
}
private static getSearchObj(form: SearchRoleParam) {
let searchObj = {};
if(form.uid) searchObj['userInfo.uid'] = form.uid;
if(form.roleId) searchObj['roleId'] = form.roleId;
if(form.roleName) searchObj['roleName'] = { $regex: new RegExp(form.roleName.toString(), 'i') };
return searchObj
}
public static async findByCondition(page: number, pageSize: number, sortField: string = 'updatedAt', sortOrder: string = 'descend', form: SearchRoleParam = {}) {
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: RoleType[] = await RoleModel.find(searchObj).limit(pageSize).skip((page - 1) * pageSize).sort(sort).lean({ getters: true, virtuals: true });
return result;
}
public static async countByCondition(form: SearchRoleParam = {}) {
let searchObj = this.getSearchObj(form);
const result = await RoleModel.count(searchObj);
return result;
}
}
export const RoleModel = getModelForClass(Role);

149
shared/db/ServerStategy.ts
View File

@@ -1,91 +1,84 @@
import BaseModel from './BaseModel';
import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
import { CounterModel } from './Counter';
import { COUNTER } from '../consts';
import { prop, DocumentType, } from '@typegoose/typegoose';
import { GM_MAIL_TYPE, MAIL_TIME_TYPE } from '../consts';
/**
* 开服策略
*/
@index({ id: 1 })
class Reward {
@prop({ required: true })
id: number;
@prop({ required: true })
count: number;
}
export default class ServerStategy extends BaseModel {
@prop({ required: true })
id: number; // 策略唯一id
@prop({ required: true })
name: string; // 策略名
export class GMMail {
@prop({ required: false})
hasGoods: boolean; // 有效时间，单位小时
@prop({ required: true, type: Reward, default: [], _id: false })
goods: Reward[];
@prop({ required: true, default: true })
timeType: MAIL_TIME_TYPE; // 邮件时间类型
@prop({ required: false})
expire: number; // 有效时间，单位小时
@prop({ required: true })
circleContinueDay: number; // 循环邮件持续天数
@prop({ required: true })
circleDay: number; // 循环时间，每周几，0表示每天
@prop({ required: true })
circleHour: string; // 几点发送
@prop({ required: true })
title: string;
@prop({ required: true })
content: string;
@prop({ required: true })
sendName: string;
@prop({ required: true })
mailType: GM_MAIL_TYPE; // 收件人类型
@prop({ required: true })
reason: string; // 原因
@prop({ required: true, default: false })
isSp: boolean; // 特殊邮件
}
export default class ServerStategy {
@prop({ required: true, default: false })
isDefault: boolean; // 是否是自动开服默认使用的策略
@prop({ required: true, default: 0 })
maxPlayerCnt: number; // 人数上限
@prop({ required: true, default: 0, type: Number })
timers: number[]; // 开服时间点
@prop({ required: true, type: Number })
activityGroupId: number[]; // 选择活动组
@prop({ required: true, type: Number })
mails: number[]; // 选择邮件模板
@prop({ required: true, type: Number })
marquees: number[]; // 选择跑马灯
@prop({ required: true, type: Number })
notices: number[]; // 选择公告
public static async findBySId(id: number) {
const result: ServerStategyType = await ServerStategyModel.findOne({ id }, { _id: 0 }).lean({ getters: true, virtuals: true });
return result;
@prop({ required: true, type: GMMail, _id: false })
openMail: GMMail;
}
@prop({ required: true, type: GMMail, _id: false })
circleMail: GMMail;
@prop({ required: true, default: 0 })
stopRegisterTime: number; // 关闭注册时间
private static getSearchObj(form: { id?: number, name?: string, isDefault?: boolean }) {
let searchObj = {};
if (form.id != undefined) searchObj['id'] = form.id;
if (form.name != undefined) searchObj['name'] = { $regex: new RegExp(form.name.toString(), 'i') };
if (form.isDefault != undefined) searchObj['isDefault'] = form.isDefault;
return searchObj
}
public static async findByCondition(page: number, pageSize: number, sortField: string, sortOrder: string, form: { id?: number, name?: string, isDefault?: 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: ServerStategyType[] = await ServerStategyModel.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, name?: string, isDefault?: boolean } = {}) {
let searchObj = this.getSearchObj(form);
const result = await ServerStategyModel.count(searchObj);
return result;
}
private static async unsetDefault() {
const rec = await ServerStategyModel.updateMany({ isDefault: true }, { $set: { isDefault: false } });
return rec;
}
public static async updateServerStategy(values: ServerStategyTypeParam & {id: string|number}, uid = 1) {
let id = values.id;
if(id == 'new') {
id = await CounterModel.getNewCounter(COUNTER.SERVER_STATEGY);
}
if(values.isDefault) {
await this.unsetDefault();
}
delete values.id;
let rec: ServerStategyType = await ServerStategyModel.findOneAndUpdate({ id }, { $set: {...values, updatedBy: uid}, $setOnInsert: { createdBy: uid } },
{ new: true, upsert: true }).lean(true);
return rec;
constructor(stategy: ServerStategyUpdate & { hasOpenMail: boolean, hasCircleMail: boolean}) {
this.maxPlayerCnt = stategy.maxPlayerCnt;
this.timers = stategy.timers;
this.activityGroupId = stategy.activityGroupId;
this.stopRegisterTime = stategy.stopRegisterTime;
if(stategy.hasCircleMail) this.circleMail = stategy.circleMail;
if(stategy.hasOpenMail) this.openMail = stategy.openMail;
}
}
export const ServerStategyModel = getModelForClass(ServerStategy);
export interface ServerStategyType extends Pick<DocumentType<ServerStategy>, keyof ServerStategy> { }
export type ServerStategyTypeParam = Partial<ServerStategyType>; // 将所有字段变成可选项
export interface ServerStategyType extends Pick<DocumentType<ServerStategy>, keyof ServerStategy> { };
export type ServerStategyUpdate = Partial<ServerStategyType>; // 将所有字段变成可选项

185
shared/db/Serverlist.ts
View File

@@ -1,25 +1,49 @@
import BaseModel from './BaseModel';
import { index, getModelForClass, prop, DocumentType, modelOptions } from '@typegoose/typegoose';
import { GameModel } from './Game';
import { CounterModel } from './Counter';
import { index, getModelForClass, prop, DocumentType, modelOptions, ReturnModelType, mongoose } from '@typegoose/typegoose';
import { CounterAllModal } from './CounterAll';
import { COUNTER, SERVER_STATUS } from '../consts';
import { ServerStategyTypeParam } from './ServerStategy';
import { getServerName, getServerGroupName } from '../pubUtils/data';
import { CreateServerParam } from '../domain/backEndField/params';
import { RegionType } from './Region';
import { nowSeconds } from '../pubUtils/timeUtil';
import { gameData } from '../pubUtils/data';
// 暂时服务器列表是从game表取的，之后会转移到使用这张表，目前用作查询该服战力中位数
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 {
@prop({ required: true, default: 1 })
gameId: number; // 游戏id Game表的id
regionId: number; // 大区id
@prop({ required: true })
id: number; // 小区id 自增
env: string; // 环境变量
@prop({ required: true })
prefix: string; // 前缀
@prop({ required: true })
id: number; // 小区id 自增，全大区共用自增counter，玩家role表中存的就是这个serverId
@prop({ required: true })
serverId: number; // 相同serverType下的id，不同serverType下id一定不同，但是serverId可能相同
@@ -28,16 +52,10 @@ export default class Serverlist extends BaseModel {
name: string; // 小区区名
@prop({ required: true })
groupId: number; // 大区id
groupId: number; // 战区id
@prop({ required: true })
groupName: string; // 大区区名
@prop({ required: true })
host: string; // pinus连接地址
@prop({ required: false, default: 3014 })
port: number; // pinus端口
groupName: string; // 战区区名
@prop({ required: true, default: 1, enum: SERVER_STATUS })
serverStatus: number; // 服务器状态
@@ -46,38 +64,57 @@ export default class Serverlist extends BaseModel {
activityGroupId: number[]; // 活动组
public get status() {
let now = new Date();
if (now > this.openTime) {
return this.serverStatus;
let now = nowSeconds();
if (now < this.openTime) {
return SERVER_STATUS.WILL_OPEN;
} else if (this.maintenance && this.maintenance.isOpen && this.maintenance.startTime < now && this.maintenance.endTime > now) {
return SERVER_STATUS.MAINTENANCE;
} else {
return SERVER_STATUS.WILL_OPEN; // 未开服
return this.serverStatus; // 未开服
}
}
@prop({ required: true })
openTime: Date;
openTime: number;
@prop({ required: true })
serverType: string;
stopRegisterTime: number;
@prop({ required: true, default: true })
canRegister: boolean;
@prop({ required: true, default: 0 })
maxPlayerCnt: number; // 最大玩家人数
playerCnt: number; // 当前玩家人数
@prop({ required: true, default: 0 })
medianCe: number; // 中位数武将战力、缩小10000倍后的结果
@prop({ required: true, type: Maintenance, _id: false })
maintenance: Maintenance
public static async getAllServerList() {
let servers: ServerlistType[] = await ServerlistModel.find().lean({ getters: true, virtuals: true });
return servers;
let id = await CounterAllModal.getCounter(COUNTER.SERVER);
let result: ServerlistType[] = [];
let n = Math.ceil(id/1000);
for(let i = 0; i < n; i++) {
let servers: ServerlistType[] = await ServerlistModel.find().limit(1000).skip(i * 1000).lean({ getters: true, virtuals: true });
result.push(...servers);
}
return result;
}
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;
}
public static async findByServerIds(serverIds: number[]) {
let servers: ServerlistType[] = await ServerlistModel.find({ id: { $in: serverIds } }).select('medianCe activityGroupId').lean({ getters: true, virtuals: true });
return servers;
}
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;
}
@@ -86,81 +123,33 @@ 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: { serverType: string, openTime: Date, name?: string }, stategy: ServerStategyTypeParam, uid = 1 ) {
let { serverType, name } = params;
let serverEnvs = await GameModel.getServerEnvList();
let curEnv = serverEnvs.find(cur => cur.serverType == serverType);
if(!curEnv) return false;
let { gameHost: host } = curEnv;
public static async newServer(params: CreateServerParam, region: RegionType, serverId: number, uid = 1 ) {
let dicServerName = gameData.serverNames.get(serverId);
let { prefix, id: regionId, env } = region;
// 分大区
let groupId = await CounterModel.getCounter(COUNTER.SERVER_GROUP);
let groupServerCount = await ServerlistModel.countByCondition({ serverType, groupId });
if(groupServerCount > 10) {
groupId = await CounterModel.getNewCounter(COUNTER.SERVER_GROUP);
}
let groupName = getServerGroupName(groupId)||"";
let serverId = await CounterModel.getNewCounter({ name: `${COUNTER.SERVER_BY_TYPE.name}_${serverType}`, def: COUNTER.SERVER_BY_TYPE.def });
let id = await CounterModel.getNewCounter(COUNTER.SERVER);
if(!name) name = getServerName(id)||"";
let id = await CounterAllModal.getNewCounter(COUNTER.SERVER);
let { openTime, stopRegisterTime: hour, activityGroupId } = params;
let { sname: name, groupId, groupName } = dicServerName;
let stopRegisterTime = openTime + hour * 60 * 60;
const doc = new ServerlistModel();
const update = Object.assign(doc.toJSON(), params, { id, serverId, host, groupId, groupName, name, createdBy: uid, updatedBy: uid }, { activityGroupId: stategy.activityGroupId, maxPlayerCnt: stategy.maxPlayerCnt});
const update = Object.assign(doc.toJSON(), {
id, regionId, env, prefix,
serverId, name, groupId, groupName, activityGroupId,
openTime, stopRegisterTime,
createdBy: uid, updatedBy: uid
});
// 旧服修改状态
await ServerlistModel.updateMany({ env, serverStatus: SERVER_STATUS.NEW }, { $set: { serverStatus: SERVER_STATUS.HOT } })
let server: ServerlistType = await ServerlistModel.findOneAndUpdate({ id }, { $setOnInsert: update }, { new: true, upsert: true }).lean({ getters: true, virtuals: true });
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();
@@ -181,9 +170,19 @@ export default class Serverlist extends BaseModel {
return result;
}
public static async incRoleCnt(serverId: number) {
let server: ServerlistType = await ServerlistModel.findOneAndUpdate({ serverId }, { $inc: { playerCnt: 1 } });
return server;
}
}
export const ServerlistModel = getModelForClass(Serverlist);
export let ServerlistModel: ReturnModelType<typeof Serverlist, {}>;
export function loadServerlistModel(connect: mongoose.Connection) {
ServerlistModel = getModelForClass(Serverlist, {
existingConnection: connect
});
}
export interface ServerlistType extends Pick<DocumentType<Serverlist>, keyof Serverlist> {
id: number;

12
shared/db/TowerRecord.ts
View File

@@ -1,5 +1,6 @@
import BaseModel from './BaseModel';
import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
import { gameData } from '../pubUtils/data';
class WarStatus {
@prop({ required: true })
@@ -86,6 +87,17 @@ export default class TowerRecord extends BaseModel {
return rec;
}
public static async insertTowerRec(roleId: string, lv: number) {
let insertParams = [];
let doc = new TowerRecordModel();
for(let [towerLv, { warArray }] of gameData.tower) {
if(towerLv < lv) {
insertParams.push({...doc.toJSON(), roleId, lv: towerLv, warStatus: warArray.map(warId => ({ warId, status: true })), passed: true})
} else if (towerLv == lv) {
insertParams.push({...doc.toJSON(), roleId, lv: towerLv, warStatus: warArray.map(warId => ({ warId, status: true })), passed: false})
}
}
}
public static async deleteAccount(roleId: string) {
let result = await TowerRecordModel.deleteMany({roleId});

49
shared/db/User.ts
View File

@@ -4,6 +4,7 @@ import BaseModel from './BaseModel';
import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
import { genCode, aesEncryptcfb, aesDecryptcfb } from '../pubUtils/util';
import { LoginValidateData37, ChannelInfo } from '../domain/sdk';
import { SearchUserParam } from '../domain/backEndField/search';
const bcrypt = require('bcrypt');
const SALT_WORK_FACTOR = 5
@@ -43,7 +44,7 @@ export default class User extends BaseModel {
@prop({ required: true, _id: false })
channelInfo: LoginValidateData37|{}; // 渠道数据
@prop({ required: true, set: (val: string) => aesEncryptcfb(val, ENCRYPT_KEY, ENCRYPT_IV), get: (val: string) => aesDecryptcfb(val, ENCRYPT_KEY, ENCRYPT_IV) })
@prop({ required: true, set: (val: string) => aesEncryptcfb(val, ENCRYPT_KEY, ENCRYPT_IV), get: (val: string) => val?aesDecryptcfb(val, ENCRYPT_KEY, ENCRYPT_IV):'' })
tel: string; // 账号
@prop({ required: true, default: '' })
@@ -107,10 +108,6 @@ export default class User extends BaseModel {
@prop({ required: true, default: false })
blocked: boolean;
// 用户权限：0-普通用户，1-测试用户
@prop({ required: true, default: 0 })
auth: number;
// 个推CID
@prop({ required: false, default: "" })
getuiCID: string;
@@ -279,21 +276,41 @@ export default class User extends BaseModel {
return user;
}
public static async findUserByField(field: string, value?: Array<number | string>) {
let searchObj = {};
if (field != 'all') {
searchObj[field] = {
$in: value
};
}
const user: UserType[] = await UserModel.find(searchObj).select('uid tel username serverType auth').lean({ getters: true });
public static async updatePlayTime(userCode: string, isGuest: boolean, todayPlayTime: number, playTime: number) {
const user: UserType = await UserModel.findOneAndUpdate({ userCode }, { $set: { guestTime: isGuest?playTime: 0, todayPlayTime: todayPlayTime, playTime } }, { new: true }).lean({ getters: true });
return user;
}
public static async updatePlayTime(userCode: string, isGuest: boolean, todayPlayTime: number, playTime: number) {
const user: UserType = await UserModel.findOneAndUpdate({ userCode }, { $set: { guestTime: isGuest?playTime: 0, todayPlayTime: todayPlayTime, playTime } }, { new: true }).lean({ getters: true });
return user;
private static getSearchObj(form: SearchUserParam) {
let searchObj = {};
if(form['uid']) searchObj['uid'] = form.uid;
if(form['tel']) searchObj['tel'] = form.tel;
if(form.channelType && form.channelType != 'normal') searchObj['channelType'] = form.channelType;
return searchObj
}
public static async findByCondition(page: number, pageSize: number, sortField: string = 'updatedAt', sortOrder: string = 'descend', form: SearchUserParam = {}) {
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: UserType[] = await UserModel.find(searchObj).limit(pageSize).skip((page - 1) * pageSize).sort(sort).select('-_id -__v -password -salt -token').lean({ getters: true, virtuals: true });
return result;
}
public static async countByCondition(form: SearchUserParam = {}) {
let searchObj = this.getSearchObj(form);
const result = await UserModel.count(searchObj);
return result;
}
}

36
shared/db/UserGiftCode.ts
View File

@@ -1,36 +0,0 @@
import BaseModel from './BaseModel';
import { index, getModelForClass, prop, DocumentType, modelOptions, Ref, mongoose } from '@typegoose/typegoose';
import GiftCode, { GiftCodeType } from './GiftCode';
/**
* 举报记录
**/
@modelOptions({ schemaOptions: { id: false } })
@index({ roleId: 1, code: 1 })
export default class UserGiftCode extends BaseModel {
@prop({ required: true, default: '' })
roleId: string; // 玩家id
@prop({ required: true, default: '' })
code: string; // 兑换码
@prop({ ref: 'GiftCode', type: mongoose.Schema.Types.ObjectId })
giftCode: Ref<GiftCode>;
// 根据code
public static async findByCode(roleId: string, code: string) {
let result: UserGiftCodeType = await UserGiftCodeModel.findOne({ roleId, code }).lean();
return result;
}
public static async createCode(roleId: string, code: string, gitCode: GiftCodeType) {
let result: UserGiftCodeType = await UserGiftCodeModel.findOneAndUpdate({ roleId, code }, { $setOnInsert: { gitCode: gitCode._id } }, { new: true, upsert: true}).lean()
return result;
}
}
export const UserGiftCodeModel = getModelForClass(UserGiftCode);
export interface UserGiftCodeType extends Pick<DocumentType<UserGiftCode>, keyof UserGiftCode> { }
export type UserGiftCodeParam = Partial<UserGiftCodeType>;

27
shared/db/WhiteList.ts
View File

@@ -1,27 +0,0 @@
import BaseModel from './BaseModel';
import { prop, DocumentType, getModelForClass } from '@typegoose/typegoose';
import { WHITE_LIST_TYPE } from '../consts';
export default class WhiteList extends BaseModel {
@prop({ required: true, enum: WHITE_LIST_TYPE })
type: WHITE_LIST_TYPE; // 区号
@prop({ required: true })
str: string; // ip或手机号
public static async checkIp(ip: string) {
const rec: WhiteListModelType = await WhiteListModel.findOne({ type: WHITE_LIST_TYPE.IP, str: ip }).lean();
return rec;
}
public static async checkTel(tel: string) {
const rec: WhiteListModelType = await WhiteListModel.findOne({ type: WHITE_LIST_TYPE.TEL, str: tel }).lean();
return rec;
}
}
export const WhiteListModel = getModelForClass(WhiteList);
export interface WhiteListModelType extends Pick<DocumentType<WhiteList>, keyof WhiteList> { }
export type WhiteListModelTypeParam = Partial<WhiteListModelType>; // 将所有字段变成可选项

11
shared/db/index.ts
View File

@@ -4,11 +4,22 @@ import { loadGMGroupModel } from "./GMGroup";
import { loadGMRecordModel } from "./GMRecord";
import { loadGMUserModel } from './GMUser'
import { loadGMUserGroupModel } from "./GMUserGroup";
import { loadRegionModel } from "./Region";
import { loadServerlistModel } from "./Serverlist";
import { loadGMMailModel } from './GMMail';
import { loadCounterModal } from "./CounterAll";
import { loadMarqueeModel } from "./Marquee";
export function loadGmDb(connect: mongoose.Connection) {
// console.log('************')
loadApiModel(connect);
loadGMGroupModel(connect);
loadGMUserModel(connect);
loadGMUserGroupModel(connect);
loadGMRecordModel(connect);
loadRegionModel(connect);
loadServerlistModel(connect);
loadGMMailModel(connect);
loadCounterModal(connect);
loadMarqueeModel(connect);
}

265
shared/domain/backEndField/params.ts Normal file
View File

@@ -0,0 +1,265 @@
import { GIFT_GENERATE_TYPE, GM_MAIL_TYPE, MAIL_TIME_TYPE, SERVER_TIMER } from "../../consts";
import { isArray, isNumber, isString } from 'underscore';
import ServerStategy, { GMMail } from "../../db/ServerStategy";
import { RegionType } from "../../db/Region";
import { RewardInter } from "../../pubUtils/interface";
import { isTimestamp } from '../../pubUtils/util';
export class UpdateMailParams {
hasGoods: boolean = false; // 是否有道具
goods: {id: number; count: number}[];
timeType: MAIL_TIME_TYPE; // 邮件时间类型
expire: number; // 有效时间，单位小时
startTime: number; // 发送时间，延时邮件使用
circleStart: number; // 循环邮件开始循环时间
circleEnd: number; // 循环邮件结束循环时间
circleDay: number; // 循环时间，每周几，0表示每天
circleHour: string; // 几点发送
title: string;
content: string;
sendName: string;
mailType: GM_MAIL_TYPE; // 收件人类型
receivers: {env: string; serverId: number; roleId: string; roleName: string; }[];
reason: string; // 原因
isSp: boolean = false; // 特殊邮件
isSingle: boolean;
constructor(obj: UpdateMailParams) {
this.goods = obj.goods;
this.hasGoods = obj.goods?.length > 0;
this.timeType = obj.timeType;
this.expire = obj.expire;
this.startTime = obj.startTime;
this.circleStart = obj.circleStart;
this.circleEnd = obj.circleEnd;
this.circleDay = obj.circleDay;
this.circleHour = obj.circleHour;
this.title = obj.title;
this.content = obj.content;
this.sendName = obj.sendName;
if(obj.isSingle == true) {
this.mailType = GM_MAIL_TYPE.SINGLE;
} else if (obj.isSingle == false) {
this.mailType = GM_MAIL_TYPE.SERVER;
}
this.receivers = obj.receivers;
this.reason = obj.reason;
}
checkParams() {
if(!this.title || !this.content || !this.sendName || !this.reason) return false;
if(this.timeType == MAIL_TIME_TYPE.IMMEDIATE) {
if(!this.expire) return false;
} else if (this.timeType == MAIL_TIME_TYPE.DELAY) {
if(!this.expire || !this.startTime) return false;
} else if (this.timeType == MAIL_TIME_TYPE.CIRCLE) {
if(!this.expire || !this.circleStart || !this.circleEnd || this.circleDay == undefined || !this.circleHour)
return false;
}
if(!this.receivers || !isArray(this.receivers)) return false;
if(!this.mailType) return false;
for(let { serverId, roleId, roleName } of this.receivers) {
if(!serverId) return false;
if(this.mailType == GM_MAIL_TYPE.SINGLE||this.mailType == GM_MAIL_TYPE.GROUP) {
if(!roleId || !roleName) return false;
}
}
return true;
}
}
export class UpdateRegionParams {
id: number|'new' = 0; // 大区id
name: string = ''; // 大区名
prefix: string = ''; // 区名前缀
remark: string = '';
maxPlayerCnt: number = 0;
timers: SERVER_TIMER[] = [];
activityGroupId: number[] = [];
openMail?: GMMail;
circleMail?: GMMail;
stopRegisterTime: number = 0;
hasOpenMail: boolean = false;
hasCircleMail: boolean = false;
constructor(obj: UpdateRegionParams) {
for(let key in obj) {
this[key] = obj[key];
}
}
checkParams() {
if(!this.id || !this.name || !this.prefix || !this.maxPlayerCnt || !isArray(this.timers) || this.timers.length <= 0 || !isArray(this.activityGroupId) || this.activityGroupId.length <= 0 ) {
return false
}
return true;
}
getUpdateParam(oldRegion?: RegionType) {
if(!oldRegion) {
let stategy = new ServerStategy(this);
return {
name: this.name,
prefix: this.prefix,
remark: this.remark,
stategy
}
} else {
let stategy = new ServerStategy(this);
return {
name: this.name||oldRegion.name,
prefix: this.prefix||oldRegion.prefix,
remark: this.remark||oldRegion.remark,
stategy: { ...(oldRegion.stategy||{}), ...stategy }
}
}
}
}
export class CreateServerParam {
env: string = '';
openTime: number = 0;
activityGroupId: number[] = [];
hasOpenMail: boolean = false;
openMail?: GMMail;
hasCircleMail: boolean = false;
circleMail?: GMMail;
stopRegisterTime: number = 0;
constructor(obj?: any) {
if(obj) {
for(let key in obj) {
this[key] = obj[key];
}
}
}
setByRegionStategy(region: RegionType, openTime: number) {
this.env = region.env;
this.openTime = openTime;
if(region.stategy) {
this.activityGroupId = region.stategy.activityGroupId;
this.hasOpenMail = !!region.stategy.openMail;
this.openMail = region.stategy.openMail;
this.hasCircleMail = !!region.stategy.circleMail;
this.circleMail = region.stategy.circleMail;
this.stopRegisterTime = region.stategy.stopRegisterTime;
}
}
checkParams() {
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;
}
}
export class CreateGiftCode {
name: string; // 礼包码名
goods: RewardInter[]; // 奖励
beginTime: number; // 开始时间
endTime: number; // 结束时间
codeLen: number; // 礼包码位数
remark: string = ''; // 备注
generateType: GIFT_GENERATE_TYPE; // 生成类型
constructor(obj: any) {
this.name = obj.name;
this.goods = obj.goods;
this.beginTime = obj.beginTime;
this.endTime = obj.endTime;
this.codeLen = obj.codeLen;
this.remark = obj.remark;
this.generateType = obj.generateType;
}
checkParams() {
if(!isString(this.name)) return false;
if(!isArray(this.goods)) return false;
for(let { id, count } of this.goods) {
if(!isNumber(id) || !isNumber(count)) return false;
}
if(!isTimestamp(this.beginTime) || !isTimestamp(this.endTime)) return false;
if(!isNumber(this.codeLen) || this.codeLen <= 0) return false;
if(this.generateType != GIFT_GENERATE_TYPE.ONE_TO_MANY && this.generateType != GIFT_GENERATE_TYPE.ONE_TO_ONE) {
return false
}
return true;
}
}
export class UpdateGiftCode {
id: number;
name: string; // 礼包码名
goods: RewardInter[]; // 奖励
beginTime: number; // 开始时间
endTime: number; // 结束时间
codeLen: number; // 礼包码位数
remark: string = ''; // 备注
constructor(id: number, obj: any) {
this.id = id;
this.name = obj.name;
this.goods = obj.goods;
this.beginTime = obj.beginTime;
this.endTime = obj.endTime;
this.codeLen = obj.codeLen;
this.remark = obj.remark;
}
checkParams() {
if(!isNumber(this.id) || this.id <= 0) return false
if(!isString(this.name)) return false;
if(!isArray(this.goods)) return false;
for(let { id, count } of this.goods) {
if(!isNumber(id) || !isNumber(count)) return false;
}
if(!isTimestamp(this.beginTime) || !isTimestamp(this.endTime)) return false;
if(!isNumber(this.codeLen) || this.codeLen <= 0) return false;
return true;
}
}
export class GuildFormParam {
code: string;
name: string;
notice: string;
fund: number;
lv: number;
equipProduce: number;
boss: number;
train: number;
wishPool: number;
store: number;
donate: number;
constructor(obj?: any) {
if(obj) {
for(let key in obj) {
this[key] = obj[key];
}
}
}
checkParams() {
if(!this.code || !isString(this.code)) return false;
if(this.name && !isString(this.name)) return false;
if(this.notice && !isString(this.notice)) return false;
if(this.fund && !isNumber(this.fund)) return false;
if(this.lv && !isNumber(this.lv)) return false;
if(this.equipProduce && !isNumber(this.equipProduce)) return false;
if(this.boss && !isNumber(this.boss)) return false;
if(this.train && !isNumber(this.train)) return false;
if(this.wishPool && !isNumber(this.wishPool)) return false;
if(this.store && !isNumber(this.store)) return false;
if(this.donate && !isNumber(this.donate)) return false;
return true;
}
}

74
shared/domain/backEndField/search.ts Normal file
View File

@@ -0,0 +1,74 @@
import { GM_MAIL_STATUS, GM_MAIL_TYPE } from "../../consts";
export interface SearchUserParam {
uid?: number;
tel?: string;
channelType?: string;
}
export interface SearchRoleParam {
uid?: number; // 玩家id
roleId?: string; // 角色id
roleName?: string; // 昵称
}
export interface SearchHeroParam {
roleId?: string;
roleName?: string;
hid?: number;
}
export interface SearchEquipParam {
roleId?: string;
roleName?: string;
id?: number;
}
export interface SearchItemParam {
roleId?: string;
roleName?: string;
id?: number;
}
export interface SearchGuildParam {
serverId?: number;
name?: string;
}
export interface SearchMailParam {
createTimeStart?: number;
createTimeEnd?: number;
serverId?: number;
roleId?: string;
roleName?: string;
title?: string;
status?: GM_MAIL_STATUS;
mailType?: GM_MAIL_TYPE;
hasGoods?: boolean;
}
export interface SearchMarqueeParam {
code?: string;
createdBy?: number;
createTimeStart?: number;
createTimeEnd?: number;
sendTimeStart?: number;
sendTimeEnd?: number;
}
export interface SearchGiftCodeParam {
env?: string;
id?: number;
name?: string;
createTimeStart?: number;
createTimeEnd?: number;
}
export interface SearchGiftCodeDetailParam {
giftId?: number;
giftName?: string;
generateType?: number;
code?: string;
roleId?: string;
roleName?: string;
}

21
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 {
@@ -7,22 +6,18 @@ export class ServerParam {
serverId: number; // 显示的区号
serverStr: string; // 显示的区号 S1
name: string; // 区名
host: string; // pinus地址
port: number; // pinus端口
host: string = ''; // pinus地址
port: number = 0; // pinus端口
status: number; // 状态
openTime: number; // 开服时间
serverType: string; // 分区类型 官服 测试服 开发服
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.host = server.host;
this.port = server.port;
this.status = server.status;
this.openTime = getSeconds(server.openTime);
this.serverType = server.serverType;
this.openTime = server.openTime;
}
}
@@ -35,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}`
}
}

14
shared/domain/roleField/mail.ts
View File

@@ -76,20 +76,12 @@ export class MailParam {
}
setContent(mail: MailType|GroupMailType|ServerMailType) {
let { contentId = 0, params, goods, sendName } = mail;
let { contentId = 0, goods, sendName, content, title } = mail;
let dicMail = gameData.mail.get(contentId);
if(!dicMail) dicMail = gameData.mail.get(0);
this.content = this.getContent(dicMail.content, params);
this.title = title;
this.content = content;
this.sendName = sendName||SEND_NAME;
this.goods = goods;
}
getContent(content: string, params: string[]) {
if(!content) content = '%d';
for(let p of params) {
content = content.replace(/%d/, p);
}
return content
}
}

19
shared/pubUtils/data.ts
View File

@@ -83,7 +83,7 @@ import { dicRecruit, loadRecruit } from './dictionary/DicRecruit';
import { loadRMB, dicRMB } from './dictionary/DicRMB';
import { dicActivityType, loadActivityType } from './dictionary/DicActivityType';
import { DicTaskType, dicTaskTypeDesc, loadTaskType } from './dictionary/DicTaskType';
import { dicServerName, dicServerGroupName, loadServerName } from "./dictionary/DicServerName";
import { dicServerName, loadServerName } from "./dictionary/DicServerName";
import { dicAp, loadAp, dicApMaxLevel } from './dictionary/DicAp';
import { dicApBuy, dicApMaxBuyTimes, loadApBuy } from "./dictionary/DicApBuy";
import { dicKingExpRatio, loadKingExpRatio } from './dictionary/DicKingExpRatio';
@@ -224,7 +224,6 @@ export const gameData = {
activityType: dicActivityType,
taskTypeDesc: dicTaskTypeDesc,
serverNames: dicServerName,
serverGroupNames: dicServerGroupName,
ap: dicAp,
apMaxLevel: dicApMaxLevel,
apBuy: dicApBuy,
@@ -718,22 +717,6 @@ function getCeRatio() {
});
}
// 根据groupId获得当前大区名
export function getServerGroupName(groupId: number) {
let name = gameData.serverGroupNames.get(groupId);
if(!name) {
let maxId = 0;
gameData.serverGroupNames.forEach((gname, id) => {
if(id > maxId) {
maxId = id;
name = gname;
}
})
}
return name;
}
// 根据服务器id获得当前大区名
export function getServerName(id: number) {
let name = gameData.serverNames.get(id);

4
shared/pubUtils/dictionary/DicMail.ts
View File

@@ -7,6 +7,8 @@ export interface DicMail {
readonly id: number;
// 内容 %d 替换
readonly content: string;
readonly title: string;
readonly sendName: string;
readonly time: number;
}
@@ -16,6 +18,8 @@ export function loadMail() {
let arr = readFileAndParse(FILENAME.DIC_MAIL);
arr.forEach(o => {
if(o.title == '&') o.title = '';
if(o.sendName == '&') o.sendName = '';
o.time = o.time * 60 * 60;
dicMail.set(o.id, o);
});

35
shared/pubUtils/dictionary/DicServerName.ts
View File

@@ -1,4 +1,4 @@
// 武将特技表
// 服务器名
import { readFileAndParse } from '../util'
import { FILENAME } from '../../consts'
@@ -6,32 +6,21 @@ export interface DicServerName {
// id
readonly id: number;
// 小区名
readonly name: string;
readonly sname: string;
// 大区id
readonly groupId: number;
// 大区名
readonly groupName: string;
}
export const dicServerName = new Map<number, string>();
export const dicServerGroupName = new Map<number, string>();
export const dicServerName = new Map<number, DicServerName>();
export function loadServerName() {
dicServerName.clear();
dicServerGroupName.clear();
{
let arr = readFileAndParse(FILENAME.DIC_SERVER_NAME);
arr.forEach(o => {
let { id, sname } = o;
dicServerName.set(id, sname);
});
arr = undefined;
}
let arr = readFileAndParse(FILENAME.DIC_SERVER_NAME);
{
let arr = readFileAndParse(FILENAME.DIC_SERVER_GROUP_NAME);
arr.forEach(o => {
let { id, groupName } = o;
dicServerGroupName.set(id, groupName);
});
arr = undefined;
}
arr.forEach(o => {
dicServerName.set(o.id, o);
});
arr = undefined;
}

Some files were not shown because too many files have changed in this diff Show More