捐献所

game-server/app/servers/battle/handler/guildRefinerHandler.ts

@@ -1,137 +0,0 @@
-import { Application, BackendSession, pinus } from 'pinus';
-import { UserGuildModel } from '../../../db/UserGuild';
-import { resResult } from '../../../pubUtils/util';
-import { STATUS, GUILD_OPERATE } from '../../../consts';
-import { GuildRefineModel } from '../../../db/GuildRefine';
-import { getArmyDevelopConsumeById, getGoodById } from '../../../pubUtils/data';
-import { EquipModel } from '../../../db/Equip';
-import { nowSeconds } from '../../../pubUtils/timeUtil';
-import { handleCost, addItems } from '../../../services/rewardService';
-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';
-
-export default function (app: Application) {
-    return new GuildRefineHandler(app);
-}
-
-export class GuildRefineHandler {
-    constructor(private app: Application) {
-
-    }
-
-    async getRefine(msg: {}, session: BackendSession) {
-        const roleId = session.get('roleId');
-        let userGuild = await UserGuildModel.getMyGuild(roleId, 'guildCode');
-        if (!userGuild) 
-            return resResult(STATUS.WRONG_PARMS); 
-        const { guildCode: code } = userGuild;
-        let { scienceTrees } = await GuildRefineModel.getRefine(code);
-        return resResult(STATUS.SUCCESS, { scienceTrees }); 
-    }   
-
-    async refineEquip(msg: {eid: number}, session: BackendSession) {
-        let { eid } = msg;
-        const roleId: string = session.get('roleId');
-        const sid: string = session.get('sid');
-        const roleName: string = session.get('roleName');
-        let userGuild = await UserGuildModel.getMyGuild(roleId, 'guildCode');
-        if (!userGuild) 
-            return resResult(STATUS.WRONG_PARMS); 
-        let { guildCode: code } = userGuild;
-        let equip = await EquipModel.findbySeqId(eid);
-        if (!equip) return resResult(STATUS.EQUIP_NOT_FIND);
-        let equpInfo = getGoodById(equip.id);
-        let { scienceTrees } = await GuildRefineModel.getRefine(code);
-        let findDevelopConsume;
-        for (let scienceTree of scienceTrees) {
-            if (scienceTree.endTime < nowSeconds()) {
-                let developConsume = getArmyDevelopConsumeById(scienceTree.id);
-                if (developConsume.quality && developConsume.levelMax >= equpInfo.lvLimited && equpInfo.lvLimited <= developConsume.levelMin) {
-                    findDevelopConsume = developConsume;
-                    break;
-                }
-            }
-        }
-        if (!findDevelopConsume) 
-            return resResult(STATUS.GUILD_NOT_REFINE_THE_EQUIP);
-      
-        let result = await handleCost(roleId, sid, findDevelopConsume.honourConsume);
-        if(!result) 
-            return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
-        let goods = await addItems(roleId, roleName, sid, [{id: eid, count: 1}]);
-        return resResult(STATUS.SUCCESS, { goods }); 
-    }   
-
-    async lightUpTree(msg: {id: number}, session: BackendSession) {
-        let { id } = msg;
-        const roleId: string = session.get('roleId');
-        const serverId: number = session.get('serverId');
-        let userGuild = await UserGuildModel.getMyGuild(roleId, 'auth guildCode');
-        if (!userGuild) 
-            return resResult(STATUS.WRONG_PARMS); 
-        const checkMyResult = await checkAuth(GUILD_OPERATE.EQUIP_PRODUCE, roleId, null, userGuild);
-        if(!checkMyResult) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
-        const { guildCode: code } = userGuild;
-        let developConsume = getArmyDevelopConsumeById(id);
-        if (!developConsume)
-            return resResult(STATUS.WRONG_PARMS); 
-        let res:any = await lockData(serverId, GUILD_DATA_NAME.GUILD_REFINE, code);//加锁
-        if (!!res.err) 
-            return resResult(STATUS.REDLOCK_ERR); 
-        let guildRefine = await GuildRefineModel.getRefine(code);
-        for (let scienceTree of  guildRefine.scienceTrees) {
-            if (scienceTree.id == id) 
-                return resResult(STATUS.GUILD_LIGHT_UP_THE_SCIENCETREE);
-            
-            if (scienceTree.endTime > nowSeconds()) 
-                return resResult(STATUS.GUILD_SCIENCETREE_IS_RUNNING);
-        }
-        const costResult = await GuildModel.costFund(code, developConsume.fundConsume);
-        if(!costResult) 
-            return resResult(STATUS.GUILD_FUND_NOT_ENOUGH);
-        let scienceTree = { id, endTime: nowSeconds() + developConsume.timeConsume, assistRoleIds: []}
-        let { scienceTrees } = await GuildRefineModel.pushRefine(code, scienceTree);
-        res.releaseCallback();
-        return resResult(STATUS.SUCCESS, { scienceTrees }); 
-    }
-
-    async assistRefine(msg: {id: number}, session: BackendSession) {
-        let { id } = msg;
-        const roleId: string = session.get('roleId');
-        const serverId: number = session.get('serverId');
-        const sid: string = session.get('sid');
-
-        let userGuild = await UserGuildModel.getMyGuild(roleId, 'guildCode');
-        if (!userGuild) 
-            return resResult(STATUS.WRONG_PARMS); 
-        const { guildCode: code } = userGuild;
-        let res:any = await lockData(serverId, GUILD_DATA_NAME.GUILD_ASSIST_REFINE, code);//加锁
-        if (!!res.err) 
-            return resResult(STATUS.REDLOCK_ERR); 
-        let guildRefine = await GuildRefineModel.getRefine(code);
-        
-        let index = findIndex(guildRefine.scienceTrees, { id });
-        if (index == -1) 
-            return resResult(STATUS.WRONG_PARMS);
-        let scienceTree = guildRefine.scienceTrees[index];
-        if (!!scienceTree.assistRoleIds.indexOf(roleId)) 
-            return resResult(STATUS.GUILD_IS_ASSISTED_SCIENCETREE); 
-        if (scienceTree.assistRoleIds.length >= ARMY.ARMY_DEVELOPMENT_SPEEDTMES) 
-            return resResult(STATUS.GUILD_REACH_MAX_ASSIST_COUNT); 
-
-        let result = await handleCost(roleId, sid, [{id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.GOLD), count: ARMY.ARMY_DEVELOPMENT_SPEEDCOST}]);
-        if(!result) 
-            return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);   
-        scienceTree.assistRoleIds.push(roleId);
-        scienceTree.endTime -= scienceTree.endTime - ARMY.ARMY_DEVELOPMENT_SPEED * 60;
-
-        let { scienceTrees } = await GuildRefineModel.updateRefine(code, { scienceTrees: guildRefine.scienceTrees })
-        res.releaseCallback();
-        return resResult(STATUS.SUCCESS, { scienceTrees }); 
-    }
-}

