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

邮件 活跃度下发

Browse Source
This commit is contained in:
mamengke01
2021-02-05 11:45:07 +08:00
parent 871e71ab54
commit 286eb231a6
36 changed files with 1183 additions and 439 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
game-server/app.ts
View File

@@ -21,7 +21,7 @@ import * as redLockService from './app/services/redLockService';
// TODO 需要整理。
import _pinus = require('pinus');
import { updateTeamStatus } from './app/services/comBattleService';
import { init } from './app/pubUtils/gmData/gmDataUtil';
const filePath = (_pinus as any).FILEPATH;
filePath.MASTER = '/config/master';
filePath.SERVER = '/config/servers';
@@ -110,6 +110,15 @@ app.configure('production|development|alpha|dev', 'gate', function () {
});
});
app.configure('production|development|alpha|dev', 'gm', function () {
app.set('connectorConfig',
{
connector: pinus.connectors.hybridconnector,
useProtobuf: true
});
init();//将gm后台数据加载到gate服
});
app.configure('production|development|alpha|dev', 'systimer', function () {
app.set('connectorConfig',
{

6
game-server/app/servers/battle/filter/checkEventFilter.ts
View File

@@ -1,6 +1,6 @@
import {Application, RouteRecord, FrontendOrBackendSession, HandlerCallback} from "pinus";
import {checkEvent, getCurrentTime} from '../../../services/eventSercive';
import {checkEvent} from '../../../services/eventSercive';
import { refresh } from '../../../services/refreshService';
module.exports = function(app: Application) {
return new Filter(app);
}
@@ -15,7 +15,7 @@ Filter.prototype.before = function (routeRecord: RouteRecord, msg: any, session:
};
Filter.prototype.after = function (err: Error, routeRecord: RouteRecord, msg: any, session: FrontendOrBackendSession, resp: any, next: HandlerCallback) {
getCurrentTime(session);
refresh(session);
return checkEvent(session).then(()=>{
next(err);
}).catch(e => {

3
game-server/app/servers/battle/handler/donateHandler.ts
View File

@@ -11,6 +11,7 @@ import { CHAT_SERVER } from '../../../consts';
import { getDonation } from '../../../services/donateService';
import { getUserGuildWithRefActive } from '../../../services/guildService';
import { ARMY } from '../../../pubUtils/dicParam';
import { addActive } from '../../../services/guildService'
export default function(app: Application) {
return new DonationHandler(app);
}
@@ -59,6 +60,8 @@ export class DonationHandler {
//增加基金
const { fund } = await GuildModel.updateInfo(code, {}, { fund: rewardFund }, 'fund');
this.app.rpc.chat.guildRemote.updateInfo.toServer(CHAT_SERVER, code, { fund });
await addActive(roleId, serverId, 1, id);
return resResult(STATUS.SUCCESS, { donateFund, reports, donateCnt, goods });
}

27
game-server/app/servers/battle/handler/guildBossHandler.ts
View File

@@ -1,18 +1,20 @@
import { Application, BackendSession, pinus } from 'pinus';
import { Application, BackendSession } from 'pinus';
import { resResult, genCode, getRandomByLen } from '../../../pubUtils/util';
import { STATUS } from '../../../consts';
import { BossInstanceModel } from '../../../db/BossInstance';
import { BattleRecordModel } from '../../../db/BattleRecord';
import { nowSeconds, getTodayZeroPoint } from '../../../pubUtils/timeUtil';
import { getBossInstanceInfo, bossResult, checkMemberExists, pushBossHpMessage, getBossInstanceWhenEnd, addBossInstance } from '../../../services/guildBossService';
import { findWhere, random } from 'underscore'
import { GUILD_DATA_NAME, GUILD_STRUCTURE } from '../../../consts/constModules/guildConst';
import { findWhere } from 'underscore'
import { GUILD_STRUCTURE } from '../../../consts/constModules/guildConst';
import { DATA_NAME } from '../../../consts/dataName';
import { UserGuildModel } from '../../../db/UserGuild';
import { GUILD_OPERATE } from '../../../consts';
import { checkAuth, addActive } from '../../../services/guildService';
import { GuildModel } from '../../../db/Guild';
import { getBossByLv } from '../../../pubUtils/data';
import { lockData } from '../../../services/redLockService';
import { handleCost } from '../../../services/rewardService';
export default function (app: Application) {
return new GuildHandler(app);
@@ -59,6 +61,8 @@ export class GuildHandler {
//开启演武场
async openBossInstance(msg: {}, session: BackendSession) {
const roleId: string = session.get('roleId');
const sid: string = session.get('sid');
const serverId: number = parseInt(session.get('serverId'));
let userGuild = await UserGuildModel.getMyGuild(roleId, 'auth guildCode');
if (!userGuild)
@@ -66,7 +70,7 @@ export class GuildHandler {
const { guildCode: code } = userGuild;
const checkMyResult = await checkAuth(GUILD_OPERATE.OPEN_BOSS, roleId, null, userGuild);
if(!checkMyResult) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
let res:any = await lockData(serverId, GUILD_DATA_NAME.BOSS_SCRIPT, code);//加锁
let res:any = await lockData(serverId, DATA_NAME.BOSS_SCRIPT, code);//加锁
if (!!res.err)
return resResult(STATUS.REDLOCK_ERR);
let bossInstance = await BossInstanceModel.findBossInstance(code);
@@ -83,14 +87,13 @@ export class GuildHandler {
return resResult(STATUS.GUILD_STRUCTURE_NOT_FOUND);
}
let bossBase = getBossByLv(curStructure.lv);
//消耗TODO
let {bossHp, warId, bossLevel } = getRandomByLen(bossBase.wars);
let resGuild = await GuildModel.costFund(code, bossBase.consume)
let { bossHp, warId } = getRandomByLen(bossBase.wars);
let resGuild = await GuildModel.costFund(code, bossBase.opencost);
if (!resGuild)
return resResult(STATUS.GUILD_FUND_NOT_ENOUGH);
await BossInstanceModel.openBossInstance(code, bossHp, warId, bossLevel);
await BossInstanceModel.openBossInstance(code, bossHp, warId, bossBase.bossLevel);
res.releaseCallback();
let result = {warId, ranks: [], myRank: {}, bossHp, status: 3, bossLv: bossLevel, isBattled: false};
let result = {warId, ranks: [], myRank: {}, bossHp, status: 3, bossLv: bossBase.bossLevel, isBattled: false};
return resResult(STATUS.SUCCESS, result);
}
@@ -111,14 +114,10 @@ export class GuildHandler {
return resResult(STATUS.GUILD_SCRIPT_IS_BATTLED);
let { warId, ranks } = bossInstance;
const battleCode = genCode(8); // 关卡唯一值
//TODO查看地图字典
let warInfo;
await BattleRecordModel.updateBattleRecordByCode(battleCode, {
$set: {
roleId, roleName, battleId: warId,
status: 0,
// warName: warInfo.gk_name,
// warType: warInfo.warType,
record: { heroes:[],recordNum: bossInstance.num, bossHp: bossInstance.bossHp},
}
}, true);
@@ -147,7 +146,7 @@ export class GuildHandler {
//记录伤害
let bossInstance = await BossInstanceModel.updateBossHp(code, damage, roleId);
if (!bossInstance) {//进入结算
let flag = await bossResult(code, serverId, GUILD_DATA_NAME.BOSS_SCRIPT, roleId, damage);
let flag = await bossResult(code, serverId, DATA_NAME.BOSS_SCRIPT, roleId, damage);
if (!flag) {
return resResult(STATUS.WRONG_PARMS);
}

6
game-server/app/servers/battle/handler/guildHandler.ts
View File

@@ -1,6 +1,6 @@
import { Application, BackendSession, pinus, ChannelService } from 'pinus';
import { resResult, getRandEelm, getRefTime } from '../../../pubUtils/util';
import { STATUS, GUILD_OPERATE, GUILD_AUTH, GUILD_JOB, GUILD_APPLY_TYPE, GUILD_STRUCTURE, GUILD_REC_TYPE, GUILD_STRUCTURE_NAME, MAIL_TYPE, REDIS_KEY, GUILD_DATA_NAME, CHAT_SERVER } from '../../../consts';
import { STATUS, GUILD_OPERATE, GUILD_AUTH, GUILD_JOB, GUILD_APPLY_TYPE, GUILD_STRUCTURE, GUILD_REC_TYPE, GUILD_STRUCTURE_NAME, MAIL_TYPE, REDIS_KEY, CHAT_SERVER } from '../../../consts';
import { UserGuildModel } from '../../../db/UserGuild';
import { checkAuth, joinGuild, getGuildWithRefActive, getUserGuildWithRefActive, addActive, settleGuildWeekly } from '../../../services/guildService';
import { GuildModel, GuildType } from '../../../db/Guild';
@@ -17,7 +17,7 @@ import { GuildRecModel } from '../../../db/GuildRec';
import { sendMail } from '../../../services/mailService';
import { existsRank, initSingleRankWithServer, getRank, setRank, redisUserInfoUpdate, redisUserInfoAdd, removeFromRank, getMyRank, isRoleOnline } from '../../../services/redisService';
import { lockData } from '../../../services/redLockService';
import { DATA_NAME } from '../../../consts/dataName';
import { openGuildRefine } from '../../../services/guildRefineService';
import { unlockTrain } from '../../../services/guildTrainService';
export default function (app: Application) {
@@ -713,7 +713,7 @@ export class GuildHandler {
const checkResult = await checkAuth(GUILD_OPERATE.UP_STRUCTURE, roleId, code);
if (!checkResult) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
let res:any = await lockData(serverId, GUILD_DATA_NAME.UP_STRUCTURE, code);// 加锁
let res:any = await lockData(serverId, DATA_NAME.UP_STRUCTURE, code);// 加锁
if (!!res.err) return resResult(STATUS.REDLOCK_ERR);
const guild = await GuildModel.findByCode(code, serverId, 'lv structure');

7
game-server/app/servers/battle/handler/guildRefineHandler.ts
View File

@@ -9,11 +9,12 @@ import { handleCost, addItems, checkGoods } from '../../../services/rewardServic
import { GuildModel } from '../../../db/Guild';
import { findIndex, findWhere } from 'underscore';
import { lockData } from '../../../services/redLockService';
import { GUILD_DATA_NAME, GUILD_STRUCTURE } from '../../../consts/constModules/guildConst';
import { checkAuth } from '../../../services/guildService';
import { ARMY } from '../../../pubUtils/dicParam';
import { CURRENCY_BY_TYPE, CURRENCY_TYPE } from '../../../consts/constModules/itemConst';
import { openGuildRefine } from '../../../services/guildRefineService';
import { DATA_NAME } from '../../../consts/dataName';
export default function (app: Application) {
return new GuildRefineHandler(app);
}
@@ -80,7 +81,7 @@ export class GuildRefineHandler {
let developConsume = getArmyDevelopConsumeById(id);
if (!developConsume)
return resResult(STATUS.WRONG_PARMS);
let res:any = await lockData(serverId, GUILD_DATA_NAME.GUILD_REFINE, code);//加锁
let res:any = await lockData(serverId, DATA_NAME.GUILD_REFINE, code);//加锁
if (!!res.err)
return resResult(STATUS.REDLOCK_ERR);
let guildRefine = await GuildRefineModel.getRefine(code);
@@ -115,7 +116,7 @@ export class GuildRefineHandler {
if (!userGuild)
return resResult(STATUS.WRONG_PARMS);
const { guildCode: code } = userGuild;
let res:any = await lockData(serverId, GUILD_DATA_NAME.GUILD_ASSIST_REFINE, code);//加锁
let res:any = await lockData(serverId, DATA_NAME.GUILD_ASSIST_REFINE, code);//加锁
if (!!res.err)
return resResult(STATUS.REDLOCK_ERR);
let guildRefine = await GuildRefineModel.getRefine(code);

8
game-server/app/servers/battle/handler/guildTrainHandler.ts
View File

@@ -7,7 +7,7 @@ import { nowSeconds, getHourPoint, getCurHourPoint } from '../../../pubUtils/tim
import { getUserGuild, getGuildTrainInfo, unlockTrain, resetTrain, getGuildTrainRewards} from '../../../services/guildTrainService';
import { findIndex, findWhere, indexBy } from 'underscore'
import { lockData } from '../../../services/redLockService';
import { GUILD_DATA_NAME, REFRESH_HOUR, GUILD_REPORT_NUM } from '../../../consts/constModules/guildConst';
import { REFRESH_HOUR, GUILD_REPORT_NUM } from '../../../consts/constModules/guildConst';
import { UserGuildModel } from '../../../db/UserGuild';
import { GuildModel } from '../../../db/Guild';
import { getArmyTrainJuDian, getTrainSoloReward, getTrainBaseByLv } from '../../../pubUtils/data';
@@ -16,6 +16,8 @@ import { handleCost, addItems } from '../../../services/rewardService';
import { ARMY } from '../../../pubUtils/dicParam';
import { addActive } from '../../../services/guildService';
import { GuildTrainReportModel } from '../../../db/GuildTrainReport';
import { DATA_NAME } from '../../../consts/dataName';
export default function (app: Application) {
return new GuildTrainHandler(app);
}
@@ -168,7 +170,7 @@ export class GuildTrainHandler {
let trainId = battleRecord.record.trainId;
let hid = battleRecord.record.hid;
let res:any = await lockData(serverId, GUILD_DATA_NAME.TRAIN, code + '_' + trainId);//加锁
let res:any = await lockData(serverId, DATA_NAME.TRAIN, code + '_' + trainId);//加锁
if (!!res.err)
return resResult(STATUS.REDLOCK_ERR);
let guildTrain = await GuildTrainModel.findTrainByTrainIdNotLock(code, trainId);
@@ -249,7 +251,7 @@ export class GuildTrainHandler {
return resResult(STATUS.WRONG_PARMS);
const { guildCode: code } = userGuild;
let { trainLv } = await GuildModel.findGuild(code, serverId, 'structure');
let res:any = await lockData(serverId, GUILD_DATA_NAME.TRAIN_BOX, code + '_' + trainId);//加锁
let res:any = await lockData(serverId, DATA_NAME.TRAIN_BOX, code + '_' + trainId);//加锁
if (!!res.err)
return resResult(STATUS.REDLOCK_ERR);

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

@@ -18,6 +18,7 @@ import { UserGuildModel } from '../../../db/UserGuild';
import { GuildModel } from '../../../db/Guild';
import { gameData } from '../../../pubUtils/data';
import { getMails } from '../../../services/mailService';
export default function (app: Application) {
return new EntryHandler(app);
}
@@ -56,6 +57,7 @@ export class EntryHandler {
await session.abind(role.roleId);
session.set('uid', role.roleId);
session.set('roleId', role.roleId);
session.set('updatedMailAt', role.updatedMailAt);
session.set('roleName', role.roleName);
session.set('eventStatus', role.eventStatus);
session.set('sid', self.app.get('serverId'));
@@ -89,7 +91,7 @@ export class EntryHandler {
let heros = await HeroModel.findByRole(role.roleId, [], HERO_SELECT.ENTRY, true);
let equips = await EquipModel.findbyRole(role.roleId);
let items = await ItemModel.findbyRole(role.roleId);
let mails = await getMails(role.roleId, serverId)
await chackFunOpenWhenLogin(role, session);
await loginRefresh(role.roleId);
@@ -98,6 +100,9 @@ export class EntryHandler {
role['consumeGoods'] = items;
let apJson = await getAp(Date.now(), role.roleId);
role['apJson'] = apJson;
role['ce'] = reduceCe(role.ce);
role['topFiveCe'] = reduceCe(role.topFiveCe);
role['mails'] = mails;
if(role.hasGuild) {
let userGuild = await UserGuildModel.getMyGuild(role.roleId, USER_GUILD_SELECT.ENTRY );

20
game-server/app/servers/gate/remote/gateRemote.ts Normal file
View File

@@ -0,0 +1,20 @@
import { Application, ChannelService, FrontendSession, RemoterClass } from 'pinus';
import { setGmMails, getGmMailById, getGmMails } from '../../../pubUtils/gmData/gmDataUtil';
import { MAIL_TYPE, MAIL_TEM_TYPE } from "../../../consts/constModules/mailConst";
import { mailData } from "../../../pubUtils/interface";
import { getContent } from '../../../services/mailService';
import { findWhere } from 'underscore';
export default function (app: Application) {
return new GateRemote(app);
}
export class GateRemote {
constructor(private app: Application) {
this.app = app;
this.channelService = app.get('channelService');
}
private channelService: ChannelService;
}

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

@@ -1,11 +1,11 @@
import {Application, BackendSession} from 'pinus';
import {Application, BackendSession, pinus} from 'pinus';
import { RoleModel } from '../../../db/Role';
import { EventRecordModel } from '../../../db/EventRecord';
import { getEvent } from '../../../services/eventSercive';
import { resResult } from '../../../pubUtils/util';
import { STATUS } from '../../../consts/statusCode';
import { GMMailModel } from '../../../db/GMMail';
import { setGmMails } from '../../../pubUtils/gmData/gmDataUtil';
export default function(app: Application) {
return new GmHandler(app);
}
@@ -70,7 +70,6 @@ export class GmHandler {
channel.add(roleId, sid);
}
let tsid = channel.getMember(roleId)['sid'];
channelService.pushMessageByUids(eventName, resResult(STATUS.SUCCESS, content), [{
uid: roleId,
@@ -78,4 +77,10 @@ export class GmHandler {
}]);
return resResult(STATUS.SUCCESS, { msg: content });
}
async addMail(msg: { endTime: number, serverId: number, sendName: string, content: string, goods, sendRoles:[{roleId: string, status: number}], gmMailType: number, sendTime: number, }) {
let {sendRoles, endTime, content, sendName, gmMailType, sendTime, goods, serverId} = msg;
let mail = await GMMailModel.addMail({serverId, sendRoles, sendName, endTime, content, gmMailType, sendTime, goods});
setGmMails([mail]);
}
}

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

@@ -1,9 +1,13 @@
import { Application, ChannelService, FrontendSession, RemoterClass } from 'pinus';
import { Application, ChannelService } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { STATUS } from '../../../consts';
import { setGmMails, getGmMailById, getGmMails } from '../../../pubUtils/gmData/gmDataUtil';
import { MAIL_TYPE, MAIL_TEM_TYPE } from "../../../consts/constModules/mailConst";
import { mailData } from "../../../pubUtils/interface";
import { getContent } from '../../../services/mailService';
import { findWhere } from 'underscore';
export default function (app: Application) {
return new ChatRemote(app);
return new GMRemote(app);
}
// rpc 定义挪到单独的定义文件(user.rpc.define.ts)。解决ts-node 有可能找不到定义的问题。
@@ -13,11 +17,11 @@ export default function (app: Application) {
// declare global {
// interface UserRpc {
// chat: {
// chatRemote: RemoterClass<FrontendSession, ChatRemote>;
// GMRemote: RemoterClass<FrontendSession, GMRemote>;
// };
// }
// }
export class ChatRemote {
export class GMRemote {
constructor(private app: Application) {
this.app = app;
@@ -91,4 +95,47 @@ export class ChatRemote {
};
channel.pushMessage('onLeave', resResult(STATUS.SUCCESS, param));
}
public async refreshGmMails(mails:[any]) {
setGmMails(mails);
}
public async getMailInfos(roleId: string, serverId: number, mails: [any], groupMails: [any]) {
let list: mailData[] = [];
mails.map(async function({ mailId, goods, sendTime, params, status, _id, mailTemType, sendName, endTime}) {
if (mailTemType == MAIL_TEM_TYPE.GAMEMAIL) { //模板邮件
let { content } = getContent(parseInt(mailId), params);
if (!content)
return;
list.push({ id: _id, mailId, goods, sendTime, endTime, content, status, mailType: MAIL_TYPE.SINGLEMAIL, sendName });
} else if (mailTemType == MAIL_TEM_TYPE.GMTYPE) { //系统邮件
let gmMail = getGmMailById(mailId, serverId);
if (!gmMail)
return;
let { goods, sendTime, content, endTime, sendName } = gmMail;
list.push({ id: _id, mailId, goods, sendTime, endTime, content, status, mailType: MAIL_TYPE.SINGLEMAIL, sendName });
}
});
groupMails.map(async function({ mailId, goods, sendTime, endTime, params, sendRoles, _id, mailTemType, sendName }) {
let { status } = findWhere(sendRoles, {roleId});
if (mailTemType == MAIL_TEM_TYPE.GAMEMAIL) { //模板邮件
let { content } = getContent( parseInt(mailId), params);
if (!content)
return;
list.push({ id: _id, mailId, goods, sendTime, content, endTime, status, mailType: MAIL_TYPE.GROUPMAIL, sendName });
} else if (mailTemType == MAIL_TEM_TYPE.GMTYPE) { //系统邮件
let gmMail = getGmMailById(mailId, serverId);
if (!gmMail)
return;
let { goods, sendTime, content, endTime, sendName } = gmMail;
list.push({ id: _id, mailId, goods, sendTime, endTime, content, status, mailType: MAIL_TYPE.GROUPMAIL, sendName });
}
});
return list;
}
public async getMails(updatedMailAt: number, serverId: number) {
let gmMails = getGmMails(updatedMailAt, serverId);
return gmMails;
}
}

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

@@ -1,7 +1,7 @@
import {Application, BackendSession, ChannelService} from 'pinus';
import { handleCost, addItems } from '../../../services/rewardService';
import { calPlayerCeAndSave } from '../../../services/playerCeService';
import { resResult, returnHeroCeRatio, getAllAttrStage } from '../../../pubUtils/util';
import { resResult, returnHeroCeRatio } from '../../../pubUtils/util';
import { STATUS } from '../../../consts/statusCode';
import {HeroModel} from '../../../db/Hero';
import {CURRENCY_BY_TYPE, CURRENCY_TYPE, CONSUME_TYPE, HERO_GROW_MAX, HERO_SYSTEM_TYPE, ITID, ABI_STAGE, HERO_CE_RATIO} from '../../../consts';

132
game-server/app/servers/role/handler/mailHandler.ts Normal file
View File

@@ -0,0 +1,132 @@
import {Application, BackendSession, ChannelService} from 'pinus';
import { MailModel } from '../../../db/Mail';
import { GroupMailModel } from '../../../db/GroupMail';
import { resResult } from '../../../pubUtils/util';
import { STATUS } from '../../../consts/statusCode';
import { findWhere } from 'underscore';
import { MAIL_STATUS, MAIL_TEM_TYPE, MAIL_TYPE } from '../../../consts/constModules/mailConst';
import { handleCost, addItems } from '../../../services/rewardService';
import { getGmMailById } from '../../../pubUtils/gmData/gmDataUtil';
export default function(app: Application) {
return new RoleHandler(app);
}
export class RoleHandler {
constructor(private app: Application) {
}
public async refrshMails(msg:{}) {
}
public async readMail(msg: { id: string, mailType: number }, session: BackendSession) {
let roleId: string = session.get('roleId');
let { id, mailType } = msg;
let mail;
if (mailType == MAIL_TYPE.SINGLEMAIL) {
mail = await MailModel.updateMailByStatus(id, [MAIL_STATUS.CREATE], { status: MAIL_STATUS.READ });
} else if (mailType == MAIL_TYPE.GROUPMAIL) {
mail = await GroupMailModel.updateMailByStatus(id, roleId, MAIL_STATUS.READ, [MAIL_STATUS.CREATE]);
}
if (!mail)
return resResult(STATUS.WRONG_PARMS);
return resResult(STATUS.SUCCESS, { mails: [{ id, status: MAIL_STATUS.READ, mailType }] });
}
public async delMails(msg: { id: string, mailType: number, type: number }, session: BackendSession) {
let roleId: string = session.get('roleId');
let { id, type, mailType } = msg;
if (type == 1) {//单个删除
if (mailType == MAIL_TYPE.SINGLEMAIL) {
let mail = await MailModel.delMail(id);
if (!mail)
return resResult(STATUS.WRONG_PARMS);
return resResult(STATUS.SUCCESS, { mails: [{ id, status: MAIL_STATUS.DELETE, mailType }] });
} else if (mailType == MAIL_TYPE.GROUPMAIL) {
let mail = await GroupMailModel.delMail(id, roleId);
if (!mail)
return resResult(STATUS.WRONG_PARMS);
return resResult(STATUS.SUCCESS, { mails: [{ id, status: MAIL_STATUS.DELETE, mailType }] });
} else {
return resResult(STATUS.WRONG_PARMS);
}
} else {//一键删除
let groupMailIds = await GroupMailModel.findReadAndRewardsMails(roleId);
await GroupMailModel.updateMailStatus(groupMailIds, MAIL_STATUS.DELETE, roleId);
let mailIds = await MailModel.findReadAndRewardsMails(roleId);
await MailModel.updateMailStatus(mailIds, MAIL_STATUS.DELETE);
let mails = [];
groupMailIds.map((id)=>{
mails.push({id, status: MAIL_STATUS.DELETE, mailType: MAIL_TYPE.GROUPMAIL});
});
mailIds.map((id)=>{
mails.push({id, status: MAIL_STATUS.DELETE, mailType: MAIL_TYPE.SINGLEMAIL});
});
return resResult(STATUS.SUCCESS, { mails });
}
}
public async getMailRewards(msg: { id: string, mailType: number, type: number }, session: BackendSession) {
let roleId: string = session.get('roleId');
let roleName: string = session.get('roleName');
let sid: string = session.get('sid');
let serverId: number = session.get('serverId');
let { id, type, mailType } = msg;
let mailGoods = [];
let mails = [];
if (type == 1) {//单个领取
let mail;
if (mailType == MAIL_TYPE.SINGLEMAIL) {
mail = await MailModel.updateMailByStatus(id, [MAIL_STATUS.READ], { status: MAIL_STATUS.RECEIVED });
if (!mail)
return resResult(STATUS.WRONG_PARMS);
} else if (mailType == MAIL_TYPE.GROUPMAIL) {
mail = await GroupMailModel.updateMailByStatus(id, roleId, MAIL_STATUS.RECEIVED, [MAIL_STATUS.READ]);
if (!mail)
return resResult(STATUS.WRONG_PARMS);
} else {
return resResult(STATUS.WRONG_PARMS);
}
mails.push({id, status: MAIL_STATUS.DELETE, mailType});
if (mail.mailTemType == MAIL_TEM_TYPE.GMTYPE) {
let gmMail = getGmMailById(id, serverId);
mailGoods.push(...gmMail.goods);
} else {
mailGoods.push(...mail.goods);
}
} else {//一键领取
let ids;
let groupMailRewards = await GroupMailModel.findRewardsMails(roleId);
ids = groupMailRewards.map(({_id, goods, mailTemType})=>{
if (mailTemType == MAIL_TEM_TYPE.GMTYPE) {
let gmMail = getGmMailById(id, serverId);
mailGoods.push(...gmMail.goods);
} else {
mailGoods.push(...goods);
}
mails.push({id: _id, status: MAIL_STATUS.DELETE, mailType: MAIL_TYPE.GROUPMAIL});
return _id;
});
if (!!ids.length)
await GroupMailModel.updateMailStatus(ids, MAIL_STATUS.RECEIVED, roleId);
let mailRewards = await MailModel.findRewardsMails(roleId);
ids = mailRewards.map(({_id, goods, mailTemType})=>{
if (mailTemType == MAIL_TEM_TYPE.GMTYPE) {
let gmMail = getGmMailById(id, serverId);
mailGoods.push(...gmMail.goods);
} else {
mailGoods.push(...goods);
}
mails.push({id, status: MAIL_STATUS.DELETE, mailType: MAIL_TYPE.SINGLEMAIL});
return _id;
});
if (!!ids.length)
await MailModel.updateMailStatus(ids, MAIL_STATUS.RECEIVED);
}
let resGoods = [];
if (!!mailGoods && !!mailGoods.length)
resGoods = await addItems(roleId, roleName, sid, mailGoods);
return resResult(STATUS.SUCCESS, { mails, goods: resGoods });
}
}

5
game-server/app/servers/user.rpc.define.ts
View File

@@ -9,7 +9,7 @@ import { BattleRemote } from './battle/remote/battleRemote';
import { ConnectorRemote } from './connector/remote/connectorRemote';
import { SystimerRemote } from './systimer/remote/systimerRemote';
import { GuildRemote } from './chat/remote/guildRemote';
import { GMRemote } from './gm/remote/gmRemote';
declare global {
interface UserRpc {
chat: {
@@ -25,6 +25,9 @@ declare global {
};
systimer: {
systimerRemote: RemoterClass<FrontendSession, SystimerRemote>;
},
gm: {
gmRemote: RemoterClass<FrontendSession, GMRemote>;
}
}
}

6
game-server/app/services/eventSercive.ts
View File

@@ -408,9 +408,3 @@ export function checkQuiz(id: number, answer: number) {
}
}
export function getCurrentTime(session: FrontendOrBackendSession) {
let roleId = session.get('roleId');
let sid = session.get('sid');
let uids = [{uid: roleId, sid}];
pinus.app.get('channelService').pushMessageByUids('onPushCurrentTime', resResult(STATUS.SUCCESS, {time: Date.now()}), uids);
}

5
game-server/app/services/guildBossService.ts
View File

@@ -11,6 +11,7 @@ import { BattleRecordModel } from '../db/BattleRecord';
import { getArmyBossRank } from '../pubUtils/data';
import { getMailContent } from '../services/mailService';
import { pushMail } from '../pubUtils/interface';
import { MAIL_TYPE } from '../consts';
/**
*
* @param bossInstance
@@ -122,12 +123,12 @@ export async function bossResult(code: string, serverId: number, dataName: strin
});
let mails = new Array<MailType>();
let pushMessage = new Array<pushMail>();
recordRanks.forEach(async function({roleId, score}, index){
recordRanks.forEach(async function({ roleId }, index){
let rankLv = index + 1;
let goods = getArmyBossRankReward(rankLv);
if (!goods || !goods.length)
return;
await getMailContent(roleId, 1, [JSON.stringify(rankLv)], goods, mails, pushMessage);
await getMailContent(roleId, MAIL_TYPE.GUILD_BOSS_REWARD, [JSON.stringify(rankLv)], goods, mails, pushMessage);
});
await MailModel.addMails(mails);
pushMessage.forEach(({route, data, uids })=>{

15
game-server/app/services/guildRefineService.ts
View File

@@ -1,17 +1,4 @@
import { UserGuildModel } from '../db/UserGuild';
import { getArmyTrainJuDian, getArmyDevelopConsume } from '../pubUtils/data';
import { nowSeconds, getHourPoint } from '../pubUtils/timeUtil';
import { GUILD_REPORT_NUM, GUILD_DATA_NAME, REFRESH_HOUR } from '../consts/constModules/guildConst';
import { GuildTrainType, GuildTrainModel, TrainInstance } from '../db/GuildTrain';
import { GuildModel } from '../db/Guild';
import { findWhere } from 'underscore';
import { ARMY } from '../pubUtils/dicParam';
import { lockData } from './redLockService';
import { pinus } from 'pinus';
import { MailModel, MailType } from '../db/Mail';
import { getRandomByLen, resResult } from '../pubUtils/util';
import { getRedis } from './redisService';
import { STATUS } from '../consts/statusCode';
import { getArmyDevelopConsume } from '../pubUtils/data';
import { ScienceTree, GuildRefineModel } from '../db/GuildRefine';
export async function openGuildRefine(code: string) {
let developConsumes = getArmyDevelopConsume();

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

@@ -1,7 +1,7 @@
import { gameData, getGuildActiveWeekReward, getGuildActiveByIdAndType } from "../pubUtils/data";
import { GuildModel, GuildType } from "../db/Guild";
import { resResult, shouldRefresh } from "../pubUtils/util";
import { STATUS, MAIL_TYPE, GUILD_AUTH, GUILD_JOB, REDIS_KEY, GUILD_DATA_NAME, } from "../consts";
import { STATUS, MAIL_TYPE, GUILD_AUTH, GUILD_JOB, REDIS_KEY, CHAT_SERVER } from "../consts";
import { RoleModel, RoleType } from "../db/Role";
import { UserGuildModel, UserGuildType } from "../db/UserGuild";
import { UserGuildApplyModel } from "../db/UserGuildApply";
@@ -18,6 +18,8 @@ import { ErrLogModel } from '../db/ErrLog';
import { MailType, MailModel } from '../db/Mail';
import { pushMail } from '../pubUtils/interface';
import { getMailContent } from '../services/mailService';
import { DATA_NAME } from '../consts/dataName';
/**
* @description 检查该玩家是否有权限做操作
* @param func 操作id
@@ -41,11 +43,11 @@ export async function checkAuth(func: number, roleId: string, code?: string, use
export async function joinGuild(code: string, guildName: string, lv: number, roleId: string, serverId: number) {
// 周结算锁
let isWeeklySum = await isLocked(serverId, GUILD_DATA_NAME.WEEKLY_GUILD_SUM, code);
let isWeeklySum = await isLocked(serverId, DATA_NAME.WEEKLY_GUILD_SUM, code);
if(isWeeklySum) return { status: 0, resResult: resResult(STATUS.GUILD_WEEKLY_SUM) };
// 人数锁
let res:any = await lockData(serverId, GUILD_DATA_NAME.JOIN_GUILD, code);// 加锁
let res:any = await lockData(serverId, DATA_NAME.JOIN_GUILD, code);// 加锁
if (!!res.err) return { status: 0, resResult: resResult(STATUS.REDLOCK_ERR) };
const result = await RoleModel.joinGuild(roleId, code, guildName);
@@ -86,7 +88,7 @@ export async function joinGuild(code: string, guildName: string, lv: number, rol
*/
export async function getGuildWithRefActive(guildCode: string, serverId: number) {
let res:any = await lockData(serverId, GUILD_DATA_NAME.REFRESH_ACTIVE, guildCode);// 加锁
let res:any = await lockData(serverId, DATA_NAME.REFRESH_ACTIVE, guildCode);// 加锁
if (!!res.err) return false;
let guild = await GuildModel.findByCode(guildCode, serverId, '+refTimeDaily');
@@ -135,7 +137,7 @@ export async function addActive(roleId: string, serverId: number, id: number, ty
if(!guild) return { status: 0, resResult: resResult(STATUS.GUILD_NOT_FOUND) };
// 周结算锁
let isWeeklySum = await isLocked(serverId, GUILD_DATA_NAME.WEEKLY_GUILD_SUM, guildCode);
let isWeeklySum = await isLocked(serverId, DATA_NAME.WEEKLY_GUILD_SUM, guildCode);
if(isWeeklySum) return { status: 0, resResult: resResult(STATUS.GUILD_WEEKLY_SUM) };
let {activeRecord} = userGuild;
@@ -159,6 +161,7 @@ export async function addActive(roleId: string, serverId: number, id: number, ty
let leader = await RoleModel.findById(guild.leader);
let guildRankParam = new GuildRankParam(guild.icon, guild.name, guild.lv, new GuildLeader(leader));
await setRank(REDIS_KEY.GUILD_ACTIVE_RANK, serverId, guild.code, guild.activeWeekly, guild.activeUpdateTime * 1000, guildRankParam);
pinus.app.rpc.chat.guildRemote.updateInfo.toServer(CHAT_SERVER, guildCode, { activeDaily: guild.activeDaily, activeWeekly: guild.activeWeekly });
return { status: 1, guild, userGuild };
}
@@ -176,17 +179,21 @@ export async function getUserGuildWithRefActive(roleId: string, select: string,
const now = new Date();
let isRefDaily = shouldRefresh(refTimeDaily, now, 0);
if(isRefDaily) {
let goods = wishGoods.map(({ goodId, drawCnt})=>{
return {id: goodId, count: drawCnt};
let goods = [];
wishGoods.map(({ goodId, drawCnt})=>{
if (drawCnt > 0)
goods.push({id: goodId, count: drawCnt});
});
let mails = new Array<MailType>();
let pushMessage = new Array<pushMail>();
await getMailContent(roleId, 1, [], goods, mails, pushMessage);
await MailModel.addMails(mails);
if (!notPush) {
pushMessage.forEach(({route, data, uids })=>{
pinus.app.channelService.pushMessageByUids(route, resResult(STATUS.SUCCESS, { mails:data }), uids);
});
if (!!goods.length) {
let mails = new Array<MailType>();
let pushMessage = new Array<pushMail>();
await getMailContent(roleId, MAIL_TYPE.WISH_POOL_REWARD, [], goods, mails, pushMessage);
await MailModel.addMails(mails);
if (!notPush) {
pushMessage.forEach(({route, data, uids })=>{
pinus.app.channelService.pushMessageByUids(route, resResult(STATUS.SUCCESS, { mails:data }), uids);
});
}
}
receivedActive = []; refTimeDaily = now; activeDaily = 0; activeRecord = []; wishGoods = [];
let receiveBoxs = [], wishDntCnt = 0, donateCnt = 0;
@@ -207,7 +214,7 @@ export async function settleGuildWeekly() {
// 周结算时，1. 不能变动memberCnt 2.玩家activeWeekly不能变动 3.公会activeWeekly不能变动
for(let { code, memberCnt, serverId } of guildList) {
let res:any = await lockData(serverId, GUILD_DATA_NAME.WEEKLY_GUILD_SUM, code);//加锁
let res:any = await lockData(serverId, DATA_NAME.WEEKLY_GUILD_SUM, code);//加锁
if (!!res.err) {
await ErrLogModel.create(`settle guild lock data error: ${res.err}`)
}

30
game-server/app/services/guildTrainService.ts
View File

@@ -1,7 +1,7 @@
import { UserGuildModel } from '../db/UserGuild';
import { getArmyTrainJuDian, getTrainBaseByLv } from '../pubUtils/data';
import { nowSeconds, getHourPoint } from '../pubUtils/timeUtil';
import { GUILD_REPORT_NUM, GUILD_DATA_NAME, REFRESH_HOUR, GUILD_STRUCTURE } from '../consts/constModules/guildConst';
import { GUILD_REPORT_NUM, REFRESH_HOUR, GUILD_STRUCTURE } from '../consts/constModules/guildConst';
import { GuildTrainType, GuildTrainModel, TrainInstance } from '../db/GuildTrain';
import { GuildModel } from '../db/Guild';
import { findWhere } from 'underscore';
@@ -12,7 +12,11 @@ import { MailModel, MailType } from '../db/Mail';
import { getRandomByLen, resResult } from '../pubUtils/util';
import { getRedis } from './redisService';
import { STATUS } from '../consts/statusCode';
import { GuildTrainReportModel } from '../db/GuildTrainReport'
import { GuildTrainReportModel } from '../db/GuildTrainReport';
import { DATA_NAME } from '../consts/dataName';
import { getMailContent } from './mailService';
import { MAIL_TYPE } from '../consts';
export async function getUserGuild(roleId: string, serverId: number) {
let userGuild = await UserGuildModel.getMyGuild(roleId,'trainCount trainTime trainRewards guildCode');
if (!userGuild)
@@ -108,7 +112,7 @@ export async function unlockTrain(code: string, trainId: number) {
}
export async function resetTrain(code: string, serverId: number) {
let res:any = await lockData(serverId, GUILD_DATA_NAME.GUILD, code);//加锁
let res:any = await lockData(serverId, DATA_NAME.GUILD, code);//加锁
if (!!res.err)
return;
let { structure } = await GuildModel.findGuild(code, serverId, 'structure');
@@ -123,7 +127,6 @@ export async function resetTrain(code: string, serverId: number) {
const guildTrains = await GuildTrainModel.getGuildTrainBoxs(code);
let mails = new Array<MailType>();
let pushMessage = [];
let uids = [];
let { shilianRewardRatio } = getTrainBaseByLv(GUILD_STRUCTURE.TRAIN);
userGuildList.forEach(async function ({roleId, trainRewards}) {
@@ -145,22 +148,15 @@ export async function resetTrain(code: string, serverId: number) {
goods.push(...jinjieReward);
}
}
let key = 'login_roleId_' + roleId;
let sid = await getRedis(key);
if (!!goods.length) {
const doc = new MailModel();
const mail = Object.assign(doc.toJSON(), {roleId, goods, sendName: '系统', mailId: 1, sendTime: nowSeconds(), content:'练兵场未领取宝箱奖励和进阶奖励：'});
mails.push(mail);
if (!!sid) {
pushMessage.push({route: 'onMailsAdd', data:[mail], uid: roleId, sid});
}
}
if (!!sid) {
uids.push({ uid: roleId, sid});
if (!!goods.length) {
await getMailContent(roleId, MAIL_TYPE.GUILD_TRAIN_REWARD, [], goods, mails, pushMessage);
}
});
pinus.app.channelService.pushMessageByUids('onGuildTainReset', resResult(STATUS.SUCCESS, {}), uids);
await MailModel.addMails(mails);
pushMessage.forEach(({route, data, uids })=>{
pinus.app.channelService.pushMessageByUids(route, resResult(STATUS.SUCCESS, { mails:data }), uids);
pinus.app.channelService.pushMessageByUids('onGuildTainReset', resResult(STATUS.SUCCESS, {}), uids);
});
await GuildTrainModel.resetGuildTrain(code);
await unlockTrain(code, 1);
await UserGuildModel.resetTrainUserGuild(code);

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

@@ -1,4 +1,4 @@
import { RewardInter, pushMail } from "../pubUtils/interface";
import { RewardInter, pushMail, mailData } from "../pubUtils/interface";
import { MailModel, MailType } from "../db/Mail";
import { getRedis } from "./redisService";
import { pinus } from "pinus";
@@ -6,34 +6,107 @@ import { gameData } from "../pubUtils/data";
import { nowSeconds } from '../pubUtils/timeUtil';
import { STATUS } from '../consts/statusCode';
import { resResult } from '../pubUtils/util';
import { GroupMailModel, GroupMailType } from "../db/GroupMail";
import { findWhere } from "underscore";
import { MAIL_TYPE, MAIL_TEM_TYPE, GM_MAIL_TYPE, MAIL_STATUS } from "../consts/constModules/mailConst";
import { DATA_NAME } from '../consts/dataName';
import { lockData } from './redLockService';
export async function sendMail(operate: number, toRoleId: string, sendName: string = '系统', params: string[] = [], goods: RewardInter[] = []) {
let content = getContent( operate, params);
let mail = await MailModel.addMail({roleId: toRoleId, goods, sendName, mailId: 1, content});
let { content, time } = getContent(operate, params);
if (!content)
return;
let mail = await MailModel.addMail({roleId: toRoleId, goods, sendName, mailId: JSON.stringify(operate), endTime: time + nowSeconds(), mailTemType: MAIL_TEM_TYPE.GAMEMAIL, params});
let key = 'login_roleId_' + toRoleId;
let sid = await getRedis(key);
if (!!sid) {
pinus.app.channelService.pushMessageByUids('onMailsAdd', resResult(STATUS.SUCCESS, { mails:[mail] }), [{uid: toRoleId, sid}]);
pinus.app.channelService.pushMessageByUids('onMailsAdd', resResult(STATUS.SUCCESS, { mails:[{
id: mail._id, mailId: mail.mailId, goods, sendTime: mail.sendTime, endTime: mail.endTime, content, status: mail.status, mailType: MAIL_TYPE.SINGLEMAIL, sendName
}]}), [{uid: toRoleId, sid}]);
}
}
export function getContent(operate: number, params: string[]) {
let content = gameData.mail.get(operate)||'%d';
let mail = gameData.mail.get(operate);
if (!mail)
return {};
let { content, time } = mail;
content = content||'%d';
for(let p of params) {
content = content.replace(/%d/, p);
}
return content
return { content, time }
}
export async function getMailContent(roleId: string, operate: number, params: string[], goods: RewardInter[], mails: MailType[], pushMessage: pushMail[], sendName: string = '系统') {
const doc = new MailModel();
let content = getContent( operate, params);
const mail = Object.assign(doc.toJSON(), { roleId, goods, sendName, mailId: 1, sendTime: nowSeconds(), content });
let { content, time } = getContent(operate, params);
if (!content)
return;
const mail = Object.assign(doc.toJSON(), { roleId, goods, sendName, mailId: operate, sendTime: nowSeconds(), mailTemType: MAIL_TEM_TYPE.GAMEMAIL, endTime: time + nowSeconds(), params });
mails.push(mail);
let key = 'login_roleId_' + roleId;
let sid = await getRedis(key);
if (!!sid) {
pushMessage.push({route: 'onMailsAdd', data:[mail], uids: [{ uid: roleId, sid }]});
pushMessage.push({route: 'onMailsAdd', data:[{
id: mail._id, mailId: mail.mailId, goods, sendTime: mail.sendTime, endTime: mail.endTime, content, status: mail.status, mailType: MAIL_TYPE.SINGLEMAIL, sendName
}], uids: [{ uid: roleId, sid }]});
}
}
export async function refreshMails(roleId: string, sid: string, serverId: number, updatedMailAt: number) {
let res:any = await lockData(serverId, DATA_NAME.GAMEMAIL, roleId);//加锁
let gmMails = await pinus.app.rpc.gm.gmRemote.getMails.toServer('gm-server-1', updatedMailAt, serverId);
let addGroupMails: GroupMailType[] = [];
let addMails: MailType[] = [];
let updateMails: mailData[] = [];
let pushMails: mailData[] = [];
gmMails.forEach(async function ({gmMailType, _id, sendRoles, endTime, content, goods, sendTime, sendName}) {
if (gmMailType == GM_MAIL_TYPE.GROUPMAIL) { //群体邮件
let mail = await GroupMailModel.getMail(_id, MAIL_TEM_TYPE.GMTYPE);
if (!mail) {
const doc = new GroupMailModel();
const mail = Object.assign(doc.toJSON(), { mailId: _id, mailTemType: MAIL_TEM_TYPE.GMTYPE, sendRoles });
addGroupMails.push(mail);
pushMails.push({ id: mail._id, mailId: _id, goods, sendTime, endTime, content, status: mail.status, mailType: MAIL_TYPE.GROUPMAIL, sendName });
} else {
let { sendRoles } = mail;
let sendRole = findWhere(sendRoles, {roleId});
if (!sendRole) {
await GroupMailModel.pushRoleMail(roleId, _id, MAIL_TEM_TYPE.GMTYPE);
pushMails.push({ id: mail._id, mailId: _id, goods, sendTime, endTime, content, status: MAIL_STATUS.CREATE, mailType: MAIL_TYPE.GROUPMAIL, sendName });
}
}
} else if (gmMailType == GM_MAIL_TYPE.SERVER) { //游戏服邮件
let mail = await MailModel.getMail(roleId, _id, MAIL_TEM_TYPE.GMTYPE);
if (!mail) {
const doc = new MailModel();
const mail = Object.assign(doc.toJSON(), { mailId: _id, mailTemType: MAIL_TEM_TYPE.GMTYPE, roleId });
addMails.push(mail);
pushMails.push({ id: mail._id, mailId: _id, goods, sendTime, endTime, content, status: mail.status, mailType: MAIL_TYPE.SINGLEMAIL, sendName });
} else {
updateMails.push({ id: mail._id, mailId: _id, goods, sendTime, endTime, content, status: mail.status, mailType: MAIL_TYPE.SINGLEMAIL, sendName })
}
}
});
if (!!updateMails.length) {
pinus.app.channelService.pushMessageByUids('onMailsUpdate', resResult(STATUS.SUCCESS, { mails: updateMails }), [{uid: roleId, sid}]);
}
if (!!addGroupMails.length) {
await GroupMailModel.addGroupMails(addGroupMails);
}
if (!!addMails.length) {
await MailModel.addMails(addMails);
}
if (!!pushMails.length) {
pinus.app.channelService.pushMessageByUids('onMailsAdd', resResult(STATUS.SUCCESS, { mails: pushMails}), [{uid: roleId, sid}]);
}
res.releaseCallback();
return nowSeconds();
}
export async function getMails(roleId: string, serverId: number) {
let mails = await MailModel.getMailsByRoleId(roleId)||[];
let groupMails = await GroupMailModel.getGroupMailsByRoleId(roleId)||[];
let list: mailData[] = await pinus.app.rpc.gm.gmRemote.getMailInfos.toServer('gm-server-1', roleId, serverId, mails, groupMails);
return list;
}

18
game-server/app/services/refreshService.ts Normal file
View File

@@ -0,0 +1,18 @@
import { FrontendOrBackendSession, pinus } from "pinus";
import { refreshMails } from '../services/mailService';
import { STATUS } from '../consts/statusCode';
import { resResult } from '../pubUtils/util';
import { nowSeconds } from "../pubUtils/timeUtil";
export async function refresh(session: FrontendOrBackendSession) {
const roleId = session.get('roleId');
const sid = session.get('sid');
const serverId: number = parseInt(session.get('serverId'));
let updatedMailAt: number = parseInt(session.get('updatedMailAt')) || 0;
let uids = [{uid: roleId, sid}];
pinus.app.get('channelService').pushMessageByUids('onPushCurrentTime', resResult(STATUS.SUCCESS, {time: Date.now()}), uids);
if (!!roleId && updatedMailAt < nowSeconds() - 5) { //保持最少5秒间隙
session.set('updatedMailAt', nowSeconds());
await refreshMails(roleId, sid, serverId, updatedMailAt);
}
}

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

@@ -8,7 +8,7 @@ import { getPvpGkWarIds, getPvpRankRewards, getPvpHeroRewards, getResultMaxRank
import { deepCopy, getRandomArr, resResult } from '../pubUtils/util';
import { getLvByScore } from './pvpService';
import { getMyRank, setRank, resetPvpRanks } from './redisService';
import { REDIS_KEY } from '../consts';
import { MAIL_TYPE, REDIS_KEY } from '../consts';
import { RankParam } from '../domain/rank';
import { RoleModel } from '../db/Role';
import { MailModel, MailType } from '../db/Mail';
@@ -89,7 +89,7 @@ export async function setPvpDefResultOnTime(pvpDefense: PvpDefenseType, seasonNu
let { score, pLv, heroScores, challengeCnt, challengeRefTime, goods } = await checkResult(pvpDefense, seasonNum, oldSeasonEndTime);
pvpDefense = await PvpDefenseModel.updateInfo(pvpDefense.roleId, {score, pLv, heroScores, seasonNum, challengeCnt, challengeRefTime});
//下发邮件
await getMailContent(pvpDefense.roleId, 1, [], goods, addMails, pushMessage);
await getMailContent(pvpDefense.roleId, MAIL_TYPE.PVP_RANK_REWARD, [], goods, addMails, pushMessage);
return pvpDefense;
}
@@ -153,7 +153,7 @@ export async function setPvpDefResult(pvpDefense: PvpDefenseType, seasonNum: num
let params = new RankParam(roleName, lv, vLv, headHid, sHid, title);
setRank(REDIS_KEY.PVP_RANK, 0, roleId, pvpDefense.score, pvpDefense.updatedAt.getTime(), params);
//下发邮件
await sendMail(1, roleId, '系统', [], goods);
await sendMail(MAIL_TYPE.PVP_RANK_REWARD, roleId, '系统', [], goods);
return pvpDefense;
}