game-server/app/servers/battle/handler/wishPoolHandler.ts

@@ -12,6 +12,7 @@ import { getUserGuildWithRefActive } from '../../../services/guildService';
 import { findIndex, findWhere } from 'underscore';
 import { RoleModel } from '../../../db/Role';
 import { getRedis } from '../../../services/redisService';
+import { ARMY } from '../../../pubUtils/dicParam';
 export default function(app: Application) {
     return new WishPoolHandler(app);
 }
@@ -67,8 +68,12 @@ export class WishPoolHandler {
         let { structure } = await GuildModel.findGuild(code, serverId, 'structure');
         let { lv } = findWhere(structure, {id: GUILD_STRUCTURE.DONATE});
         let { wishGoodsEquips, wishGoodsHeros } = getArmyWishPoolBaseByLv(lv);
-        let len = wishGoods.length;
+        let len = 0;
-        if (len >= 1)  //今日已经许愿过
+        wishGoods.map(({type: resType})=>{
+            if (resType == type)
+                len++;
+        });
+        if (len >= ARMY.ARMY_WISH_TIMES)  //今日已经许愿过
             return resResult(STATUS.WRONG_PARMS);
         if (type == 1) {
             let wishGoodsEquip = findWhere(wishGoodsEquips, { quality: goodInfo.quality});
@@ -81,9 +86,8 @@ export class WishPoolHandler {
                 return resResult(STATUS.WRONG_PARMS);
             count = wishGoodsHero.count;
         }
-       
         const id = genCode(6);
-        let { wishGoods : resWishGoods } = await UserGuildModel.pushAndUpdate(roleId, {}, { wishGoods: { type, goodId, count, receiveCnt: 0, drawCnt: 0, id} }, 'wishGoods');
+        let { wishGoods: resWishGoods } = await UserGuildModel.pushAndUpdate(roleId, {}, { wishGoods: { type, goodId, count, receiveCnt: 0, drawCnt: 0, id} }, 'wishGoods');
         return resResult(STATUS.SUCCESS, { wishGoods: resWishGoods });
     }
 
@@ -106,13 +110,13 @@ export class WishPoolHandler {
             return resResult(STATUS.WRONG_PARMS);
         if (dntRoleGuild.guildCode != code) 
             return resResult(STATUS.WRONG_PARMS);
-        if (dntRoleGuild.wishDntCnt >= 3) 
+        if (dntRoleGuild.wishDntCnt >= ARMY.ARMY_WISH_HELP) 
-            return resResult(STATUS.WRONG_PARMS);
+            return resResult(STATUS.HAS_REACH_WISH_COUNT_LIMIT);
         let wishGood = findWhere(wishGoods, { id });
         if (!wishGood) 
             return resResult(STATUS.WRONG_PARMS);//没有该许愿
         if (wishGood.receiveCnt >= wishGood.count)
-            return resResult(STATUS.WRONG_PARMS);//已经收到
+            return resResult(STATUS.HAS_RECEIVE_WISH_GOOD);//已经收到
         let { wishDntCnt } = await UserGuildModel.donateGoods(dntRoleId, 1, 'wishDntCnt');
         let { wishGoods: resWishGoods } = await UserGuildModel.donateUpdate(wishRoleId, id, 'wishGoods');
         let key = 'login_roleId_' + wishRoleId; 
@@ -123,8 +127,9 @@ export class WishPoolHandler {
         }
         await WishPoolReportModel.addReport(code, wishRoleId, role.roleName , dntRoleId, dntRoleName, wishGood.goodId, 1);
         return resResult(STATUS.SUCCESS, { wishDntCnt, updateWishGoods: resWishGoods.map(({type, goodId, count, receiveCnt, drawCnt, id})=>{
-            return { type, goodId, count, receiveCnt, drawCnt, id, roleId: wishRoleId };
+                return { type, goodId, count, receiveCnt, drawCnt, id, roleId: wishRoleId };
-        })});
+            })
+        });
     }
 
     async receiveGoods(msg: { id: string }, session: BackendSession) {
@@ -157,5 +162,4 @@ export class WishPoolHandler {
         const reports = await WishPoolReportModel.getReportsByTime(code, 1);//获得今天的捐赠日报
         return resResult(STATUS.SUCCESS, { reports });
     }
-    
 } 

game-server/app/services/donateService.ts

@@ -1,6 +1,6 @@
 
 import { DonationModel } from '../db/Donation';
-import { nowSeconds } from '../pubUtils/timeUtil';
+import { getTodayZeroPoint, nowSeconds } from '../pubUtils/timeUtil';
 import { GuildModel } from '../db/Guild';
 import { findWhere } from 'underscore';
 import { GUILD_STRUCTURE } from '../consts/constModules/guildConst';
@@ -9,7 +9,7 @@ export async function getDonation(code: string, serverId: number) {
     if (!donation) {
         donation = await createDonation(code, serverId);
     }
-    if (donation.refTime < nowSeconds()) {
+    if (donation.refTime < getTodayZeroPoint()) {
         let { structure } = await GuildModel.findGuild(code, serverId, 'structure');
         let { lv } = findWhere(structure, {id: GUILD_STRUCTURE.DONATE});
         donation = await DonationModel.updateDonation(code, { donateFund:0, reports:[], refTime: nowSeconds(), donationLv: lv});

game-server/app/services/guildTrainService.ts

@@ -41,8 +41,7 @@ export async function recordUserGuild(roleId: string, code: string) {
 }
 
 export function getGuildTrain (guildTrains, trainCount:number, trainRewards: Array<number>) {
-    let list = [];
+    let list = guildTrains.map(({trainId, isComplete})=>{
-    list = guildTrains.map(({trainId, isComplete})=>{
         return ({trainId, isComplete, });
     });
     return { list, trainCount, trainRewards};

game-server/app/services/mailService.ts

@@ -25,15 +25,15 @@ export function getContent(operate: number, params: string[]) {
     }
     return content
 }
-export async function getMailContent(roleId: string, operate: number, params: string[], goods:RewardInter[], mails:MailType[], pushMessage:pushMail[], sendName: string = '系统') {
+
+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 });
-    const mail = Object.assign(doc.toJSON(), {roleId, goods, sendName, mailId: 1, sendTime: nowSeconds(), content});
     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:[mail], uids: [{ uid: roleId, sid }]});
     }
 }

game-server/app/services/timeTaskService.ts

@@ -7,7 +7,7 @@ import { nowSeconds, getTodayZeroPoint } from '../pubUtils/timeUtil';
 import { getPvpGkWarIds, getPvpRankRewards, getPvpHeroRewards, getResultMaxRank } from '../pubUtils/data';
 import { deepCopy, getRandomArr, resResult } from '../pubUtils/util';
 import { getLvByScore } from './pvpService';
-import { getMyRank, setRank, getRedis, resetPvpRanks } from './redisService';
+import { getMyRank, setRank, resetPvpRanks } from './redisService';
 import { REDIS_KEY } from '../consts';
 import { RankParam } from '../domain/rank';
 import { RoleModel } from '../db/Role';
@@ -17,10 +17,10 @@ import { indexOf } from 'underscore';
 import { PvpSeasonResultModel } from '../db/PvpSeasonResult';
 import { settleGuildWeekly } from './guildService';
 import { STATUS } from '../consts/statusCode';
+import { getMailContent, sendMail } from './mailService';
 const PER_SECOND = 1 * 1000;
 const PER_DAY = 24 * 60 * 60;
 const SETTLE_DIFF = 29 * 60;
-const LIMIT_NUM = 1000;
 const pageNum = 500;
 const PER_MINUTE = 1 * 60;
 var seasonJobId;
@@ -47,9 +47,7 @@ export async function init() {
         } 
     }
     let settleTime = (seasonEndTime - SETTLE_DIFF)* PER_SECOND;
-    console.log(' settleTime = ' + settleTime);
     seasonJobId = scheduleJob(settleTime, setPvpSeasonResult, { name: 'setPvpSeasonResult' });
-    console.log(' settleTime111111 = ' + (seasonEndTime -  PER_MINUTE)* PER_SECOND);
 
     seasonEndTimeJobId = scheduleJob((seasonEndTime -  PER_MINUTE)* PER_SECOND, resetPvpRanks, { name: 'resetRank' });
     warJobId = scheduleJob("0 0 0 * * 3", resetPvpWarId);
@@ -81,26 +79,17 @@ export async function setPvpSeasonResult(obj:{ name:string, notSetNext?: boolean
             continue;
         }
         for (let message of pushMessage) {      
-            pinus.app.rpc.connector.connectorRemote.pushMessage.toServer(message.sid, message.uid, message.route, message.data);
+            pinus.app.channelService.pushMessageByUids('onMailsAdd', resResult(STATUS.SUCCESS, { mails: message.data }), [{uid: message.uid, sid: message.sid}]);
         }
     }
     return { seasonNum, seasonEndTime, oldSeasonEndTime};
 }
 
 export async function setPvpDefResultOnTime(pvpDefense: PvpDefenseType, seasonNum: number, oldSeasonEndTime: number, addMails: Array<MailType>, pushMessage:Array<any>) {
-
     let { score, pLv, heroScores, challengeCnt, challengeRefTime, goods } = await checkResult(pvpDefense, seasonNum, oldSeasonEndTime);
     pvpDefense = await PvpDefenseModel.updateInfo(pvpDefense.roleId, {score, pLv, heroScores, seasonNum, challengeCnt, challengeRefTime});
-
     //下发邮件
-    const doc = new MailModel();
+    await getMailContent(pvpDefense.roleId, 1, [], goods, addMails, pushMessage);
-    const mail = Object.assign(doc.toJSON(), {roleId: pvpDefense.roleId, goods, sendName: '系统', mailId: 1, sendTime: oldSeasonEndTime});
-    addMails.push(mail);
-    let key = 'login_roleId_' + pvpDefense.roleId; 
-    let sid = await getRedis(key);
-    if (!!sid) {
-        pushMessage.push({route: 'onMailsAdd', data:[mail], uid: pvpDefense.roleId, sid});
-    }
     return pvpDefense;
 }
 
@@ -130,7 +119,7 @@ export async function checkResult(pvpDefense: PvpDefenseType, seasonNum: number,
     for (let i = 0; i < pvpDefense.heroScores.length; i++) {
         let heroScore = pvpDefense.heroScores[i];
         let pvpHeroReward = getScore(pvpHeroRewards, heroScore.score);
-        if(pvpHeroReward) {
+        if (pvpHeroReward) {
             goods = goods.concat(pvpHeroReward.reward);
             heroScore.score = pvpHeroReward.heroscore;
             if (!!pvpHeroReward.reward[0]) {
@@ -147,7 +136,7 @@ export async function checkResult(pvpDefense: PvpDefenseType, seasonNum: number,
     await PvpSeasonResultModel.updatePvpSeasonResult(pvpDefense.roleId, { 
         oldSeasonData:{refOppCnt: pvpDefense.refOppCnt, rankLv, score: pvpDefense.score, pLv: oldPLv, heroScores: oldHeroScores, 
             seasonNum: pvpDefense.seasonNum, challengeCnt, challengeRefTime, seasonEndTime: oldSeasonEndTime
-        }, heroGoods, rankGoods, show: true});
+        }, heroGoods, rankGoods, show: true });
     return { rankLv, score, pLv, heroScores: pvpDefense.heroScores, seasonNum, challengeCnt:PVP.PVP_CHALLENGE_COUNTS, challengeRefTime:0, oldSeasonEndTime, goods};
 }
 
@@ -162,14 +151,9 @@ export async function setPvpDefResult(pvpDefense: PvpDefenseType, seasonNum: num
     pvpDefense = await PvpDefenseModel.updateInfoAndInclude(pvpDefense.roleId, {score, pLv, heroScores, seasonNum, challengeCnt, challengeRefTime});
     let { roleName, lv, vLv, headHid, sHid, title , roleId } = role;
     let params = new RankParam(roleName, lv, vLv, headHid, sHid, title);
-    setRank(REDIS_KEY.PVP_RANK, 0, pvpDefense.roleId, pvpDefense.score, pvpDefense.updatedAt.getTime(), params);
+    setRank(REDIS_KEY.PVP_RANK, 0, roleId, pvpDefense.score, pvpDefense.updatedAt.getTime(), params);
     //下发邮件
-    let mail = await MailModel.addMail({roleId, goods, sendName: '系统', mailId: 1, sendTime: oldSeasonEndTime});
+    await sendMail(1, roleId, '系统', [], goods);
-    let key = 'login_roleId_' + roleId; 
-    let sid = await getRedis(key);
-    if (!!sid) {
-        pinus.app.channelService.pushMessageByUids('onMailsAdd', resResult(STATUS.SUCCESS, { mails:[mail] }), [{uid: roleId, sid}]);
-    }
     return pvpDefense;
 }
 
@@ -187,7 +171,7 @@ export async function resetPvpWarId() {
 }
 
 async function setNextPvpTime(notSetNext: boolean) {
-    let {seasonEndTime, seasonNum} = await SystemConfigModel.findSystemConfig();
+    let { seasonEndTime, seasonNum } = await SystemConfigModel.findSystemConfig();
     if (!!notSetNext) {
         return { seasonEndTime, seasonNum , oldSeasonEndTime: 0};
     }

shared/consts/statusCode.ts

@@ -154,6 +154,8 @@ export const STATUS = {
     GUILD_DONATE_BOXS_NOT_GOT: { code: 20924, simStr: '该捐献宝箱未达到领取条件' },
     GUILD_WISH_POOL_NOT_OWN_EQUIP: { code: 20926, simStr: '未拥有此装备或碎片，不能许愿' },
     GUILD_WISH_POOL_NOT_OWN_HERO: { code: 20927, simStr: '未拥有此武将或碎片，不能许愿' },
+    HAS_REACH_WISH_COUNT_LIMIT: { code: 20928, simStr: '今日许愿次数已用完，不能许愿' },
+    HAS_RECEIVE_WISH_GOOD: { code: 20929, simStr: '玩家已经收到许愿物品' },
 
     GUILD_SCRIPT_IS_OPENED_TODAY: { code: 20950, simStr: '今日演武场已开启' },
     GUILD_SCRIPT_NOT_OPENED: { code: 20951, simStr: '演武场未开启' },

shared/db/Mail.ts

@@ -26,11 +26,14 @@ export default class Mail extends BaseModel {
     @prop({ required: true })
     content: string; 
 
-    public static async addMails( mails: Array<MailType>) {
+    @prop({ required: true, default: 0 })
+    status: number; 
+
+    public static async addMails(mails: Array<MailType>) {
         await MailModel.insertMany(mails);
     }
 
-    public static async addMail(params:{roleId: string, goods: Array<RewardInter>, sendName: string, mailId: number, sendTime?: number, content?:string}) {
+    public static async addMail(params:{ roleId: string, goods: Array<RewardInter>, sendName: string, mailId: number, sendTime?: number, content?:string }) {
         const doc = new MailModel();
         const mail = Object.assign(doc.toJSON(), params);
         await MailModel.create(mail);

shared/pubUtils/dictionary/DicStructure.ts

@@ -210,7 +210,7 @@ const strDonate = readJsonFile(FILENAME.DIC_GUILD_DONATE_BASE);
 let arrDonate = JSON.parse(strDonate);
 arrDonate.forEach(o => {
     setStructureConsume(o);
-    o.donateReward = parseDonateReward(o.donatevalue, o.donateReward, o.fundReward);
+    o.donateReward = parseDonateReward(o.donatevalue, o.honourReward, o.fundReward);
     dicDonateBase.set(o.level, _.pick(o, Object.keys(DicDonateKeys)));
 });
 arrDonate = undefined;