数数：消耗来源

game-server/app/servers/activity/handler/activityMonopolyHandler.ts

@@ -1,6 +1,6 @@
 import { Application, BackendSession, HandlerService } from 'pinus';
 import { resResult } from '../../../pubUtils/util';
-import { LAND_TYPE, STATUS, CURRENCY_TYPE, CURRENCY_BY_TYPE, BANK_TYPE, ACTIVITY_RESOURCES_TYPE } from '../../../consts';
+import { LAND_TYPE, STATUS, CURRENCY_TYPE, CURRENCY_BY_TYPE, BANK_TYPE, ACTIVITY_RESOURCES_TYPE, ITEM_CHANGE_REASON } from '../../../consts';
 import { ActivityMonopolyModel, ActivityMonopolyModelType } from '../../../db/ActivityMonopoly';
 import { ActivityMonopolyLandModel, ActivityMonopolyLandModelType } from '../../../db/ActivityMonopolyLand';
 import { getPlayerMonopolyData, nextPosition } from '../../../services/activity/monopolyService';
@@ -58,12 +58,12 @@ export class ActivityMonopolyHandler {
         let moveStep = 0;
         if (step >= 1 && step <= 6) {//指定，天机骰子
             //检查资源
-            let consumeResult = await handleCost(roleId, sid, [{ id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.SPECIAL_DICE), count: 1 }]);
+            let consumeResult = await handleCost(roleId, sid, [{ id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.SPECIAL_DICE), count: 1 }], ITEM_CHANGE_REASON.MONOPOLY_MOVE);
             if (!consumeResult) return resResult(STATUS.ACTIVITY_RES_NOT_ENOUGH);
             moveStep = step;
         } else {//普通骰子
             //检查资源
-            let consumeResult = await handleCost(roleId, sid, [{ id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.NORMAL_DICE), count: 1 }]);
+            let consumeResult = await handleCost(roleId, sid, [{ id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.NORMAL_DICE), count: 1 }], ITEM_CHANGE_REASON.MONOPOLY_MOVE);
             if (!consumeResult) return resResult(STATUS.ACTIVITY_RES_NOT_ENOUGH);
             moveStep = random(5) + 1;
         }
@@ -81,7 +81,7 @@ export class ActivityMonopolyHandler {
             if (landData.rewards.length > landData.stopCount) {
                 let reward = landData.rewards[landData.level - 1];
                 let rewardArray = stringToRewardParam(reward)
-                landReward = await addReward(roleId, roleName, sid, serverId, rewardArray);
+                landReward = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.MONOPOLY_MOVE);
             }
 
             //土地升级
@@ -97,7 +97,7 @@ export class ActivityMonopolyHandler {
                 if (records.length < landData.takeOutMax) {
                     let resource = landData.record[0].resource;
                     let rewardArray = stringToRewardParam(resource)
-                    bankReward = await addReward(roleId, roleName, sid, serverId, rewardArray);
+                    bankReward = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.MONOPOLY_MOVE);
                     let recordResult = await ActivityMonopolyLandModel.addRecord(serverId, activityId, roleId, newPosition, BANK_TYPE.OUT, resource);
                     landData.record = recordResult.record;
                 }
@@ -109,7 +109,7 @@ export class ActivityMonopolyHandler {
                 if (records.length < landData.takeOutMax) {
                     let resource = landData.record[0].resource;
                     let rewardArray = stringToRewardParam(resource)
-                    bankReward = await addReward(roleId, roleName, sid, serverId, rewardArray);
+                    bankReward = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.MONOPOLY_MOVE);
                     let recordResult = await ActivityMonopolyLandModel.addRecord(serverId, activityId, roleId, newPosition, BANK_TYPE.OUT, resource);
                     landData.record = recordResult.record;
                 }
@@ -157,12 +157,12 @@ export class ActivityMonopolyHandler {
                 || landData.landType == LAND_TYPE.BANK_NORMAL) {
                 resrouseStr = `${ACTIVITY_RESOURCES_TYPE.GOODS}&${CURRENCY_BY_TYPE.get(CURRENCY_TYPE.COIN)}&${addCount}`
                 //检查资源
-                let consumeResult = await handleCost(roleId, sid, [{ id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.COIN), count: addCount }]);
+                let consumeResult = await handleCost(roleId, sid, [{ id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.COIN), count: addCount }], ITEM_CHANGE_REASON.MONOPOLY_BANK);
                 if (!consumeResult) return resResult(STATUS.ACTIVITY_RES_NOT_ENOUGH);
             } else if (landData.landType == LAND_TYPE.BANK_GOLD) {
                 resrouseStr = `${ACTIVITY_RESOURCES_TYPE.GOODS}&${CURRENCY_BY_TYPE.get(CURRENCY_TYPE.GOLD)}&${addCount}`
                 //检查资源
-                let consumeResult = await handleCost(roleId, sid, [{ id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.GOLD), count: addCount }]);
+                let consumeResult = await handleCost(roleId, sid, [{ id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.GOLD), count: addCount }], ITEM_CHANGE_REASON.MONOPOLY_BANK);
                 if (!consumeResult) return resResult(STATUS.ACTIVITY_RES_NOT_ENOUGH);
             }
 
@@ -239,11 +239,11 @@ export class ActivityMonopolyHandler {
 
         //检查资源
         let consume = stringToConsumeParam(item.consume)
-        let consumeResult = await handleCost(roleId, sid, consume);
+        let consumeResult = await handleCost(roleId, sid, consume, ITEM_CHANGE_REASON.MONOPOLY_BUY_GOODS);
         if (!consumeResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
 
         let rewardArray = stringToRewardParam(item.reward)
-        let result = await addReward(roleId, roleName, sid, serverId, rewardArray);
+        let result = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.MONOPOLY_BUY_GOODS);
 
         await ActivityRefreshShopModel.addRecord(shopActivityId, roleId, roundIndex, pageIndex, id);
 

game-server/app/servers/activity/handler/dailyChallengesHandler.ts

@@ -1,6 +1,6 @@
 import { Application, BackendSession, HandlerService } from 'pinus';
 import { resResult } from '../../../pubUtils/util';
-import { STATUS } from '../../../consts';
+import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
 import { getPlayerDailyChallengesData } from '../../../services/activity/dailyChallengesService';
 import { DailyItem } from '../../../domain/activityField/dailyChallengesField';
 import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
@@ -68,7 +68,7 @@ export class DailyChallengesHandler {
         await ActivityDailyChallengesModel.addCellRecord(serverId, activityId, roleId, dayIndex, cellIndex, type, 1);
 
         let rewardParamArr: Array<RewardParam> = stringToRewardParam(dailyItemData.reward);
-        let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr)
+        let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.DAILY_CHALLENGE_REWARD)
 
         dailyItemData.receiveRewardCount = 1;
         return resResult(STATUS.SUCCESS, Object.assign(result, {

game-server/app/servers/activity/handler/dailyCoinHandler.ts

@@ -1,6 +1,6 @@
 import { Application, BackendSession, HandlerService } from 'pinus';
 import { resResult } from '../../../pubUtils/util';
-import { ACTIVITY_RESOURCES_TYPE, CURRENCY_BY_TYPE, CURRENCY_TYPE, STATUS } from '../../../consts';
+import { ACTIVITY_RESOURCES_TYPE, CURRENCY_BY_TYPE, CURRENCY_TYPE, ITEM_CHANGE_REASON, STATUS } from '../../../consts';
 import { handleCost } from '../../../services/rewardService';
 import { getPlayerDailyCoinData, mergeData } from '../../../services/activity/dailyCoinService';
 import { ConsumeExchangeFormulaItem, CoinRewardFormulaItem } from '../../../domain/activityField/dailyCoinField';
@@ -106,7 +106,7 @@ export class DailyCoinHandler {
         console.log('所有奖励', JSON.stringify(newReward))
 
         //检查资源
-        let consumeResult = await handleCost(roleId, sid, newConsume);
+        let consumeResult = await handleCost(roleId, sid, newConsume, ITEM_CHANGE_REASON.DAILY_COIN_EXCHANGE);
         if (!consumeResult) return resResult(STATUS.ACTIVITY_RES_NOT_ENOUGH);
 
         let addCoin = 0
@@ -127,7 +127,7 @@ export class DailyCoinHandler {
 
         //免费期间
         let time = moment(new Date()).valueOf();
-        let result = await addReward(roleId, roleName, sid, serverId, newReward)
+        let result = await addReward(roleId, roleName, sid, serverId, newReward, ITEM_CHANGE_REASON.DAILY_COIN_EXCHANGE);
         await ActivityDailyCoinModel.addExchangeRecord(serverId, activityId, roleId, playerData.roundIndex, count, addCoin, `${count}&${consumeGold}&${addCoin}&${time}`);
 
         let exchangeCount = playerData.exchangeCount + count;

game-server/app/servers/activity/handler/dailyGiftsHandler.ts

@@ -1,6 +1,6 @@
 import { Application, BackendSession, HandlerService, } from 'pinus';
 import { resResult } from '../../../pubUtils/util';
-import { STATUS, ACTIVITY_RESOURCES_TYPE } from '../../../consts';
+import { STATUS, ACTIVITY_RESOURCES_TYPE, ITEM_CHANGE_REASON } from '../../../consts';
 import { handleCost } from '../../../services/rewardService';
 import { getPlayerDailyGiftsData } from '../../../services/activity/dailyGiftsService';
 import { DailyGiftItem } from '../../../domain/activityField/dailyGiftsField';
@@ -72,7 +72,7 @@ export class DailyGiftsHandler {
         let consumeType = consumeData.type;//购买类型
 
         if (consumeType == ACTIVITY_RESOURCES_TYPE.GOODS) {//物品表，元宝、金币、体力
-            let result = await handleCost(roleId, sid, [{ id: consumeData.id, count: consumeData.count }]);
+            let result = await handleCost(roleId, sid, [{ id: consumeData.id, count: consumeData.count }], ITEM_CHANGE_REASON.BUY_DAILY_GIFTS);
             if (!result) return resResult(STATUS.ACTIVITY_RES_NOT_ENOUGH);
         } else if (consumeType == ACTIVITY_RESOURCES_TYPE.RMB) {//RMB购买
             return resResult(STATUS.ACTIVITY_NEED_PAY);
@@ -81,7 +81,7 @@ export class DailyGiftsHandler {
         await ActivityDailyGiftsModel.buyRecord(serverId, activityId, roleId, dayIndex, cellIndex, 1);
 
         let rewardParamArr: Array<RewardParam> = stringToRewardParam(dailyItemData.reward);
-        let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr)
+        let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.BUY_DAILY_GIFTS)
 
         dailyItemData.buyCount += 1;
         return resResult(STATUS.SUCCESS, Object.assign(result, {

game-server/app/servers/activity/handler/dailyMealHandler.ts

@@ -1,6 +1,6 @@
 import { Application, BackendSession, HandlerService, } from 'pinus';
 import { resResult } from '../../../pubUtils/util';
-import { STATUS } from '../../../consts';
+import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
 import { handleCost } from '../../../services/rewardService';
 import { getPlayerDailyMealData } from '../../../services/activity/dailyMealService';
 import { DailyMealItem } from '../../../domain/activityField/dailyMealField';
@@ -71,12 +71,12 @@ export class DailyMealHandler {
         if (curDate > itemData.endTime) {//补领
             //检查资源
             let consume = stringToConsumeParam(itemData.consume)
-            let consumeResult = await handleCost(roleId, sid, consume);
+            let consumeResult = await handleCost(roleId, sid, consume, ITEM_CHANGE_REASON.DAILY_MEAL_RECEIVE_REPAIRE);
             if (!consumeResult) return resResult(STATUS.ACTIVITY_RES_NOT_ENOUGH);
         }
         //免费期间
         let rewardParamArr: Array<RewardParam> = stringToRewardParam(itemData.reward);
-        let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr)
+        let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.DAILY_MEAL_RECEIVE);
         await ActivityDailyMealModel.addReceiveRecord(serverId, activityId, roleId, type, curDate, playerData.roundIndex);
         itemData.isReceive = true;
         return resResult(STATUS.SUCCESS, Object.assign(result, {

game-server/app/servers/activity/handler/dailyRMBGiftsHandler.ts

@@ -1,6 +1,6 @@
 import { Application, BackendSession, HandlerService, } from 'pinus';
 import { resResult } from '../../../pubUtils/util';
-import { STATUS, } from '../../../consts';
+import { ITEM_CHANGE_REASON, STATUS, } from '../../../consts';
 import { getPlayerDailyRMBGiftsData } from '../../../services/activity/dailyRMBGiftsService';
 import { RewardParam } from '../../../domain/activityField/rewardField';
 import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
@@ -65,7 +65,7 @@ export class DailyRMBGiftsHandler {
                 return resResult(STATUS.ACTIVITY_NEED_PAY);
             }
             let rewardParamArr: Array<RewardParam> = stringToRewardParam(item.reward);
-            let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr)
+            let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.DAILY_RMB_GIFT)
             await ActivityDailyRMBGiftsModel.receiveRecord(serverId, activityId, roleId, moment(playerData.beginTime).toDate(), [item.id]);
             item.isReceive = true;
             return resResult(STATUS.SUCCESS, Object.assign(result, {
@@ -88,7 +88,7 @@ export class DailyRMBGiftsHandler {
                 rewardArray = rewardArray.concat(rewardParamArr);
                 item.isReceive = true;
             }
-            let result = await addReward(roleId, roleName, sid, serverId, rewardArray)
+            let result = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.DAILY_RMB_GIFT)
             await ActivityDailyRMBGiftsModel.receiveRecord(serverId, activityId, roleId, moment(playerData.beginTime).toDate(), ids);
             return resResult(STATUS.SUCCESS, Object.assign(result, {
                 param: { activityId },

game-server/app/servers/activity/handler/firstGiftHandler.ts

@@ -1,6 +1,6 @@
 import { Application, BackendSession, HandlerService, } from 'pinus';
 import { resResult } from '../../../pubUtils/util';
-import { FIRST_GIFT_STATE, STATUS } from '../../../consts';
+import { FIRST_GIFT_STATE, ITEM_CHANGE_REASON, STATUS } from '../../../consts';
 import { getPlayerFirstGiftData } from '../../../services/activity/firstGiftService';
 import { RoleModel } from '../../../db/Role';
 import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
@@ -74,7 +74,7 @@ export class FirstGiftHandler {
             indexArray.push(item.index)
             item.isReceive = true;
         }
-        let result = await addReward(roleId, roleName, sid, serverId, rewardArray);
+        let result = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.FIRST_GIFT);
 
         let isOver = playerData.isComplete();
 

game-server/app/servers/activity/handler/gachaHandler.ts

@@ -1,6 +1,6 @@
 import { Application, BackendSession, HandlerService, } from "pinus";
 import { resResult, shouldRefresh, getRandSingleEelm } from "../../../pubUtils/util";
-import { STATUS, GACHA_ID, HERO_QUALITY_TYPE, TASK_TYPE, } from "../../../consts";
+import { STATUS, GACHA_ID, HERO_QUALITY_TYPE, TASK_TYPE, ITEM_CHANGE_REASON, } from "../../../consts";
 import { gameData } from "../../../pubUtils/data";
 import { GachaResult, GachaData } from "../../../domain/activityField/gachaField";
 import { UserGachaModel } from "../../../db/UserGacha";
@@ -85,13 +85,13 @@ export class GachaHandler {
         // 消耗东西
         if (costNum > 0) {
             let cost = dicGacha.cost.map(cur => { return { id: cur.id, count: cur.count * costNum } });
-            let costResult = await handleCost(roleId, sid, cost);
+            let costResult = await handleCost(roleId, sid, cost, ITEM_CHANGE_REASON.GACHA_PULL);
             if (!costResult) return resResult(STATUS.GACHA_COST_NOT_ENOUGH);
         }
         // 给东西
         // console.log('****', heroInfo)
         let { heroes, resultHeroes } = await createHeroes(roleId, roleName, sid, serverId, heroInfo);
-        await addItems(roleId, roleName, sid, items);
+        await addItems(roleId, roleName, sid, items, ITEM_CHANGE_REASON.GACHA_ITEMS);
         // 更新数据
         userGacha = await UserGachaModel.updateInfo(roleId, gachaId, activityId, {
             freeCount, hope, floor, count: historyCount + count
@@ -328,7 +328,7 @@ export class GachaHandler {
 
         visitedHero.push(hid);
         let userGacha = await UserGachaModel.updateInfo(roleId, GACHA_ID.NORMAL, 0, { visitedHero, refVisitedTime });
-        let goods = await addItems(roleId, roleName, sid, [{ id: pieceId, count: RECRUIT.RECRUIT_SHARD_LIMIT }]);
+        let goods = await addItems(roleId, roleName, sid, [{ id: pieceId, count: RECRUIT.RECRUIT_SHARD_LIMIT }], ITEM_CHANGE_REASON.VISIT_HERO);
 
         return resResult(STATUS.SUCCESS, {
             hids: userGacha.visitedHero,
@@ -376,7 +376,7 @@ export class GachaHandler {
         if(guideCount == 0) {
             // 消耗东西
             let cost = dicGacha.cost.map(cur => { return { id: cur.id, count: cur.count * count } });
-            let costResult = await handleCost(roleId, sid, cost);
+            let costResult = await handleCost(roleId, sid, cost, ITEM_CHANGE_REASON.GACHA_PULL);
             if (!costResult) return resResult(STATUS.GACHA_COST_NOT_ENOUGH);
         }
 
@@ -468,7 +468,7 @@ export class GachaHandler {
         // 给东西
         // console.log('****', heroInfo)
         let { heroes, resultHeroes } = await createHeroes(roleId, roleName, sid, serverId, heroInfo);
-        await addItems(roleId, roleName, sid, items);
+        await addItems(roleId, roleName, sid, items, ITEM_CHANGE_REASON.GACHA_ITEMS);
         // 更新数据
         role = await RoleModel.updateRoleInfo(roleId, { gachaHasGuide: true });
         await UserGachaRecModel.createRec(roleId, gachaId, 0, count, resultList);

game-server/app/servers/activity/handler/growthFundHandler.ts

@@ -1,6 +1,6 @@
 import { Application, BackendSession, HandlerService, } from 'pinus';
 import { resResult } from '../../../pubUtils/util';
-import { STATUS } from '../../../consts';
+import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
 import { getPlayerGrowthFundData } from '../../../services/activity/growthFundService';
 import { GrowthFundItem } from '../../../domain/activityField/growthFundField';
 import { ActivityGrowthFundModel } from '../../../db/ActivityGrowthFund';
@@ -72,7 +72,7 @@ export class GrowthFundHandler {
         await ActivityGrowthFundModel.addRecord(activityId, roleId, pageIndex, cellIndex);
 
         let rewardParamArr: Array<RewardParam> = stringToRewardParam(growthFundItemData.reward);
-        let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr)
+        let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.GROWTH_FUND)
 
         return resResult(STATUS.SUCCESS, Object.assign(result, {
             param: { activityId, pageIndex, cellIndex },

game-server/app/servers/activity/handler/growthHandler.ts

@@ -1,6 +1,6 @@
 import { Application, BackendSession, HandlerService, } from 'pinus';
 import { resResult } from '../../../pubUtils/util';
-import { STATUS } from '../../../consts';
+import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
 import { getPlayerGrowthData } from '../../../services/activity/growthService';
 import { GrowthItem, PointRewardItem } from '../../../domain/activityField/growthField';
 import { ActivityGrowthModel } from '../../../db/ActivityGrowth';
@@ -68,7 +68,7 @@ export class GrowthHandler {
 
         await ActivityGrowthModel.addCellRecord(serverId, activityId, roleId, dayIndex, cellIndex, type, 1);
         let rewardParamArr: Array<RewardParam> = stringToRewardParam(growthItemData.reward);
-        let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr)
+        let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.GROWTH_REWARD)
 
         growthItemData.receiveRewardCount = 1;
         return resResult(STATUS.SUCCESS, Object.assign(result, {
@@ -108,7 +108,7 @@ export class GrowthHandler {
         await ActivityGrowthPointModel.addRecord(serverId, activityId, roleId, id);
 
         let rewardParamArr: Array<RewardParam> = stringToRewardParam(pointItemData.reward);
-        let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr)
+        let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.GROWTH_DAY_EXCHANGE)
 
 
         pointItemData.getPointReward = true;

game-server/app/servers/activity/handler/limitPackageHandler.ts

@@ -1,6 +1,6 @@
 import { Application, BackendSession, HandlerService, } from 'pinus';
 import { resResult } from '../../../pubUtils/util';
-import { ACTIVITY_TYPE, STATUS } from '../../../consts';
+import { ACTIVITY_TYPE, ITEM_CHANGE_REASON, STATUS } from '../../../consts';
 import { newPlayerLimitPackageActivity, getPlayerLimitPackageData } from '../../../services/activity/limitPackageService';
 import { addReward, stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
 import { ActivityShopModel } from '../../../db/ActivityShop';
@@ -116,11 +116,11 @@ export class LimitPackageHandler {
 
         //检查资源
         let consume = stringToConsumeParam(item.consume)
-        let consumeResult = await handleCost(roleId, sid, consume);
+        let consumeResult = await handleCost(roleId, sid, consume, ITEM_CHANGE_REASON.BUY_LIMIT_PACKAGE);
         if (!consumeResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
 
         let rewardArray = stringToRewardParam(item.reward)
-        let result = await addReward(roleId, roleName, sid, serverId, rewardArray);
+        let result = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.BUY_LIMIT_PACKAGE);
 
         await ActivityShopModel.addRecord(activityId, roleId, roundIndex, id);
 

game-server/app/servers/activity/handler/newHeroGachaHandler.ts

@@ -1,6 +1,6 @@
 import { Application, BackendSession, HandlerService, } from 'pinus';
 import { resResult } from '../../../pubUtils/util';
-import { STATUS, GACHA_ID } from '../../../consts';
+import { STATUS, GACHA_ID, ITEM_CHANGE_REASON } from '../../../consts';
 import { getPlayerNewHeroGachaData } from '../../../services/activity/newHeroGachaService';
 import { RoleModel } from '../../../db/Role';
 import { HeroModel } from '../../../db/Hero';
@@ -88,7 +88,7 @@ export class NewHeroGachaHandler {
 
         // 消耗东西
         let cost = item.cost.map(cur => { return { id: cur.id, count: cur.count * count } });
-        let costResult = await handleCost(roleId, sid, cost);
+        let costResult = await handleCost(roleId, sid, cost, ITEM_CHANGE_REASON.NEW_HERO_GACHA_PULL);
         if (!costResult) return resResult(STATUS.ACTIVITY_RES_NOT_ENOUGH);
 
         //记录数据
@@ -96,11 +96,11 @@ export class NewHeroGachaHandler {
 
         // 给东西
         let { heroes, resultHeroes } = await createHeroes(roleId, roleName, sid, serverId, heroInfo);
-        await addItems(roleId, roleName, sid, items);
+        await addItems(roleId, roleName, sid, items, ITEM_CHANGE_REASON.GACHA_ITEMS);
         //固定奖励
         let rewardParamArr: Array<RewardParam> = stringToRewardParam(item.commonReward);
         let newRewardParamArr: Array<RewardParam> = rewardParamArr.map(obj => { return { id: obj.id, type: obj.type, count: obj.count * count } });
-        let commonResult = await addReward(roleId, roleName, sid, serverId, newRewardParamArr)
+        let commonResult = await addReward(roleId, roleName, sid, serverId, newRewardParamArr, ITEM_CHANGE_REASON.NEW_HERO_GACHA_PULL)
 
         return resResult(STATUS.SUCCESS, {
             hid, activityId, count, randomReward: { heroes: resultHeroes, result: resultList }, commonReward: commonResult

game-server/app/servers/activity/handler/newHeroGiftsHandler.ts

@@ -1,6 +1,6 @@
 import { Application, BackendSession, HandlerService, } from 'pinus';
 import { resResult } from '../../../pubUtils/util';
-import { STATUS, } from '../../../consts';
+import { ITEM_CHANGE_REASON, STATUS, } from '../../../consts';
 import { getPlayerNewHeroGiftsData } from '../../../services/activity/newHeroGiftsService';
 import { RewardParam } from '../../../domain/activityField/rewardField';
 import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
@@ -63,7 +63,7 @@ export class NewHeroGiftsHandler {
             return resResult(STATUS.ACTIVITY_NO_POINT);
         }
         let rewardParamArr: Array<RewardParam> = stringToRewardParam(item.reward);
-        let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr)
+        let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.NEW_HERO_EXCHANGE)
         await ActivityNewHeroGiftModel.addReceiveRecord(serverId, activityId, roleId, index, item.consumePoint);
         item.buyCount += 1;
         return resResult(STATUS.SUCCESS, Object.assign(result, {

game-server/app/servers/activity/handler/popUpShopHandler.ts

@@ -1,6 +1,6 @@
 import { Application, BackendSession, HandlerService, } from 'pinus';
 import { resResult, splitString } from '../../../pubUtils/util';
-import { ACTIVITY_RESOURCES_TYPE, CURRENCY_BY_TYPE, STATUS, CURRENCY_TYPE, } from '../../../consts';
+import { ACTIVITY_RESOURCES_TYPE, CURRENCY_BY_TYPE, STATUS, CURRENCY_TYPE, ITEM_CHANGE_REASON, } from '../../../consts';
 import { getPlayerPopUpShopData } from '../../../services/activity/popUpShopService';
 import { ActivityModel, ActivityModelType } from '../../../db/Activity';
 import { ActivityPopUpShopModel, ActivityPopUpShopModelType } from '../../../db/ActivityPopUpShop';
@@ -94,11 +94,11 @@ export class PopUpShopHandler {
             return resResult(STATUS.ACTIVITY_GOLD_RESOURCE);
         }
         let price = arr[2];//数量
-        let resourceResult = await handleCost(roleId, sid, [{ id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.GOLD), count: price }]);
+        let resourceResult = await handleCost(roleId, sid, [{ id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.GOLD), count: price }], ITEM_CHANGE_REASON.POP_UP_BUY_GIFT);
         if (!resourceResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
 
         let rewardParamArr: Array<RewardParam> = stringToRewardParam(playerData.reward);
-        let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr)
+        let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.POP_UP_BUY_GIFT)
 
         await ActivityPopUpShopModel.addRecord(serverId, activityId, roleId, id, playerData.taskType, 1, beginTime);
 

game-server/app/servers/activity/handler/rechargeMoneyHandler.ts

@@ -1,6 +1,6 @@
 import { Application, BackendSession, HandlerService, } from 'pinus';
 import { resResult } from '../../../pubUtils/util';
-import { STATUS } from '../../../consts';
+import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
 import { getPlayerRechargeMoneyData } from '../../../services/activity/rechargeMoneyService';
 import { RechargeMoneyItem } from '../../../domain/activityField/rechargeMoneyField';
 import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
@@ -66,7 +66,7 @@ export class RechargeMoneyHandler {
         console.log('recordArray', JSON.stringify(recordArray));
         await ActivityRechargeMoneyModel.addRecord(rechargeItem._id, item.id, item.reward)
         let rewardParamArr: Array<RewardParam> = stringToRewardParam(item.reward);
-        let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr)
+        let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.RECHARGE_REWARD)
         if (playerData.isLast()) {
             let _ids = playerData.recordArray.map(a => a._id)
             await ActivityRechargeMoneyModel.setEndState(serverId, roleId, _ids);

game-server/app/servers/activity/handler/refreshShopHandler.ts

@@ -1,6 +1,6 @@
 import { Application, BackendSession, HandlerService, } from 'pinus';
 import { resResult } from '../../../pubUtils/util';
-import { STATUS } from '../../../consts';
+import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
 import { getPlayerRefreshShopData } from '../../../services/activity/refreshShopService';
 import { addReward, stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
 import { ActivityRefreshShopModel } from '../../../db/ActivityRefreshShop';
@@ -72,11 +72,11 @@ export class RefreshShopHandler {
 
         //检查资源
         let consume = stringToConsumeParam(item.consume)
-        let consumeResult = await handleCost(roleId, sid, consume);
+        let consumeResult = await handleCost(roleId, sid, consume, ITEM_CHANGE_REASON.BUY_REFRESH_SHOP);
         if (!consumeResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
 
         let rewardArray = stringToRewardParam(item.reward)
-        let result = await addReward(roleId, roleName, sid, serverId, rewardArray);
+        let result = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.BUY_REFRESH_SHOP);
 
         await ActivityRefreshShopModel.addRecord(activityId, roleId, roundIndex, pageIndex, id);
 

game-server/app/servers/activity/handler/refreshTaskHandler.ts

@@ -1,6 +1,6 @@
 import { Application, BackendSession, HandlerService, } from 'pinus';
 import { resResult } from '../../../pubUtils/util';
-import { STATUS } from '../../../consts';
+import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
 import { getPlayerRefreshTaskData } from '../../../services/activity/refreshTaskService';
 import { RefreshTaskItem } from '../../../domain/activityField/refreshTaskField';
 import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
@@ -71,7 +71,7 @@ export class RefreshTaskHandler {
         await ActivityRefreshTaskModel.addReceiveRecord(serverId, activityId, roleId, roundIndex, pageIndex, id, type, 1);
 
         let rewardParamArr: Array<RewardParam> = stringToRewardParam(dailyItemData.reward);
-        let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr)
+        let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.REFRESH_TASK_REWARD)
 
         //获得点数
         await ActivityRefreshTaskPointModel.addPoint(serverId, activityId, roleId, dailyItemData.point);
@@ -123,7 +123,7 @@ export class RefreshTaskHandler {
         await ActivityRefreshTaskPointModel.addReceiveRecord(serverId, activityId, roleId, playerData.consumePoint);
 
         let rewardParamArr: Array<RewardParam> = stringToRewardParam(playerData.reward);
-        let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr)
+        let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.REFRESH_TASK_EXCHANGE)
 
         playerData.exchangePoint += playerData.consumePoint;
         return resResult(STATUS.SUCCESS, Object.assign(result, {

game-server/app/servers/activity/handler/selfServiceShopHandler.ts

@@ -1,6 +1,6 @@
 import { Application, BackendSession, HandlerService, } from 'pinus';
 import { resResult, splitString } from '../../../pubUtils/util';
-import { STATUS, } from '../../../consts';
+import { ITEM_CHANGE_REASON, STATUS, } from '../../../consts';
 import { SelfServiceShopData } from '../../../domain/activityField/selfServiceShopField';
 import { handleCost } from '../../../services/rewardService';
 import { ActivitySelfServiceShopModel, ActivitySelfServiceShopModelType } from '../../../db/ActivitySelfServiceShop';
@@ -73,7 +73,7 @@ export class SelfServiceShopHandler {
         }
         //检查资源
         let consume = stringToConsumeParam(item.consume)
-        let consumeResult = await handleCost(roleId, sid, consume);
+        let consumeResult = await handleCost(roleId, sid, consume, ITEM_CHANGE_REASON.SELF_SERVICE_SHOP_BUY_GIFT);
         if (!consumeResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
 
         let result = await addSelfServiceShopGiftReward(roleId, roleName, sid, serverId, activityId, roundIndex, index, item);
@@ -131,12 +131,12 @@ export class SelfServiceShopHandler {
 
         //检查资源
         let consume = stringToConsumeParam(unitPrice)
-        let consumeResult = await handleCost(roleId, sid, consume);
+        let consumeResult = await handleCost(roleId, sid, consume, ITEM_CHANGE_REASON.SELF_SERVICE_SHOP_BUY_RESOURCE);
         if (!consumeResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
 
         await ActivitySelfServiceModel.addBuyRecord(serverId, activityId, roleId, roundIndex, 1);
         let rewardArray = stringToRewardParam(unitReward)
-        let result = await addReward(roleId, roleName, sid, serverId, rewardArray);
+        let result = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.SELF_SERVICE_SHOP_BUY_RESOURCE);
 
         return resResult(STATUS.SUCCESS, Object.assign(result, { unitBuyCount: buyCount + 1 }));
     }

game-server/app/servers/activity/handler/sevenDaysHandler.ts

@@ -1,6 +1,6 @@
 import { Application, BackendSession, HandlerService, } from 'pinus';
 import { resResult } from '../../../pubUtils/util';
-import { STATUS, ACTIVITY_RESOURCES_TYPE } from '../../../consts';
+import { STATUS, ACTIVITY_RESOURCES_TYPE, ITEM_CHANGE_REASON } from '../../../consts';
 import { handleCost } from '../../../services/rewardService';
 import { ActivityGrowthModel } from '../../../db/ActivityGrowth';
 import { ActivityDailyGiftsModel } from '../../../db/ActivityDailyGifts';
@@ -72,7 +72,7 @@ export class SevenDaysHandler {
 
         await ActivityGrowthModel.addCellRecord(serverId, activityId, roleId, dayIndex, cellIndex, type, 1);
         let rewardParamArr: Array<RewardParam> = stringToRewardParam(growthItemData.reward);
-        let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr)
+        let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.GROWTH_REWARD)
 
         growthItemData.receiveRewardCount = 1;
         return resResult(STATUS.SUCCESS, Object.assign(result, {
@@ -112,7 +112,7 @@ export class SevenDaysHandler {
         await ActivityGrowthPointModel.addRecord(serverId, activityId, roleId, id);
 
         let rewardParamArr: Array<RewardParam> = stringToRewardParam(pointItemData.reward);
-        let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr)
+        let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.GROWTH_DAY_EXCHANGE)
 
 
         pointItemData.getPointReward = true;
@@ -155,7 +155,7 @@ export class SevenDaysHandler {
         await ActivityDailyChallengesModel.addCellRecord(serverId, activityId, roleId, dayIndex, cellIndex, type, 1);
 
         let rewardParamArr: Array<RewardParam> = stringToRewardParam(dailyItemData.reward);
-        let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr)
+        let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.DAILY_CHALLENGE_REWARD)
 
         dailyItemData.receiveRewardCount = 1;
         return resResult(STATUS.SUCCESS, Object.assign(result, {
@@ -200,7 +200,7 @@ export class SevenDaysHandler {
         let consumeType = consumeData.type;//购买类型
 
         if (consumeType == ACTIVITY_RESOURCES_TYPE.GOODS) {//物品表，元宝、金币、体力
-            let result = await handleCost(roleId, sid, [{ id: consumeData.id, count: consumeData.count }]);
+            let result = await handleCost(roleId, sid, [{ id: consumeData.id, count: consumeData.count }], ITEM_CHANGE_REASON.BUY_DAILY_GIFTS);
             if (!result) return resResult(STATUS.ACTIVITY_RES_NOT_ENOUGH);
         } else if (consumeType == ACTIVITY_RESOURCES_TYPE.RMB) {//RMB购买
             return resResult(STATUS.ACTIVITY_NEED_PAY);
@@ -209,7 +209,7 @@ export class SevenDaysHandler {
         await ActivityDailyGiftsModel.buyRecord(serverId, activityId, roleId, dayIndex, cellIndex, 1);
 
         let rewardParamArr: Array<RewardParam> = stringToRewardParam(dailyItemData.reward);
-        let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr)
+        let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.BUY_DAILY_GIFTS)
 
         dailyItemData.buyCount += 1;
         return resResult(STATUS.SUCCESS, Object.assign(result, {

game-server/app/servers/activity/handler/signInHandler.ts

@@ -1,6 +1,6 @@
 import { Application, BackendSession, HandlerService, } from 'pinus';
 import { resResult } from '../../../pubUtils/util';
-import { STATUS, ACTIVITY_TYPE, SERVER_OPEN_TIME, } from '../../../consts';
+import { STATUS, ACTIVITY_TYPE, SERVER_OPEN_TIME, ITEM_CHANGE_REASON, } from '../../../consts';
 import { canBuyVip, getPlayerSignInData } from '../../../services/activity/signInService';
 import { handleCost } from '../../../services/rewardService';
 import { SignInItem } from '../../../domain/activityField/signInField';
@@ -100,14 +100,14 @@ export class SignInHandler {
         }
         if (isDelay) {
             let consume = stringToConsumeParam(playerData.consume)
-            let consumeResult = await handleCost(roleId, sid, consume);
+            let consumeResult = await handleCost(roleId, sid, consume, ITEM_CHANGE_REASON.REPAIRE_SIGNIN);
             if (!consumeResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
         }
 
         await ActivitySignInModel.addSignInRecord(activityId, roleId, roundIndex, [dayIndex]);
 
         let rewardParamArr: Array<RewardParam> = stringToRewardParam(signinItemData.reward);
-        let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr)
+        let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.SIGNIN)
 
         return resResult(STATUS.SUCCESS, Object.assign(result, {
             param: { activityId, dayIndex },

game-server/app/servers/activity/handler/thirtyDaysHandler.ts

@@ -1,6 +1,6 @@
 import { Application, BackendSession, HandlerService, } from 'pinus';
 import { resResult } from '../../../pubUtils/util';
-import { STATUS, ACTIVITY_TYPE } from '../../../consts';
+import { STATUS, ACTIVITY_TYPE, ITEM_CHANGE_REASON } from '../../../consts';
 import { getPlayerThirtyDaysData, playerThirtyDaysActivityDays } from '../../../services/activity/thirtyDaysService';
 import { ThirtyDaysData, ThirtyDaysItem, ThirtyDaysPointItem } from '../../../domain/activityField/thirtyDaysField';
 import { ActivityThirtyDaysModel } from '../../../db/ActivityThirtyDays';
@@ -104,7 +104,7 @@ export class ThirtyDaysHandler {
         await ActivityThirtyDaysModel.addRecord(serverId, activityId, roleId, pageIndex, cellIndex, tab);
 
         let rewardParamArr: Array<RewardParam> = stringToRewardParam(thirtyDaysItemData.reward);
-        let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr)
+        let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.THIRTHDAY_TASK)
         thirtyDaysItemData.isReceive = true;
         return resResult(STATUS.SUCCESS, Object.assign(result, {
             param: { activityId, pageIndex, cellIndex },
@@ -148,7 +148,7 @@ export class ThirtyDaysHandler {
         }
 
         let rewardParamArr: Array<RewardParam> = stringToRewardParam(reward);
-        let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr)
+        let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.THIRTHDAY_EXCHANGE)
 
         thirtyDaysPointItemData.isReceive = true;
         return resResult(STATUS.SUCCESS, Object.assign(result, {

game-server/app/servers/activity/handler/treasureHuntHandler.ts

@@ -1,6 +1,6 @@
 import { Application, BackendSession, HandlerService, } from 'pinus';
 import { resResult } from '../../../pubUtils/util';
-import { STATUS, } from '../../../consts';
+import { ITEM_CHANGE_REASON, STATUS, } from '../../../consts';
 import { getPlayerTreasureHuntData, getTreasureHuntData, getPlayerTreasureHuntShopData, getPlayerTreasureHuntTaskData, getPlayerTreasureHuntTreasureShopData, getPlayerTreasureHuntChallengeData, getPlayerTreasureHuntFirstPageData } from '../../../services/activity/treasureHuntService';
 import { ActivityTreasureHuntShopModel } from '../../../db/ActivityTreasureHuntShop';
 import { ActivityTreasureHuntTaskModel } from '../../../db/ActivityTreasureHuntTask';
@@ -77,7 +77,7 @@ export class TreasureHuntHandler {
         await ActivityTreasureHuntFirstPageModel.receiveReward(serverId, activityId, roleId, huntRoundIndex);
 
         let rewardParamArr: Array<RewardParam> = stringToRewardParam(playerData.firstPage.reward);
-        let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr)
+        let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.TREASURE_HUNT_FIRST_PAGE_REWARD)
 
         playerData.firstPage.isReceive = true;
         return resResult(STATUS.SUCCESS, Object.assign(result, {
@@ -122,14 +122,14 @@ export class TreasureHuntHandler {
 
         let consumeStr = item.getConsume();
         let consume = stringToConsumeParam(consumeStr)
-        let resourceResult = await handleCost(roleId, sid, consume);
+        let resourceResult = await handleCost(roleId, sid, consume, ITEM_CHANGE_REASON.TREASURE_HUNT_SHOP_BUY);
         if (!resourceResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
 
         //添加购买记录
         await ActivityTreasureHuntShopModel.buyShopRecord(activityId, roleId, huntRoundIndex, playerData.todayIndex, cellIndex);
 
         let rewardParamArr: Array<RewardParam> = stringToRewardParam(item.reward);
-        let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr)
+        let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.TREASURE_HUNT_SHOP_BUY)
 
         item.buyCount += 1;
         return resResult(STATUS.SUCCESS, Object.assign(result, {
@@ -176,7 +176,7 @@ export class TreasureHuntHandler {
         await ActivityTreasureHuntTaskModel.receiveReward(serverId, activityId, roleId, huntRoundIndex, cellIndex, 1);
 
         let rewardParamArr: Array<RewardParam> = stringToRewardParam(item.reward);
-        let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr)
+        let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.TREASURE_HUNT_TASK_REWARD)
 
         item.isReceive = true;
         return resResult(STATUS.SUCCESS, Object.assign(result, {
@@ -212,7 +212,7 @@ export class TreasureHuntHandler {
         //消耗资源
         let consumeStr = challengeData.consume;
         let consume = stringToConsumeParam(consumeStr)
-        let resourceResult = await handleCost(roleId, sid, consume);
+        let resourceResult = await handleCost(roleId, sid, consume, ITEM_CHANGE_REASON.TREASURE_HUNT_CHALLENGE);
         if (!resourceResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
 
         let warId = playerData.challenge.randomGK();
@@ -255,14 +255,14 @@ export class TreasureHuntHandler {
 
         let consumeStr = item.consume;
         let consume = stringToConsumeParam(consumeStr)
-        let resourceResult = await handleCost(roleId, sid, consume);
+        let resourceResult = await handleCost(roleId, sid, consume, ITEM_CHANGE_REASON.TREASURE_HUNT_SP_SHOP_BUY);
         if (!resourceResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
 
         //添加购买记录
         await ActivityTreasureHuntTreasureShopModel.addRecord(activityId, roleId, huntRoundIndex, cellIndex);
 
         let rewardParamArr: Array<RewardParam> = stringToRewardParam(item.reward);
-        let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr)
+        let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.TREASURE_HUNT_SP_SHOP_BUY)
 
         item.buyCount += 1;
         return resResult(STATUS.SUCCESS, Object.assign(result, {

game-server/app/servers/activity/handler/vipRechargeMoneyHandler.ts

@@ -1,6 +1,6 @@
 import { Application, BackendSession, HandlerService, } from 'pinus';
 import { resResult } from '../../../pubUtils/util';
-import { STATUS, } from '../../../consts';
+import { ITEM_CHANGE_REASON, STATUS, } from '../../../consts';
 import { getPlayerVipRechargeMoneyData, } from '../../../services/activity/vipRechargeMoneyService';
 import { VipRechargeMoneyItem } from '../../../domain/activityField/vipRechargeMoneyField';
 import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
@@ -68,7 +68,7 @@ export class VipRechargeMoneyHandler {
         await ActivityVipRechargeMoneyModel.addRecord(serverId, activityId, roleId, id);
 
         let rewardParamArr: Array<RewardParam> = stringToRewardParam(item.reward);
-        let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr)
+        let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.VIP_RECHARGE_MONEY)
         item.receiveCount += 1;
 
         return resResult(STATUS.SUCCESS, Object.assign(result, {

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

@@ -6,7 +6,7 @@ import { difference } from 'underscore';
  * @Last Modified by: 梁桐川
  * @Last Modified time: 2021-08-27 17:47:56
  */
-import { IT_TYPE, CURRENCY_BY_TYPE, CURRENCY_TYPE, COM_TEAM_STATUS, COM_BTL_CONST, CONSUME_TYPE, COM_BTL_QUALITY, MSG_SOURCE, QUALITY_TYPE, ROLE_SELECT, TASK_TYPE, KING_EXP_RATIO_TYPE } from './../../../consts';
+import { IT_TYPE, CURRENCY_BY_TYPE, CURRENCY_TYPE, COM_TEAM_STATUS, COM_BTL_CONST, CONSUME_TYPE, COM_BTL_QUALITY, MSG_SOURCE, QUALITY_TYPE, ROLE_SELECT, TASK_TYPE, KING_EXP_RATIO_TYPE, ITEM_CHANGE_REASON } from './../../../consts';
 import Role, { RoleModel } from '../../../db/Role';
 import { STATUS } from '../../../consts/statusCode';
 import { Application, BackendSession } from 'pinus';
@@ -592,7 +592,7 @@ export class ComBattleHandler {
         // }
 
         await ComBattleTeamModel.updateRewardSt(teamCode, roleId, true);
-        const goods = await addItems(roleId, roleName, sid, roleSt.fixReward);
+        const goods = await addItems(roleId, roleName, sid, roleSt.fixReward, ITEM_CHANGE_REASON.COM_BATTLE_REWARD);
         let actordata = await roleLevelup(KING_EXP_RATIO_TYPE.BATTLE, roleId, warInfo.kingExp, session);// 主公升级经验
         // 任务
         await checkTaskWithGoods(roleId, sid, TASK_TYPE.COM_BATTLE_DROP, goods);
@@ -799,13 +799,13 @@ export class ComBattleHandler {
         original.push(...dicCompose.coinNum);
         // 消耗藏宝图和寻宝币
 
-        let costResult = await handleCost(roleId, sid, original);
+        let costResult = await handleCost(roleId, sid, original, ITEM_CHANGE_REASON.BLUEPRT_COMPOSE);
         if(!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
 
         const targetList = gameData.blueprt.get(dicCompose.targetQuality);
         const target = getRandSingleEelm(targetList);
         const reward = [{id: target, count: 1}];
-        const goods = await addItems(roleId, roleName, sid, reward);
+        const goods = await addItems(roleId, roleName, sid, reward, ITEM_CHANGE_REASON.BLUEPRT_COMPOSE);
         if (dicCompose.targetQuality >= QUALITY_TYPE.ORANGE) {
             const { name } = gameData.goods.get(target);
             pushNormalItemMsg(roleId, roleName, serverId, MSG_SOURCE.ORANGE_BLUEPRT_COMPOSE, target, name);

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

@@ -7,7 +7,7 @@ import { getDailyNum, getDailyBattleList, getDailyBuyCountCost } from '../../../
 import { handleCost } from '../../../services/rewardService';
 import { getGoldObject } from '../../../pubUtils/itemUtils';
 import { gameData } from '../../../pubUtils/data';
-import { DEBUG_MAGIC_WORD } from '../../../consts';
+import { DEBUG_MAGIC_WORD, ITEM_CHANGE_REASON } from '../../../consts';
 
 export default function(app: Application) {
     return new DailyBattleHandler(app);
@@ -55,7 +55,7 @@ export class DailyBattleHandler {
             return resResult(STATUS.DAILY_REFRESH_GOLD_LACK);
         }
 
-        await handleCost(roleId, sid, [getGoldObject(buyCost)]);
+        await handleCost(roleId, sid, [getGoldObject(buyCost)], ITEM_CHANGE_REASON.DAILY_BATTLE_BUY_CNT);
         let newDailyRecord = await DailyRecordModel.increseBuyCount(roleId, type, count);
 
         let checkDailyResult = await getDailyNum(newDailyRecord, timesPerDay, timesCanBuy);

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

@@ -8,7 +8,7 @@ import { getDungeonData, getDungeonBuyCountCost } from '../../../services/dungeo
 import * as dicParam from '../../../pubUtils/dicParam';
 import { DungeonFirstModel } from '../../../db/DungeonFirst';
 import { DungeonResultParam } from '../../../domain/battleField/dungeon';
-import { DEBUG_MAGIC_WORD } from '../../../consts';
+import { DEBUG_MAGIC_WORD, ITEM_CHANGE_REASON } from '../../../consts';
 
 export default function(app: Application) {
     return new DungeonBattleHandler(app);
@@ -56,7 +56,7 @@ export class DungeonBattleHandler {
         if(buyCost > gold) {
             return resResult(STATUS.DAILY_REFRESH_GOLD_LACK);
         }
-        await handleCost(roleId, sid, [getGoldObject(buyCost)]);
+        await handleCost(roleId, sid, [getGoldObject(buyCost)], ITEM_CHANGE_REASON.DUNGEON_BATTLE_BUY_CNT);
         await RoleModel.buyCnt(roleId, needRefresh, count, curTime);
 
         let nextCostGold = getDungeonBuyCountCost(dungeonBuyCnt + count + 1);

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

@@ -1,7 +1,7 @@
 import { Application, BackendSession, HandlerService, } from 'pinus';
 import { EventRecordModel } from '../../../db/EventRecord';
 import { RoleModel } from '../../../db/Role';
-import { EVENT_STATUS, EVENT_RECORD_STATUS, EVENT_ANSWER_STATUS, TASK_TYPE, DEBUG_MAGIC_WORD } from '../../../consts';
+import { EVENT_STATUS, EVENT_RECORD_STATUS, EVENT_ANSWER_STATUS, TASK_TYPE, DEBUG_MAGIC_WORD, ITEM_CHANGE_REASON } from '../../../consts';
 import { checkEventStatus, getEventSuccessStatus, getEvent, checkQuiz, startEvent, refreshEvent, getEventTime } from '../../../services/eventSercive';
 import { addItems } from '../../../services/rewardService';
 import { STATUS } from '../../../consts/statusCode';
@@ -116,7 +116,7 @@ export class EventBattleHandler {
         let result = await EventRecordModel.setStatusByCode(roleId, eventCode, isSuccess ? EVENT_RECORD_STATUS.SUCCESS_RECEIVED : EVENT_RECORD_STATUS.FAIL_RECEIVED);
         // 保存奖励
         let reward = isSuccess ? dicEvent.winReward : dicEvent.loseReward;
-        let goods = await addItems(roleId, roleName, sid, reward);
+        let goods = await addItems(roleId, roleName, sid, reward, ITEM_CHANGE_REASON.EVENT_REWARD);
         if (eventStatus == EVENT_STATUS.STARTING) { // 如果是第一次开启的挑战，保存成开启状态
             await RoleModel.setEventStatus(roleId, EVENT_STATUS.OPEN);
             // 第一场时间挑战完，开始正常刷新事件，所以刷新时间也重置起来

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

@@ -6,7 +6,7 @@ import { ExpeditionPointModel } from '../../../db/ExpeditionPoint';
 import { RoleModel } from '../../../db/Role';
 import { calculateSumCE, genCode } from '../../../pubUtils/util';
 import { getPointRewardStatus, getResetRemainCnt, findOrCreateEnemies, getExpeditionStatus } from '../../../services/expeditionService';
-import { DEBUG_MAGIC_WORD, EXPEDITION_WAR_RECORD_STATUS, KING_EXP_RATIO_TYPE, LINEUP_NUM, TASK_TYPE } from '../../../consts';
+import { DEBUG_MAGIC_WORD, EXPEDITION_WAR_RECORD_STATUS, ITEM_CHANGE_REASON, KING_EXP_RATIO_TYPE, LINEUP_NUM, TASK_TYPE } from '../../../consts';
 import { WarReward } from '../../../services/warRewardService';
 import { addItems } from '../../../services/rewardService';
 import { getAp, setAp } from '../../../services/actionPointService';
@@ -16,6 +16,7 @@ import { calculateWarStar, checkBattleHeroes, roleLevelup } from '../../../servi
 import { checkActivityTask, checkTask, checkTaskInBattleEnd } from '../../../services/taskService';
 import { gameData } from '../../../pubUtils/data';
 import * as dicParam from '../../../pubUtils/dicParam';
+import { getSeconds } from '../../../pubUtils/timeUtil';
 
 export default function (app: Application) {
     new HandlerService(app, {});
@@ -197,7 +198,7 @@ export class ExpeditionBattleHandler {
         }
 
         let flag = 1; // 对比hero信息
-        let { record: { heroes: dbHeroes, seqIds: dbSeqIds } } = BattleRecord;
+        let { record: { heroes: dbHeroes, seqIds: dbSeqIds }, createdAt } = BattleRecord;
         for (let { dataId } of heroes) {
             if (dbSeqIds.indexOf(dataId) == -1) flag = 0;
         }
@@ -255,6 +256,7 @@ export class ExpeditionBattleHandler {
             battleStatus: expeditionWarRecord.battleStatus,
             battleGoods: reward,
             expeditionPoint,
+            createdAt: getSeconds(createdAt),
             ...actordata
         });
     }
@@ -312,7 +314,7 @@ export class ExpeditionBattleHandler {
         await checkTask(roleId, sid, TASK_TYPE.BATTLE_EXPEDITION_BOX, 1, true, { point });
         await checkActivityTask(serverId, sid, roleId, TASK_TYPE.BATTLE_EXPEDITION_BOX, 1)
 
-        let goods = await addItems(roleId, roleName, sid, curDicExpeditionPoint.reward);
+        let goods = await addItems(roleId, roleName, sid, curDicExpeditionPoint.reward, ITEM_CHANGE_REASON.EXPEDITION_POINT_REWARD);
 
         return resResult(STATUS.SUCCESS, {
             costPoint: hasReceivedAll ? maxPoint : 0,

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

@@ -17,7 +17,7 @@ import { checkDungeonNum, checkDungeonAndIncrease, saveDungeonFirst } from '../.
 // import { switchOnFunc } from '../../../services/funcSwitchService';
 import { gameData } from '../../../pubUtils/data';
 import { pushMysteryFirstMsg, pushTowerMsg, pushVestigeFirstMsg } from '../../../services/chatService';
-import { nowSeconds } from '../../../pubUtils/timeUtil';
+import { getSeconds, nowSeconds } from '../../../pubUtils/timeUtil';
 import { Rank } from '../../../services/rankService';
 import { checkTaskWithWar, checkTaskInBattleEnd, checkActivityTask } from '../../../services/taskService';
 import { ActivitySelfServiceModel } from '../../../db/ActivitySelfService';
@@ -147,7 +147,7 @@ export class NormalBattleHandler {
         }
 
         let flag = 1; // 对比hero信息
-        let { record: { heroes: dbHeroes, seqIds: dbSeqIds } } = BattleRecord;
+        let { record: { heroes: dbHeroes, seqIds: dbSeqIds }, createdAt } = BattleRecord;
         for (let seqId of dbSeqIds) {
             if (dbSeqIds.indexOf(seqId) == -1) flag = 0;
         }
@@ -269,6 +269,7 @@ export class NormalBattleHandler {
             battleCode, battleId, status,
             battleGoods: reward,
             towerStatus, dailyNum, dungeonNum,
+            createdAt: getSeconds(createdAt),
             ...actordata
         });
     }

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

@@ -12,7 +12,7 @@ import { PVPConfigModel } from '../../../db/SystemConfig';
 import { Rank } from '../../../services/rankService';
 import { checkActivityTask, checkTask, checkTaskInPvpEnd } from '../../../services/taskService';
 import { Attack, AttackHero, Defense, DefenseHero, PvpDataReturn } from '../../../domain/battleField/pvp';
-import { DEBUG_MAGIC_WORD, FIGURE_UNLOCK_CONDITION, LINEUP_NUM, REDIS_KEY, TASK_TYPE } from '../../../consts';
+import { DEBUG_MAGIC_WORD, FIGURE_UNLOCK_CONDITION, ITEM_CHANGE_REASON, LINEUP_NUM, REDIS_KEY, TASK_TYPE } from '../../../consts';
 import { PVP } from '../../../pubUtils/dicParam';
 import { getGoldObject } from '../../../pubUtils/itemUtils';
 import { addItems, handleCost, unlockFigure } from '../../../services/rewardService';
@@ -107,7 +107,7 @@ export class PvpHandler {
             return resResult(STATUS.PVP_REFRESH_CNT_REACH_MAX);
         }
 
-        let costResult = await handleCost(roleId, sid, refOppObj.consume);
+        let costResult = await handleCost(roleId, sid, refOppObj.consume, ITEM_CHANGE_REASON.PVP_REFRESH_OPP);
         if (!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
         refOppObj.refOppCnt ++;
 
@@ -202,7 +202,7 @@ export class PvpHandler {
             return resResult(STATUS.BATTLE_STATUS_WRONG);
         }
 
-        let { record: { heroes: dbHeroes, oppRoleId, pos } } = BattleRecord;
+        let { record: { heroes: dbHeroes, oppRoleId, pos }, createdAt } = BattleRecord;
 
         let flag = 1; // 对比hero信息
         for (let { hid } of myHeroes) {
@@ -276,6 +276,7 @@ export class PvpHandler {
         return resResult(STATUS.SUCCESS, {
             battleCode, isSuccess,
             heroScores: showHeroScores,
+            createdAt: getSeconds(createdAt),
             ...pick(result, ['score', 'myRank', 'winStreakNum', 'attack', 'oppPlayers', 'challengeCnt', 'challengeRefTime'])
         });
     }
@@ -297,7 +298,7 @@ export class PvpHandler {
         refOppObj.buyAttackCnt += count;
 
         let gold = getGoldObject(PVP.PVP_SET_ATTACK_CNT_GOLD * count);
-        let costResult = await handleCost(roleId, sid, [gold]);
+        let costResult = await handleCost(roleId, sid, [gold], ITEM_CHANGE_REASON.PVP_BUY_ATTACK_CNT);
         if(!costResult) return resResult(STATUS.TOWER_GOLD_NOT_ENOUGH);
 
         let update: pvpUpdateInter = { ...refOppObj };
@@ -518,7 +519,7 @@ export class PvpHandler {
         receivedBox.push(id);
         let { challengeCnt, challengeRefTime } = refChallengeCnt(lastChallengeCnt, lastChallengeRefTime, seasonEndTime);
         await PvpDefenseModel.updateInfo(roleId, { receivedBox, challengeCnt, challengeRefTime });
-        let result = await addItems(roleId, roleName, sid, pvpBox.reward);
+        let result = await addItems(roleId, roleName, sid, pvpBox.reward, ITEM_CHANGE_REASON.PVP_BOX_REWARD);
         // 任务
         await checkTask(roleId, sid, TASK_TYPE.PVP_RECEIVE_BOX, 1, true, {});
         return resResult(STATUS.SUCCESS, { goods: result, receivedBox, challengeCnt, challengeRefTime });

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

@@ -1,5 +1,5 @@
 import { STATUS } from './../../../consts/statusCode';
-import { HANG_UP_CONSTS, REDIS_KEY } from './../../../consts';
+import { HANG_UP_CONSTS, ITEM_CHANGE_REASON, REDIS_KEY } from './../../../consts';
 import { TaskHero, TowerTaskRecModel, TowerTaskRecType } from './../../../db/TowerTaskRec';
 import { HangUpSpdUpRecModel } from './../../../db/HangUpSpdUpRec';
 import { HangUpRecordModel } from './../../../db/HangUpRecord';
@@ -72,7 +72,7 @@ export class TowerBattleHandler {
         }
         let { timeReward, endLv, endTime, deltaTime, needReceiveGoods } = result.data;
  
-        const goods = await addItems(roleId, roleName, sid, timeReward);
+        const goods = await addItems(roleId, roleName, sid, timeReward, ITEM_CHANGE_REASON.TOWER_HUNG_UP_REWARD);
         await HangUpRecordModel.updateRec(roleId, roleName, endLv, endTime, needReceiveGoods);
 
         return resResult(STATUS.SUCCESS, { endTime, hangUpPassTime: Math.floor((deltaTime%HANG_UP_CONSTS.UNIT_TIME)/1000), goods });
@@ -101,14 +101,14 @@ export class TowerBattleHandler {
             return resResult(STATUS.TOWER_GOLD_NOT_ENOUGH);
         }
 
-        await handleCost(roleId, sid, [getGoldObject(costGold)])
+        await handleCost(roleId, sid, [getGoldObject(costGold)], ITEM_CHANGE_REASON.TOWER_HUNG_UP_SDP_UP)
 
         const spdUpResult = await RoleModel.hangUpSpdUp(roleId, msg.speedUpCnt, curTime);
         if (!spdUpResult) {
             return resResult(STATUS.TOWER_HANG_UP_FAILED);
         }
         const spdUpRec = await HangUpSpdUpRecModel.updateRec(roleId, roleName, msg.speedUpCnt, endLv, needReceiveGoods);
-        const goods = await addItems(roleId, roleName, sid, timeReward);
+        const goods = await addItems(roleId, roleName, sid, timeReward, ITEM_CHANGE_REASON.TOWER_HUNG_UP_REWARD);
         let nextCostGold = getManyHangSpdUpCostGold(spdUpResult.hangUpSpdUpCnt, 1);
 
         return resResult(STATUS.SUCCESS, { goods, hangUpSpdUpCnt: dicParam.TOWER_BOOST.TOWER_BOOSTTIME - spdUpResult.hangUpSpdUpCnt, nextCostGold, hangUpPassTime: Math.floor(deltaTime/1000), rewardLv: endLv, costGold });
@@ -236,7 +236,7 @@ export class TowerBattleHandler {
             return resResult(STATUS.TOWER_TASK_BATCH_NOT_FOUND);
         }
         const { compTasks, rewards } = checkResult;
-        let goods = await addItems(roleId, roleName, sid, rewards);
+        let goods = await addItems(roleId, roleName, sid, rewards, ITEM_CHANGE_REASON.TOWER_TASK_REWARD);
         await TowerTaskRecModel.finishTask(msg.batchCode, compTasks);
         let refRemainTime = getRemainTime(curTime);
 

game-server/app/servers/guild/handler/auctionHandler.ts

@@ -1,6 +1,6 @@
 import { DividendModel } from './../../../db/Dividend';
 import { Application, BackendSession, ChannelService, HandlerService, pinus, } from "pinus";
-import { AUCTION_STAGE, DEBUG_MAGIC_WORD, STATUS, CURRENCY_BY_TYPE, CURRENCY_TYPE, DATA_NAME, LOT_STATUS, CHANNEL_PREFIX, MAIL_TYPE } from "../../../consts";
+import { AUCTION_STAGE, DEBUG_MAGIC_WORD, STATUS, CURRENCY_BY_TYPE, CURRENCY_TYPE, DATA_NAME, LOT_STATUS, CHANNEL_PREFIX, MAIL_TYPE, ITEM_CHANGE_REASON } from "../../../consts";
 import { LotModel } from "../../../db/Lot";
 import { ItemReward } from "../../../domain/dbGeneral";
 import { genCode, resResult } from "../../../pubUtils/util";
@@ -82,7 +82,7 @@ export class AuctionHandler {
                 newPrice = maxPrice;
                 maxFlag = true;
             }
-            const costRes = await handleCost(roleId, sid, [{ id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.GOLD), count: newPrice }]);
+            const costRes = await handleCost(roleId, sid, [{ id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.GOLD), count: newPrice }], ITEM_CHANGE_REASON.AUCTION_OFFER);
             if (!costRes) {
                 res.releaseCallback();
                 return resResult(STATUS.ROLE_COIN_NOT_ENOUGH);
@@ -150,7 +150,7 @@ export class AuctionHandler {
         const { dividends } = dividendData;
         const dividend = dividends.find(item => { return item.roleId === roleId });
         if (!dividend) return resResult(STATUS.DIVIDEND_GUILD_PLAYER_ONLY);
-        let goods = await addItems(roleId, roleName, sid, [{ id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.GOLD), count: dividend.total }]);
+        let goods = await addItems(roleId, roleName, sid, [{ id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.GOLD), count: dividend.total }], ITEM_CHANGE_REASON.AUCTION_DIVIDEND);
         await DividendModel.updateReceiveStatus(dividendData.code, roleId);
         return resResult(STATUS.SUCCESS, { dividend, goods });
     }

game-server/app/servers/guild/handler/cityActivityHandler.ts

@@ -1,5 +1,5 @@
 import { Application, ChannelService, BackendSession, pinus, HandlerService, } from "pinus";
-import { GUILD_ACTIVITY_TYPE, STATUS, REDIS_KEY, GUILD_POINT_WAYS, CITY_STATUS, TASK_TYPE } from "../../../consts";
+import { GUILD_ACTIVITY_TYPE, STATUS, REDIS_KEY, GUILD_POINT_WAYS, CITY_STATUS, TASK_TYPE, ITEM_CHANGE_REASON } from "../../../consts";
 import { resResult } from "../../../pubUtils/util";
 import { getGuildActivityStatus, getCityActivityObj, getCityStatus as pubGetCityStatus, getCities, getCityActivityRank, sendSingleCityActEndMsg, getMedianCe } from "../../../services/guildActivityService";
 import { GuildActivityCityModel } from "../../../db/GuildActivityCity";
@@ -221,7 +221,7 @@ export class CityActivityHandler {
         let myGuildActivityRec = await UserGuildActivityRecModel.getRecord(roleId, roleName, guildCode, serverId, sourceCode, this.aid);
 
         let goldObj = getGoldObject(GUILDACTIVITY.CITYACTIVITY_CD_COST);
-        const costRes = await handleCost(roleId, sid, [goldObj]);
+        const costRes = await handleCost(roleId, sid, [goldObj], ITEM_CHANGE_REASON.CITY_ACT_RESET_CHALLENGE_TIME);
         if (!costRes) {
             return resResult(STATUS.BATTLE_GOLD_NOT_ENOUGH);
         }

game-server/app/servers/guild/handler/donateHandler.ts

@@ -1,7 +1,7 @@
 import { Application, BackendSession, HandlerService, } from 'pinus';
 import { UserGuildModel } from '../../../db/UserGuild';
 import { resResult } from '../../../pubUtils/util';
-import { DATA_NAME, STATUS, TASK_TYPE } from '../../../consts';
+import { DATA_NAME, ITEM_CHANGE_REASON, STATUS, TASK_TYPE } from '../../../consts';
 import { DonationModel } from '../../../db/Donation';
 import { nowSeconds } from '../../../pubUtils/timeUtil';
 import { getArmyDonateBaseByLv, getArmyDonateBoxBaseById } from '../../../pubUtils/data';
@@ -73,7 +73,7 @@ export class DonationHandler {
             let { donationLv } = await getDonation(code, serverId);
             let { donateReward } = getArmyDonateBaseByLv(donationLv);
             let { rewardGood, rewardFund, cosume } = donateReward.get(id);
-            let result = await handleCost(roleId, sid, [cosume]);
+            let result = await handleCost(roleId, sid, [cosume], ITEM_CHANGE_REASON.DONATE);
             if (!result) {
                 res.releaseCallback();
                 return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
@@ -83,7 +83,7 @@ export class DonationHandler {
             let { donateFund, reports } = await DonationModel.donation(code, rewardFund, { reports: { id, roleName, time: nowSeconds() } });
             let goods = [];
             if (!!rewardGood)
-                goods = await addItems(roleId, roleName, sid, [rewardGood]);
+                goods = await addItems(roleId, roleName, sid, [rewardGood], ITEM_CHANGE_REASON.DONATE);
             //增加基金
             const { fund } = await GuildModel.updateInfo(code, {}, { fund: rewardFund }, 'fund');
             this.app.rpc.chat.guildRemote.updateInfo.toServer(CHAT_SERVER, code, { fund });
@@ -127,7 +127,7 @@ export class DonationHandler {
         });
         resReceiveBoxs.push(id);
         let { receiveBoxs } = await UserGuildModel.updateInfo(roleId, { receiveBoxs: resReceiveBoxs }, {}, 'receiveBoxs');
-        let goods = await addItems(roleId, roleName, sid, boxRewards);
+        let goods = await addItems(roleId, roleName, sid, boxRewards, ITEM_CHANGE_REASON.DONATE_BOX);
         return resResult(STATUS.SUCCESS, { receiveBoxs, goods });
     }
 }

game-server/app/servers/guild/handler/guildBossHandler.ts

@@ -1,9 +1,9 @@
 import { Application, BackendSession, pinus, HandlerService, } from 'pinus';
 import { resResult, genCode, getRandSingleEelm } from '../../../pubUtils/util';
-import { AUCTION_SOURCE, DEBUG_MAGIC_WORD, MAIL_TYPE, STATUS, TASK_TYPE } from '../../../consts';
+import { AUCTION_SOURCE, DEBUG_MAGIC_WORD, ITEM_CHANGE_REASON, MAIL_TYPE, STATUS, TASK_TYPE } from '../../../consts';
 import { BossInstanceModel } from '../../../db/BossInstance';
 import { BattleRecordModel } from '../../../db/BattleRecord';
-import { nowSeconds, getZeroPoint } from '../../../pubUtils/timeUtil';
+import { nowSeconds, getZeroPoint, getSeconds } from '../../../pubUtils/timeUtil';
 import { getBossInstanceInfo, checkBossBattleMemberExists, pushBossHpMessage, addBossInstance, refreshUserGuildOfBoss, refreshGuildOfBoss, getRanks, getBossInstanceInfoByData } from '../../../services/guildBossService';
 import { findWhere } from 'underscore'
 import { GUILD_STRUCTURE, GUILD_BOSS_STATUS, GUILD_POINT_WAYS } from '../../../consts/constModules/guildConst';
@@ -202,7 +202,7 @@ export class GuildHandler {
             return { id, count: Math.floor(count * bossDamage * dicBossBase.ratio / 1000 ) }
         });
 
-        let battleGoods = await addItems(roleId, roleName, sid, reward);
+        let battleGoods = await addItems(roleId, roleName, sid, reward, ITEM_CHANGE_REASON.BOSS_BATTLE_END);
 
         await addActive(roleId, serverId, GUILD_POINT_WAYS.BOSS_WAR);//获得活跃值
         // 任务
@@ -210,7 +210,7 @@ export class GuildHandler {
         
         let result = await getBossInstanceInfoByData(bossInstance, userGuild);
 
-        return resResult(STATUS.SUCCESS, { ...result, battleGoods });
+        return resResult(STATUS.SUCCESS, { ...result, battleGoods, createdAt: getSeconds(battleRecord.createdAt) });
     }
 
     async encourage(msg: guildInter & { count: number }, session: BackendSession) {
@@ -236,7 +236,7 @@ export class GuildHandler {
         if(!bossInstance) return resResult(STATUS.GUILD_SCRIPT_ENCOURGE_NOT_ENOUGH);
 
         let consume = getGoldObject(costGold);
-        let costResult = await handleCost(roleId, sid, [consume]);
+        let costResult = await handleCost(roleId, sid, [consume], ITEM_CHANGE_REASON.GUILD_BOSS_ENCOURAGE);
         if(!costResult) return resResult(STATUS.BATTLE_GOLD_NOT_ENOUGH);
 
         let { myEncourageCnt: myEncourageCntResult } = await refreshUserGuildOfBoss(userGuild, count);

game-server/app/servers/guild/handler/guildHandler.ts

@@ -1,6 +1,6 @@
 import { Application, BackendSession, ChannelService, HandlerService, } from 'pinus';
 import { resResult, getRandEelm, shouldRefresh, sortArrRandom } 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_SELECT, USER_GUILD_SELECT, TASK_TYPE, DEBUG_MAGIC_WORD, CHANNEL_PREFIX, MSG_TYPE, MSG_SOURCE } 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, GUILD_SELECT, USER_GUILD_SELECT, TASK_TYPE, DEBUG_MAGIC_WORD, CHANNEL_PREFIX, MSG_TYPE, MSG_SOURCE, ITEM_CHANGE_REASON } from '../../../consts';
 import { UserGuildModel, UserGuildType } from '../../../db/UserGuild';
 import { checkAuth, joinGuild, getGuildWithRefActive, getUserGuildWithRefActive, addActive, settleGuildWeekly, getMyGuildInfo, refreshUserGuild, setUserGuildSession } from '../../../services/guildService';
 import { GuildModel, GuildType, GuildUpdateParam } from '../../../db/Guild';
@@ -63,7 +63,7 @@ export class GuildHandler {
             return resResult(STATUS.GUILD_PAY_CONDITION);
         }
 
-        await handleCost(roleId, sid, [getGoldObject(ARMY.ARMY_CREAT_COST)]);
+        await handleCost(roleId, sid, [getGoldObject(ARMY.ARMY_CREAT_COST)], ITEM_CHANGE_REASON.CREATE_GUILD);
 
         // 创建公会
         const guild = await GuildModel.createGuild({ guildCode, name, icon, notice }, role, serverId);
@@ -677,7 +677,7 @@ export class GuildHandler {
         if (ARMY.ARMY_IMPEACH_COST > role.gold) {
             return resResult(STATUS.DAILY_REFRESH_GOLD_LACK);
         }
-        await handleCost(roleId, sid, [getGoldObject(ARMY.ARMY_IMPEACH_COST)]);
+        await handleCost(roleId, sid, [getGoldObject(ARMY.ARMY_IMPEACH_COST)], ITEM_CHANGE_REASON.GUILD_IMPEACH);
 
         const topUser = <RoleType>topUserGuild.role;
         // 交换
@@ -848,7 +848,7 @@ export class GuildHandler {
         }
         userGuild.receivedActive.push(id);
 
-        let goods = await addItems(roleId, roleName, sid, activeDayReward.reward);
+        let goods = await addItems(roleId, roleName, sid, activeDayReward.reward, ITEM_CHANGE_REASON.GUILD_ACTIVE_REWARD);
         userGuild = await UserGuildModel.updateInfo(roleId, { receivedActive: userGuild.receivedActive }, {}, 'receivedActive');
 
         // 任务

game-server/app/servers/guild/handler/guildRefineHandler.ts

@@ -1,7 +1,7 @@
 import { Application, BackendSession, pinus, HandlerService, } from 'pinus';
 import { UserGuildModel } from '../../../db/UserGuild';
 import { resResult } from '../../../pubUtils/util';
-import { STATUS, GUILD_OPERATE, TASK_TYPE } from '../../../consts';
+import { STATUS, GUILD_OPERATE, TASK_TYPE, ITEM_CHANGE_REASON } from '../../../consts';
 import { GuildRefineModel } from '../../../db/GuildRefine';
 import { getArmyDevelopConsumeById, getGoodById } from '../../../pubUtils/data';
 import { nowSeconds } from '../../../pubUtils/timeUtil';
@@ -67,10 +67,10 @@ export class GuildRefineHandler {
         }
         if (!findDevelopConsume)
             return resResult(STATUS.GUILD_NOT_REFINE_THE_EQUIP);
-        let result = await handleCost(roleId, sid, findDevelopConsume.honourConsume);
+        let result = await handleCost(roleId, sid, findDevelopConsume.honourConsume, ITEM_CHANGE_REASON.REFINE_EQUIP);
         if (!result)
             return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
-        let goods = await addItems(roleId, roleName, sid, [{ id: pid, count: 1 }]);
+        let goods = await addItems(roleId, roleName, sid, [{ id: pid, count: 1 }], ITEM_CHANGE_REASON.REFINE_EQUIP);
 
         // 任务
         await checkTask(roleId, sid, TASK_TYPE.GUILD_REFINE, 1, true, { quality: pieceInfo.lvLimited });
@@ -156,7 +156,7 @@ export class GuildRefineHandler {
             res.releaseCallback();
             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 }]);
+        let result = await handleCost(roleId, sid, [{ id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.GOLD), count: ARMY.ARMY_DEVELOPMENT_SPEEDCOST }], ITEM_CHANGE_REASON.ASSIST_REFINE);
         if (!result) {
             res.releaseCallback();
             return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);

game-server/app/servers/guild/handler/guildTrainHandler.ts

@@ -1,6 +1,6 @@
 import { Application, BackendSession, HandlerService, } from 'pinus';
 import { resResult, genCode, getRandSingleEelm } from '../../../pubUtils/util';
-import { DEBUG_MAGIC_WORD, STATUS, TASK_TYPE } from '../../../consts';
+import { DEBUG_MAGIC_WORD, ITEM_CHANGE_REASON, STATUS, TASK_TYPE } from '../../../consts';
 import { GuildTrainModel } from '../../../db/GuildTrain';
 import { BattleRecordModel } from '../../../db/BattleRecord';
 import { nowSeconds, getTimeFun, getZeroPoint } from '../../../pubUtils/timeUtil';
@@ -191,7 +191,7 @@ export class GuildTrainHandler {
         }
         let addScore = Math.floor((isSuccess ? trainSoloReward.winScore : trainSoloReward.failScore));//个人获得积分，也是压制进度
         //个人功勋奖励
-        let goods = await addItems(roleId, roleName, sid, [{ id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.HONOUR), count: Math.floor((isSuccess ? trainSoloReward.winHonour : trainSoloReward.failHonour) * soloRewardRatio) }]);
+        let goods = await addItems(roleId, roleName, sid, [{ id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.HONOUR), count: Math.floor((isSuccess ? trainSoloReward.winHonour : trainSoloReward.failHonour) * soloRewardRatio) }], ITEM_CHANGE_REASON.TRAIN_BATTLE_END);
         let { isComplete, ranks } = guildTrain;
         let reports = [];
         // let index = findIndex(ranks, { roleId });
@@ -249,6 +249,7 @@ export class GuildTrainHandler {
         let { trainCount, trainRewards } = userGuild;
         let result: any = getGuildTrainInfo(guildTrain, roleId, trainCount, trainRewards);//战斗后更新练兵场信息
         result.battleGoods = goods;
+        result.createdAt = time;
         await addActive(roleId, serverId, GUILD_POINT_WAYS.TRAIN);
 
         // 任务
@@ -307,7 +308,7 @@ export class GuildTrainHandler {
             return resResult(STATUS.GUILD_TRAIN_BOX_IS_GOT);
         }
         let good = getRandSingleEelm(trainInfo.heroRewards);
-        let goods = await addItems(roleId, roleName, sid, [good]);
+        let goods = await addItems(roleId, roleName, sid, [good], ITEM_CHANGE_REASON.TRAIN_BOX_REWARD);
 
         let resGuildTrain = await GuildTrainModel.receiveBoxByIndex(code, roleId, trainId, hid, index, good);
         res.releaseCallback();//解锁
@@ -345,7 +346,7 @@ export class GuildTrainHandler {
         if (!userGuild) {
             return resResult(STATUS.INTERNAL_ERR);
         }
-        let goods = await addItems(roleId, roleName, sid, jinjieReward);
+        let goods = await addItems(roleId, roleName, sid, jinjieReward, ITEM_CHANGE_REASON.TRAIN_LV_REWARD);
         let { trainRewards } = userGuild;
         return resResult(STATUS.SUCCESS, { trainRewards, goods });
     }
@@ -361,7 +362,7 @@ export class GuildTrainHandler {
             return resResult(STATUS.WRONG_PARMS);
         if (userGuild.buyTrainCount >= ARMY.ARMY_TRAIN_BUYTIMES)
             return resResult(STATUS.GUILD_BUY_TRAIN_COUNT_REACH_MAX);
-        let result = await handleCost(roleId, sid, [{ id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.GOLD), count: ARMY.ARMY_TRAIN_TIMESCOST }]);
+        let result = await handleCost(roleId, sid, [{ id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.GOLD), count: ARMY.ARMY_TRAIN_TIMESCOST }], ITEM_CHANGE_REASON.TRAIN_BATTLE_BUY_CNT);
         if (!result)
             return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
         let { trainCount, buyTrainCount } = await UserGuildModel.addTrainCount(roleId, count);

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

@@ -3,7 +3,7 @@ import { UserGuildModel } from '../../../db/UserGuild';
 import { GuildModel } from '../../../db/Guild';
 import { WishPoolReportModel } from '../../../db/WishPoolReport';
 import { resResult, genCode } from '../../../pubUtils/util';
-import { STATUS } from '../../../consts';
+import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
 import { getArmyWishPoolBaseByLv, getGoodById } from '../../../pubUtils/data';
 import { addItems, checkGoods, checkHeroes } from '../../../services/rewardService';
 import { IT_TYPE } from '../../../consts/constModules/itemConst';
@@ -123,7 +123,7 @@ export class WishPoolHandler {
 
         let hisOnlineInfo = await getRoleOnlineInfo(wishRoleId);
         if(hisOnlineInfo.isOnline && hisOnlineInfo.sid) {
-            await addItems(wishRoleId, role.roleName, hisOnlineInfo.sid ,  [{ id : wishGood.goodId, count: 1 }]);
+            await addItems(wishRoleId, role.roleName, hisOnlineInfo.sid ,  [{ id : wishGood.goodId, count: 1 }], ITEM_CHANGE_REASON.WISH_POOL_DONATE);
             this.app.channelService.pushMessageByUids('onWishGoodsRecive', resResult(STATUS.SUCCESS, { wishGoods: resWishGoods }), [{uid:wishRoleId, sid: hisOnlineInfo.sid}]);   
         }
         await WishPoolReportModel.addReport(code, wishRoleId, role.roleName , dntRoleId, dntRoleName, wishGood.goodId, 1);
@@ -154,7 +154,7 @@ export class WishPoolHandler {
         let result = await UserGuildModel.updateInfo(roleId, { wishGoods, receivedWishPool }, {});
         if (!result) 
             resResult(STATUS.INTERNAL_ERR);
-        let goods = await addItems(roleId, roleName, sid,  [{ id : goodId, count: drawCnt }]);
+        let goods = await addItems(roleId, roleName, sid,  [{ id : goodId, count: drawCnt }], ITEM_CHANGE_REASON.WISH_POOL_RECEIVE);
         return resResult(STATUS.SUCCESS, { goods, wishGoods });
     }
 

game-server/app/servers/role/handler/equipHandler.ts

@@ -1,9 +1,9 @@
 import { Application, BackendSession, HandlerService, } from "pinus";
-import { STATUS, EQUIP_STRENGTHEN_TYPE, CURRENCY_BY_TYPE, CURRENCY_TYPE, HERO_SYSTEM_TYPE, CONSUME_TYPE, HERO_GROW_MAX, MSG_SOURCE, JEWEL_PUSH_LV, TASK_TYPE, HERO_CE_RATIO } from "../../../consts";
+import { STATUS, EQUIP_STRENGTHEN_TYPE, CURRENCY_BY_TYPE, CURRENCY_TYPE, HERO_SYSTEM_TYPE, CONSUME_TYPE, HERO_GROW_MAX, MSG_SOURCE, JEWEL_PUSH_LV, TASK_TYPE, HERO_CE_RATIO, ITEM_CHANGE_REASON } from "../../../consts";
 import { ItemInter } from "../../../pubUtils/interface";
 
 import { resResult, parseGoodStr } from "../../../pubUtils/util";
-import { addItems, handleCost, decreaseItems, combineItems, CheckMeterial } from "../../../services/rewardService";
+import { addItems, handleCost, combineItems, CheckMeterial } from "../../../services/rewardService";
 import { EquipModel, EquipType } from "../../../db/Equip";
 import { HeroModel, EPlace, HeroType } from "../../../db/Hero";
 import Role from "../../../db/Role";
@@ -36,7 +36,7 @@ export class EquipHandler {
         let roleName: string = session.get('roleName');
         let sid: string = session.get('sid');
         let { id, count } = msg;
-        let goods = await addItems(roleId, roleName, sid, [{ id, count }]);
+        let goods = await addItems(roleId, roleName, sid, [{ id, count }], ITEM_CHANGE_REASON.DEBUG);
         return resResult(STATUS.SUCCESS, { goods });
     }
 
@@ -81,12 +81,12 @@ export class EquipHandler {
                 count: targetGood.pieces
             });
         }
-        let result = await handleCost(roleId, sid, cost);
+        let result = await handleCost(roleId, sid, cost, ITEM_CHANGE_REASON.EQUIP_COMPOSE);
         if (!result) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
 
-        await addItems(roleId, roleName, sid, jewels); // 宝石返还
+        await addItems(roleId, roleName, sid, jewels, ITEM_CHANGE_REASON.EQUIP_DEL_RETURN_JEWEL); // 宝石返还
         let items = [{ id: gid, count: 1 }];
-        let goods = await addItems(roleId, roleName, sid, items);
+        let goods = await addItems(roleId, roleName, sid, items, ITEM_CHANGE_REASON.EQUIP_COMPOSE);
         if (targetGood.suitId) {
             pushNormalEquipMsg(roleId, roleName, serverId, MSG_SOURCE.EQUIP_COMPOSE_SUIT, gid, targetGood.name, targetGood.quality);
         }
@@ -166,7 +166,7 @@ export class EquipHandler {
         let result = await handleCost(roleId, sid, [{
             id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.COIN),
             count: costCoin
-        }]);
+        }], ITEM_CHANGE_REASON.EQUIP_STRENTHEN);
         if (!result) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
 
         hero.ePlace = ePlace;
@@ -248,7 +248,7 @@ export class EquipHandler {
         let result = await handleCost(roleId, sid, [{
             id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.COIN),
             count: costCoin
-        }]);
+        }], ITEM_CHANGE_REASON.EQUIP_STRENTHEN);
         if (!result) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
 
         hero.ePlace = ePlace;
@@ -305,7 +305,7 @@ export class EquipHandler {
             return resResult(STATUS.EQUIP_REFINE_ERR);
         }
         let consumes = check.getConsume();
-        let result = await handleCost(roleId, sid, consumes);
+        let result = await handleCost(roleId, sid, consumes, ITEM_CHANGE_REASON.EQUIP_REFINE);
         if (!result)
             return resResult(STATUS.BATTLE_CONSUMES_NOT_ENOUGH);
             
@@ -358,7 +358,7 @@ export class EquipHandler {
             } else {
                 return resResult(STATUS.ROLE_ALL_SE_LOCK);
             }
-            let result = await handleCost(roleId, sid, consumes);
+            let result = await handleCost(roleId, sid, consumes, ITEM_CHANGE_REASON.EQUIP_LOCK_RANDSE);
             if (!result) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
         }
 
@@ -409,7 +409,7 @@ export class EquipHandler {
                 consumes = parseGoodStr(EQUIP.EQUIP_FOUR_REFORGED);
             }
 
-            let result = await handleCost(roleId, sid, consumes);
+            let result = await handleCost(roleId, sid, consumes, ITEM_CHANGE_REASON.EQUIP_RESTRENGTHEN);
             if (!result) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
 
             equip = await EquipModel.updateEquipInfo(eid, { previewRandSe });
@@ -519,7 +519,7 @@ export class EquipHandler {
 
         if (times == 0) return resResult(STATUS.EQUIP_QUENCH_ERR);
         let consumes = check.getConsume();
-        let result = await handleCost(roleId, sid, consumes);
+        let result = await handleCost(roleId, sid, consumes, ITEM_CHANGE_REASON.EQUIP_QUENCH);
         if (!result)
             return resResult(STATUS.BATTLE_CONSUMES_NOT_ENOUGH);
 
@@ -572,12 +572,12 @@ export class EquipHandler {
             goods = goods.concat(goodInfo.decomposeItem);
             cost.push({ seqId: equip.seqId, id: equip.id, count: 1 });
         }
-        let costResult = await handleCost(roleId, sid, cost); // 删掉装备
+        let costResult = await handleCost(roleId, sid, cost, ITEM_CHANGE_REASON.EQUIP_DECOMPOSE); // 删掉装备
         if(!costResult) return resResult(STATUS.BATTLE_CONSUMES_NOT_ENOUGH);
 
 
-        await addItems(roleId, roleName, sid, jewels); // 把原本镶嵌在装备上的宝石返还了
+        await addItems(roleId, roleName, sid, jewels, ITEM_CHANGE_REASON.EQUIP_DEL_RETURN_JEWEL); // 把原本镶嵌在装备上的宝石返还了
-        let result = await addItems(roleId, roleName, sid, goods);
+        let result = await addItems(roleId, roleName, sid, goods, ITEM_CHANGE_REASON.EQUIP_DECOMPOSE);
         return resResult(STATUS.SUCCESS, { goods: combineItems(result) });
     }
 
@@ -601,9 +601,9 @@ export class EquipHandler {
             }
         }
 
-        let costResult = await handleCost(roleId, sid, originalPiece);
+        let costResult = await handleCost(roleId, sid, originalPiece, ITEM_CHANGE_REASON.EQUIP_PIECE_DECOMPOSE);
         if(!costResult) return resResult(STATUS.BATTLE_CONSUMES_NOT_ENOUGH);
-        let result = await addItems(roleId, roleName, sid, goods);
+        let result = await addItems(roleId, roleName, sid, goods, ITEM_CHANGE_REASON.EQUIP_PIECE_DECOMPOSE);
         return resResult(STATUS.SUCCESS, { goods: combineItems(result) });
     }
 
@@ -801,7 +801,7 @@ export class EquipHandler {
         } else if (id == 3) {
             consumes = parseGoodStr(EQUIP.EQUIP_THREE_HOLE);
         }
-        let result = await handleCost(roleId, sid, consumes);
+        let result = await handleCost(roleId, sid, consumes, ITEM_CHANGE_REASON.EQUIP_DIG_HOLE);
         if (!result)
             return resResult(STATUS.BATTLE_CONSUMES_NOT_ENOUGH);
         equip.holes[index].isOpen = true;
@@ -835,14 +835,14 @@ export class EquipHandler {
         if (!!oldJewel)
             goods.push({ id: oldJewel, count: 1 });
         consumes.push({ id: jewel, count: 1 });
-        let result = await handleCost(roleId, sid, consumes);
+        let result = await handleCost(roleId, sid, consumes, ITEM_CHANGE_REASON.EQUIP_FILL_HOLE);
         if (!result)
             return resResult(STATUS.BATTLE_CONSUMES_NOT_ENOUGH);
         equip.holes[index].jewel = jewel;
         await EquipModel.updateEquipInfo(eid, { holes: equip.holes });
         let roleName: string = session.get('roleName');
         if (goods.length)
-            await addItems(roleId, roleName, sid, goods);
+            await addItems(roleId, roleName, sid, goods, ITEM_CHANGE_REASON.TAKE_OUT_JEWEL);
         if (!!equip.hid) {
             let hero = await HeroModel.findByHidAndRoleWithEquip(equip.hid, roleId);
             await calPlayerCeAndSave(HERO_SYSTEM_TYPE.JEWEL_ON, sid, roleId, hero, {}, [jewel, oldJewel]);
@@ -879,10 +879,10 @@ export class EquipHandler {
         let needConsumes = checkMaterialEnough(consumes, jewel, count);//检查是否可以合成，并返回最终需要消耗的材料
         if (!needConsumes)
             return resResult(STATUS.WRONG_PARMS);
-        let res = await handleCost(roleId, sid, needConsumes);
+        let res = await handleCost(roleId, sid, needConsumes, ITEM_CHANGE_REASON.JEWEL_COMPOSE);
         if (!res)
             return resResult(STATUS.BATTLE_CONSUMES_NOT_ENOUGH);
-        let result = await addItems(roleId, roleName, sid, [{ id: jewel, count: count }]);
+        let result = await addItems(roleId, roleName, sid, [{ id: jewel, count: count }], ITEM_CHANGE_REASON.JEWEL_COMPOSE);
 
         if (goodInfo.lvLimited >= JEWEL_PUSH_LV) {
             pushNormalItemMsg(roleId, roleName, serverId, MSG_SOURCE.JEWEL_COMPOSE, jewel, goodInfo.name);
@@ -912,7 +912,7 @@ export class EquipHandler {
         goods.push({ id: jewel, count: 1 });
         equip.holes[index].jewel = 0;
         await EquipModel.updateEquipInfo(eid, { holes: equip.holes });
-        await addItems(roleId, roleName, sid, goods);
+        await addItems(roleId, roleName, sid, goods, ITEM_CHANGE_REASON.TAKE_OUT_JEWEL);
         if (!!equip.hid) {
             let hero = await HeroModel.findByHidAndRole(equip.hid, roleId);
             await calPlayerCeAndSave(HERO_SYSTEM_TYPE.JEWEL_OFF, sid, roleId, hero, {}, [jewel]);
@@ -943,15 +943,15 @@ export class EquipHandler {
         let needConsumes = checkMaterialEnough(consumes.concat(purchaseGoods), jewel, count);//检查是否可以合成，并返回最终需要消耗的材料
         if (!needConsumes)
             return resResult(STATUS.WRONG_PARMS);
-        let items: Array<{ id: number, count: number, ratio?: number }> = [];
+        let items: ItemInter[] = [];
         for (let item of purchaseGoods) {
-            items.push({ id: item.id, count: item.count, ratio: 1 })//加上购买的数量
+            items.push({ id: item.id, count: item.count })//加上购买的数量
         }
         items = items.concat(needConsumes);
-        let hasError = await decreaseItems(roleId, sid, items);//合并消耗是否足够
+        let costResult = await handleCost(roleId, sid, items, ITEM_CHANGE_REASON.JEWEL_COMPOSE);//合并消耗是否足够
-        if (!!hasError)
+        if (!costResult)
             return resResult(STATUS.BATTLE_CONSUMES_NOT_ENOUGH);
-        await addItems(roleId, roleName, sid, [{ id: jewel, count: count }]);
+        await addItems(roleId, roleName, sid, [{ id: jewel, count: count }], ITEM_CHANGE_REASON.JEWEL_COMPOSE);
         if (goodInfo.lvLimited >= JEWEL_PUSH_LV) {
             pushNormalItemMsg(roleId, roleName, serverId, MSG_SOURCE.JEWEL_COMPOSE, jewel, goodInfo.name);
         }
@@ -967,7 +967,7 @@ export class EquipHandler {
         let roleId: string = session.get('roleId');
         let roleName: string = session.get('roleName');
         let sid: string = session.get('sid');
-        let result = await addItems(roleId, roleName, sid, purchaseGoods);
+        let result = await addItems(roleId, roleName, sid, purchaseGoods, ITEM_CHANGE_REASON.DEBUG);
         if (!result) {
             return resResult(STATUS.BATTLE_CONSUMES_NOT_ENOUGH);
         }
@@ -989,7 +989,7 @@ export class EquipHandler {
         let good = ITID.get(goodInfo.itid);
         let needUpdate = false;
         let oldJewel: number;
-        let consumes: Array<{ id: number, count: number, ratio?: number }> = [];
+        let consumes: Array<{ id: number, count: number }> = [];
         if (good.type != CONSUME_TYPE.JEWEL || !eid || eid < 0)
             return resResult(STATUS.WRONG_PARMS);
         let equip = await EquipModel.getEquip(eid);
@@ -1003,15 +1003,15 @@ export class EquipHandler {
             oldJewel = equip.holes[index].jewel;
             equip.holes[index].jewel = jewel;//合成后的新宝石穿戴到装备上
             needUpdate = true;
-            consumes.push({ id: goodInfo.composeMaterial[0].id, count: 1, ratio: 1 });//ratio：1表示可以释放掉一颗宝石
+            consumes.push({ id: goodInfo.composeMaterial[0].id, count: 1 });//ratio：1表示可以释放掉一颗宝石
         }
 
         consumes = consumes.concat(goodInfo.composeMaterial);
         if (goodInfo.specialMaterial.count) {
             consumes.push({ id: goodInfo.specialMaterial.ids[0], count: goodInfo.specialMaterial.count })
         }
-        let hasError = await decreaseItems(roleId, sid, consumes);//检查是消耗是否足够
+        let costResult = await handleCost(roleId, sid, consumes, ITEM_CHANGE_REASON.JEWEL_COMPOSE);//检查是消耗是否足够
-        if (!!hasError)
+        if (!costResult)
             return resResult(STATUS.BATTLE_CONSUMES_NOT_ENOUGH);
 
         if (goodInfo.lvLimited >= JEWEL_PUSH_LV) {
@@ -1043,7 +1043,7 @@ export class EquipHandler {
 
             return resResult(STATUS.SUCCESS, { curEquip: { seqId: eid, holes: equip.holes } });
         } else {
-            result = await addItems(roleId, roleName, sid, [{ id: jewel, count: count }]);
+            result = await addItems(roleId, roleName, sid, [{ id: jewel, count: count }], ITEM_CHANGE_REASON.JEWEL_COMPOSE);
             return resResult(STATUS.SUCCESS, { goods: [{ id: jewel, count }] });
         }
     }
@@ -1094,11 +1094,11 @@ export class EquipHandler {
 
         // 消耗藏宝图和寻宝币
 
-        let costResult = await handleCost(roleId, sid, [...original, ...dicCompose.coinNum]);
+        let costResult = await handleCost(roleId, sid, [...original, ...dicCompose.coinNum], ITEM_CHANGE_REASON.BLUEPRT_COMPOSE);
         if (!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
 
         const reward = [{ id: target, count: 1 }];
-        const goods = await addItems(roleId, roleName, sid, reward);
+        const goods = await addItems(roleId, roleName, sid, reward, ITEM_CHANGE_REASON.BLUEPRT_COMPOSE);
         if (dicCompose.targetQuality >= QUALITY_TYPE.ORANGE) {
             const { name } = gameData.goods.get(target);
             pushNormalItemMsg(roleId, roleName, serverId, MSG_SOURCE.ORANGE_BLUEPRT_COMPOSE, target, name);

game-server/app/servers/role/handler/friendHandler.ts

@@ -1,6 +1,6 @@
 import { Application, BackendSession, ChannelService, HandlerService, } from "pinus";
 import { resResult, getRandEelm, getResStr, shouldRefresh, sortArrRandom, checkRoleIsRobot, getRobotSysType, makeRobotId } from "../../../pubUtils/util";
-import { STATUS, ROLE_SELECT, FRIEND_DROP_TYPE, FRIEND_RELATION_TYPE, POPULATE_TYPE, BLOCK_OPEATE, CONSUME_TYPE, ITID, HERO_SELECT, EQUIP_SELECT, REDIS_KEY, MSG_SOURCE, MSG_TYPE, TASK_TYPE, ROBOT_SYS_TYPE } from "../../../consts";
+import { STATUS, ROLE_SELECT, FRIEND_DROP_TYPE, FRIEND_RELATION_TYPE, POPULATE_TYPE, BLOCK_OPEATE, CONSUME_TYPE, ITID, HERO_SELECT, EQUIP_SELECT, REDIS_KEY, MSG_SOURCE, MSG_TYPE, TASK_TYPE, ROBOT_SYS_TYPE, ITEM_CHANGE_REASON } from "../../../consts";
 import { RoleModel, RoleType } from "../../../db/Role";
 import { getTimeFun, getZeroPointD } from "../../../pubUtils/timeUtil";
 import { FriendApplyModel } from "../../../db/FriendApply";
@@ -550,7 +550,7 @@ export class FriendHandler {
         }
         if (todayReceiveInc <= 0) return resResult(STATUS.FRIEND_HAS_RECEIVE);
         let fp = getFriendPointObject(todayReceiveCnt);
-        let goods = await addItems(roleId, roleName, sid, [fp])
+        let goods = await addItems(roleId, roleName, sid, [fp], ITEM_CHANGE_REASON.RECEIVE_FRIEND_HEART)
 
         frdPointRec = await FriendPointModel.updatePointToday(roleId, roleName, todayReceiveInc, max, FRIEND_DROP_TYPE.SEND_GIFT);
 
@@ -588,7 +588,7 @@ export class FriendHandler {
             }
         }
 
-        let costResult = await handleCost(roleId, sid, items);
+        let costResult = await handleCost(roleId, sid, items, ITEM_CHANGE_REASON.FRIEND_SEND_PRESENT);
         if (!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
 
         let result = await FriendShipModel.addFriendValue(roleId, hisRoleId, friendValueInc);

game-server/app/servers/role/handler/heroHandler.ts

@@ -4,7 +4,7 @@ import { calPlayerCeAndSave, calAllHeroCe } from '../../../services/playerCeServ
 import { resResult, deepCopy } from '../../../pubUtils/util';
 import { STATUS } from '../../../consts/statusCode';
 import { HeroModel, Connect, HeroSkin, HeroUpdate, EPlace } from '../../../db/Hero';
-import { CURRENCY_BY_TYPE, CURRENCY_TYPE, CONSUME_TYPE, HERO_GROW_MAX, HERO_SYSTEM_TYPE, ABI_STAGE, DEBUG_MAGIC_WORD, HERO_INITIAL_QUALITY, REDIS_KEY, TASK_TYPE } from '../../../consts';
+import { CURRENCY_BY_TYPE, CURRENCY_TYPE, CONSUME_TYPE, HERO_GROW_MAX, HERO_SYSTEM_TYPE, ABI_STAGE, DEBUG_MAGIC_WORD, HERO_INITIAL_QUALITY, REDIS_KEY, TASK_TYPE, ITEM_CHANGE_REASON } from '../../../consts';
 import { RoleModel } from '../../../db/Role';
 import { ItemModel } from '../../../db/Item';
 import { gameData, getHeroExpByLv, getHeroStarByQuality, getHeroWakeByQuality, getHeroLvByExp, getMaxGradeByjobClass, getJobByGradeAndClass, getFriendShipById, getFavourLvByExp, reloadDicParam } from '../../../pubUtils/data';
@@ -46,7 +46,7 @@ export class HeroHandler {
         if (!dicHero) return resResult(STATUS.DIC_DATA_NOT_FOUND);
         let { pieceId, quality, pieceCount } = dicHero;
         // 碎片数量是否足够
-        let costResult = await handleCost(roleId, sid, [{ id: pieceId, count: pieceCount }]);
+        let costResult = await handleCost(roleId, sid, [{ id: pieceId, count: pieceCount }], ITEM_CHANGE_REASON.COMPOSE_HERO);
         if (!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
         // createHero
         let { heroes, resultHeroes } = await createHero(roleId, roleName, sid, serverId, { hid, count: 1 });
@@ -107,7 +107,7 @@ export class HeroHandler {
 
         let newLv = getHeroLvByExp(newExp);
 
-        let costResult = await handleCost(roleId, sid, material);
+        let costResult = await handleCost(roleId, sid, material, ITEM_CHANGE_REASON.HERO_LV_UP);
         if (!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
 
         let update = {
@@ -124,7 +124,7 @@ export class HeroHandler {
         const curHero = {
             hid, lv: hero.lv, exp: hero.exp
         }
-        return resResult(STATUS.SUCCESS, { curHero });
+        return resResult(STATUS.SUCCESS, { curHero, cost: material });
 
     }
 
@@ -168,7 +168,7 @@ export class HeroHandler {
         }
         if (newStarStage == oldStarStage) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
         let consumes = check.getConsume();
-        let result = await handleCost(roleId, sid, consumes);
+        let result = await handleCost(roleId, sid, consumes, ITEM_CHANGE_REASON.HERO_STAR_UP);
         if (!result)
             return resResult(STATUS.BATTLE_CONSUMES_NOT_ENOUGH);
 
@@ -232,7 +232,7 @@ export class HeroHandler {
         if (!curDicHeroQualityUp) return resResult(STATUS.DIC_DATA_NOT_FOUND);
         let { fragmentNum } = curDicHeroQualityUp;
 
-        let costResult = await handleCost(roleId, sid, [{ id: pieceId, count: fragmentNum }]);
+        let costResult = await handleCost(roleId, sid, [{ id: pieceId, count: fragmentNum }], ITEM_CHANGE_REASON.HERO_QUALITY_UP);
         if (!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
 
         hero = await calPlayerCeAndSave(HERO_SYSTEM_TYPE.QUALITY, sid, roleId, hero, {
@@ -298,7 +298,7 @@ export class HeroHandler {
         }
         if (newColorStarStage == oldColorStarStage) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
         let consumes = check.getConsume();
-        let result = await handleCost(roleId, sid, consumes);
+        let result = await handleCost(roleId, sid, consumes, ITEM_CHANGE_REASON.HERO_WAKE_UP);
         if (!result)
             return resResult(STATUS.BATTLE_CONSUMES_NOT_ENOUGH);
 
@@ -367,7 +367,7 @@ export class HeroHandler {
         }
         if (newJobStage == hero.jobStage) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
         let consumes = check.getConsume();
-        let result = await handleCost(roleId, sid, consumes);
+        let result = await handleCost(roleId, sid, consumes, ITEM_CHANGE_REASON.HERO_JOB_TRAIN);
         if (!result)
             return resResult(STATUS.BATTLE_CONSUMES_NOT_ENOUGH);
 
@@ -401,7 +401,7 @@ export class HeroHandler {
             return resResult(STATUS.NOT_REACH_UNLOCK_LEVEL);
         if (curJob >= getMaxGradeByjobClass(heroJob.job_class))
             return resResult(STATUS.HERO_JOB_REACH_MAX_STAGE);
-        let result = await handleCost(roleId, sid, heroJob.upGradeConsume);
+        let result = await handleCost(roleId, sid, heroJob.upGradeConsume, ITEM_CHANGE_REASON.HERO_JOB_STAGEUP);
         if (!result) {
             return resResult(STATUS.BATTLE_CONSUMES_NOT_ENOUGH);
         }
@@ -459,7 +459,7 @@ export class HeroHandler {
             if (member.star + member.colorStar < friendShip.level)
                 return resResult(STATUS.NOT_REACH_UNLOCK_LEVEL);
         }
-        let result = await handleCost(roleId, sid, [{ id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.COIN), count: friendShip.costCoin }]);
+        let result = await handleCost(roleId, sid, [{ id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.COIN), count: friendShip.costCoin }], ITEM_CHANGE_REASON.HERO_CONNECT_ACTIVE);
         if (!result) {
             return resResult(STATUS.BATTLE_CONSUMES_NOT_ENOUGH);
         }
@@ -528,7 +528,7 @@ export class HeroHandler {
 
         let newLv = getFavourLvByExp(newExp);
 
-        let result = await handleCost(roleId, sid, material);
+        let result = await handleCost(roleId, sid, material, ITEM_CHANGE_REASON.HERO_GIVE_FAVOR);
         if (!result) {
             return resResult(STATUS.BATTLE_CONSUMES_NOT_ENOUGH);
         }
@@ -545,7 +545,7 @@ export class HeroHandler {
         } else {
             hero = await HeroModel.updateHeroInfo(roleId, hero.hid, { favour: newExp, favourLv: newLv });
         }
-        return resResult(STATUS.SUCCESS, { curHero: { hid: hero.hid, favour: hero.favour, favourLv: hero.favourLv } });
+        return resResult(STATUS.SUCCESS, { curHero: { hid: hero.hid, favour: hero.favour, favourLv: hero.favourLv, cost: material } });
     }
 
     //穿带时装
@@ -658,7 +658,7 @@ export class HeroHandler {
         if (!dicHero) return resResult(STATUS.HERO_NOT_FIND);
         await addItems(roleId, roleName, sid, [{
             id: dicHero.pieceId, count: dicHero.pieceCount * HERO_GROW_MAX.STAR * ABI_STAGE.END
-        }]);
+        }], ITEM_CHANGE_REASON.DEBUG);
 
         let hero = await HeroModel.findByHidAndRole(hid, roleId);
         if (!hero) return resResult(STATUS.HERO_NOT_FIND);
@@ -690,7 +690,7 @@ export class HeroHandler {
                 await RoleModel.updateRoleInfo(roleId, role);
             }
         }
-        let result = await addItems(roleId, roleName, sid, items);
+        let result = await addItems(roleId, roleName, sid, items, ITEM_CHANGE_REASON.DEBUG);
         if (!result) {
             return resResult(STATUS.BATTLE_CONSUMES_NOT_ENOUGH);
         }

game-server/app/servers/role/handler/itemHandler.ts

@@ -1,5 +1,5 @@
 import { Application, BackendSession, HandlerService, } from "pinus";
-import { STATUS, CONSUME_TYPE, DEBUG_MAGIC_WORD } from "../../../consts";
+import { STATUS, CONSUME_TYPE, DEBUG_MAGIC_WORD, ITEM_CHANGE_REASON } from "../../../consts";
 import { RewardInter } from "../../../pubUtils/interface";
 
 import { resResult } from "../../../pubUtils/util";
@@ -35,7 +35,7 @@ export class ItemHandler {
         
 
         if (count > 0) {
-            let consumeResult = await handleCost(roleId, sid, [{ id: id, count: count }]);
+            let consumeResult = await handleCost(roleId, sid, [{ id: id, count: count }], ITEM_CHANGE_REASON.USE_GIFT_PACKAGE);
             if (!consumeResult) return resResult(STATUS.ACTIVITY_RES_NOT_ENOUGH);
 
             let dicGoods = gameData.goods.get(id);
@@ -82,7 +82,7 @@ export class ItemHandler {
             let { isOver } = await getAp(roleId, role.lv);
             if (isOver) return resResult(STATUS.AP_IS_FULL);
 
-            let consumeResult = await handleCost(roleId, sid, [{ id: id, count: count }]);
+            let consumeResult = await handleCost(roleId, sid, [{ id: id, count: count }], ITEM_CHANGE_REASON.USE_MEAT);
             if (!consumeResult) return resResult(STATUS.BATTLE_CONSUMES_NOT_ENOUGH);
 
             let apJson = await setAp(roleId, role.lv, dicGoods.value * count, sid);
@@ -125,10 +125,10 @@ export class ItemHandler {
             if (curCost) cost = cost.concat(curCost);
         }
 
-        let consumeResult = await handleCost(roleId, sid, cost);
+        let consumeResult = await handleCost(roleId, sid, cost, ITEM_CHANGE_REASON.BUY_MEAT);
         if (!consumeResult) return resResult(STATUS.BATTLE_CONSUMES_NOT_ENOUGH);
 
-        let goods = await addItems(roleId, roleName, sid, [{ id, count }]);
+        let goods = await addItems(roleId, roleName, sid, [{ id, count }], ITEM_CHANGE_REASON.BUY_MEAT);
         let apJson = await setApBuyTimes(roleId, role.lv, sid, count);
 
         return resResult(STATUS.SUCCESS, {
@@ -167,7 +167,7 @@ export class ItemHandler {
         await GiftCodeDetailModel.increaseUsedNum(code);
         await GiftCodeModel.increaseUsedNum(giftCode.id);
 
-        let goods = await addItems(roleId, roleName, sid, giftCode.goods);
+        let goods = await addItems(roleId, roleName, sid, giftCode.goods, ITEM_CHANGE_REASON.USE_GIFT_CODE);
         return resResult(STATUS.SUCCESS, { goods });
     }
 

game-server/app/servers/role/handler/mailHandler.ts

@@ -11,7 +11,7 @@ import { MailParam } from '../../../domain/roleField/mail';
 import { ItemInter, RewardInter } from '../../../pubUtils/interface';
 import { RoleModel } from '../../../db/Role';
 import { gameData } from '../../../pubUtils/data';
-import { ITID, RECEIVE_MAIL_TYPE } from '../../../consts';
+import { ITEM_CHANGE_REASON, ITID, RECEIVE_MAIL_TYPE } from '../../../consts';
 import { BAG } from '../../../pubUtils/dicParam';
 
 export default function(app: Application) {
@@ -146,7 +146,7 @@ export class MailHandler {
             mails.push(mailObj);
         }
 
-        let resGoods = await addItems(roleId, roleName, sid, mailGoods);
+        let resGoods = await addItems(roleId, roleName, sid, mailGoods, ITEM_CHANGE_REASON.MAIL);
 
         return resResult(STATUS.SUCCESS, { mails, goods: resGoods });
     }

game-server/app/servers/role/handler/rankHandler.ts

@@ -1,6 +1,6 @@
 import { Application, BackendSession, HandlerService, } from "pinus";
 import { resResult } from "../../../pubUtils/util";
-import { STATUS, RANK_TYPE_TO_KEY, ROLE_SELECT, RANK_TYPE, HERO_SELECT, GUILD_SELECT, RANK_FIRST_REWARD_STATUS } from "../../../consts";
+import { STATUS, RANK_TYPE_TO_KEY, ROLE_SELECT, RANK_TYPE, HERO_SELECT, GUILD_SELECT, RANK_FIRST_REWARD_STATUS, ITEM_CHANGE_REASON } from "../../../consts";
 import { RoleModel } from "../../../db/Role";
 import { UserGuildModel } from "../../../db/UserGuild";
 import { GuildModel } from "../../../db/Guild";
@@ -190,7 +190,7 @@ export class RoleHandler {
             return { id, type, status: RANK_FIRST_REWARD_STATUS.RECEIVED }
         })
 
-        let goods = await addItems(roleId, roleName, sid, rewards);
+        let goods = await addItems(roleId, roleName, sid, rewards, ITEM_CHANGE_REASON.RANK_REWARD);
 
         return resResult(STATUS.SUCCESS, {
             rewards: rewardStatus,

game-server/app/servers/role/handler/roleHandler.ts

@@ -12,7 +12,7 @@ import { SclResultInter, SclPosInter } from '../../../pubUtils/interface';
 import { SchoolModel } from '../../../db/School';
 import { getTeraphStrengthenResult, getSchoolList } from '../../../services/roleService'
 import { calPlayerCeAndSave, calAllHeroCe } from '../../../services/playerCeService';
-import { HERO_SYSTEM_TYPE, LINEUP_NUM, ROLE_SELECT, REDIS_KEY, TASK_TYPE, DEFAULT_HEROES, DEFAULT_HERO_LV, DEFAULT_ITEMS, DEFAULT_EQUIPS, DEFAULT_GOLD, DEFAULT_COIN, DEBUG_MAGIC_WORD, COUNTER, DEFAULT_LV } from '../../../consts';
+import { HERO_SYSTEM_TYPE, LINEUP_NUM, ROLE_SELECT, REDIS_KEY, TASK_TYPE, DEFAULT_HEROES, DEFAULT_HERO_LV, DEFAULT_ITEMS, DEFAULT_EQUIPS, DEFAULT_GOLD, DEFAULT_COIN, DEBUG_MAGIC_WORD, COUNTER, DEFAULT_LV, ITEM_CHANGE_REASON } from '../../../consts';
 import { checkBattleHeroesByHid, roleLevelup } from '../../../services/normalBattleService';
 import { Rank } from '../../../services/rankService';
 import { updateUserInfo } from '../../../services/redisService';
@@ -70,7 +70,7 @@ export class RoleHandler {
         session.push('roleName', () => { });
 
         let items = [].concat(DEFAULT_ITEMS, DEFAULT_EQUIPS, [getGoldObject(DEFAULT_GOLD)], [getCoinObject(DEFAULT_COIN)]);
-        await addItems(roleId, roleName, sid, items);
+        await addItems(roleId, roleName, sid, items, ITEM_CHANGE_REASON.DEFAULT_ITEMS);
 
         let battleId = SCRIPT.SCRIPT_BATTLE_ID;
         let warInfo = gameData.war.get(battleId);
@@ -104,7 +104,7 @@ export class RoleHandler {
         if (titleInfo.lvLimited > role.lv)
             return resResult(STATUS.COM_BATTLE_LV_NOT_ENOUGH)
         let consumes = titleInfo.material;
-        let result = await handleCost(roleId, sid, consumes);
+        let result = await handleCost(roleId, sid, consumes, ITEM_CHANGE_REASON.TITLE_LEVEL_UP);
         if (!result)
             return resResult(STATUS.BATTLE_CONSUMES_NOT_ENOUGH);
 
@@ -140,7 +140,7 @@ export class RoleHandler {
         if (times == 0)
             return resResult(STATUS.ROLE_TERAPH_NOT_STRENGTHEN);
 
-        let result = await handleCost(roleId, sid, consumes);
+        let result = await handleCost(roleId, sid, consumes, ITEM_CHANGE_REASON.TERAPH_STRENGTHEN);
         if (!result)
             return resResult(STATUS.BATTLE_CONSUMES_NOT_ENOUGH);
 
@@ -184,7 +184,7 @@ export class RoleHandler {
             return resResult(STATUS.DIC_DATA_NOT_FOUND);
 
         let consumes = teraphInfo.upGradeMaterial;
-        let result = await handleCost(roleId, sid, consumes);
+        let result = await handleCost(roleId, sid, consumes, ITEM_CHANGE_REASON.TERAPH_QUALITY_UP);
         if (!result)
             return resResult(STATUS.BATTLE_CONSUMES_NOT_ENOUGH);
 
@@ -284,7 +284,7 @@ export class RoleHandler {
         }
 
         const cost = parseGoodStr(SCHOOL.SCHOOL_UNLOCK_COIN);
-        const costResult = await handleCost(roleId, sid, cost);
+        const costResult = await handleCost(roleId, sid, cost, ITEM_CHANGE_REASON.UNLOCK_SCHOOL_POSITION);
         if (!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
 
         curSchool = await SchoolModel.updateBySclAndPos(roleId, schoolId, positionId, { isOpen: true })
@@ -478,7 +478,7 @@ export class RoleHandler {
         let role = await RoleModel.findByRoleId(roleId, 'renameCnt');
         let costGold = role.renameCnt >= dicParam.NAMEPLATE.NAMEPLATE_FREECOST? dicParam.NAMEPLATE.NAMEPLATE_FEECOST: 0;
         if(costGold > 0) {
-            let result = await handleCost(roleId, sid, [getGoldObject(costGold)]);
+            let result = await handleCost(roleId, sid, [getGoldObject(costGold)], ITEM_CHANGE_REASON.RENAME);
             if(!result) return resResult(STATUS.BATTLE_GOLD_NOT_ENOUGH);
         }
 

game-server/app/servers/role/handler/shopHandler.ts

@@ -1,7 +1,7 @@
 import { Application, BackendSession } from "pinus";
 import { gameData } from "../../../pubUtils/data";
 import { parseGoodStr, resResult } from "../../../pubUtils/util";
-import { STATUS, GUILD_STRUCTURE, ITID, CONSUME_TYPE, HERO_QUALITY_TYPE, HERO_GROW_MAX } from "../../../consts";
+import { STATUS, GUILD_STRUCTURE, ITID, CONSUME_TYPE, HERO_QUALITY_TYPE, HERO_GROW_MAX, ITEM_CHANGE_REASON } from "../../../consts";
 import { DicShopListModel } from "../../../db/DicShopList";
 import { UserShopModel } from "../../../db/UserShop";
 import { handleCost, addItems } from "../../../services/rewardService";
@@ -68,7 +68,7 @@ export class ShopHandler {
             id: dicShopItem.money,
             count: Math.round(dicShopItem.price * count)
         }];
-        let costResult = await handleCost(roleId, sid, cost);
+        let costResult = await handleCost(roleId, sid, cost, ITEM_CHANGE_REASON.SHOP_PURCHASE);
         if(!costResult) return resResult(STATUS.BATTLE_CONSUMES_NOT_ENOUGH);
 
         // 次数
@@ -80,7 +80,7 @@ export class ShopHandler {
             id: dicShopItem.goodid,
             count
         }];
-        let goods = await addItems(roleId, roleName, sid, reward);
+        let goods = await addItems(roleId, roleName, sid, reward, ITEM_CHANGE_REASON.SHOP_PURCHASE);
 
         return resResult(STATUS.SUCCESS, {
             shopItemId, count,
@@ -113,7 +113,7 @@ export class ShopHandler {
         let cost = [{
             id: goodsId, count
         }];
-        let costResult = await handleCost(roleId, sid, cost);
+        let costResult = await handleCost(roleId, sid, cost, ITEM_CHANGE_REASON.RECYCLE_SOUL);
         if(!costResult) return resResult(STATUS.BATTLE_CONSUMES_NOT_ENOUGH);
 
         let reward: RewardInter[] = [];
@@ -126,7 +126,7 @@ export class ShopHandler {
                 reward = parseGoodStr(SHOP.HERO_SOUL_GOLDEN); break;
         }
         // 增加货币
-        let goods = await addItems(roleId, roleName, sid, reward.map(cur => { return {id: cur.id, count: cur.count * count} }));
+        let goods = await addItems(roleId, roleName, sid, reward.map(cur => { return {id: cur.id, count: cur.count * count} }), ITEM_CHANGE_REASON.RECYCLE_SOUL);
 
         return resResult(STATUS.SUCCESS, {
             goodsId, count,

game-server/app/servers/role/handler/taskHandler.ts

@@ -1,6 +1,6 @@
 import { Application, BackendSession, pinus, HandlerService, } from "pinus";
 import { resResult, parseGoodStr, getRandSingleEelm } from "../../../pubUtils/util";
-import { STATUS, TASK_FUN_TYPE, SHOP_REFRESH_TYPE, KING_EXP_RATIO_TYPE, DEBUG_MAGIC_WORD } from "../../../consts";
+import { STATUS, TASK_FUN_TYPE, SHOP_REFRESH_TYPE, KING_EXP_RATIO_TYPE, DEBUG_MAGIC_WORD, ITEM_CHANGE_REASON } from "../../../consts";
 import { gameData } from "../../../pubUtils/data";
 import { UserTaskRecModel } from "../../../db/UserTaskRec";
 import { addItems } from "../../../services/rewardService";
@@ -86,7 +86,7 @@ export class ShopHandler {
             this.app.get('channelService').pushMessageByUids('addPoint', resResult(STATUS.SUCCESS, { activityId: obj.activityId, addPoint: point }), uids);
         }
 
-        let goods = await addItems(roleId, roleName, sid, taskReward);
+        let goods = await addItems(roleId, roleName, sid, taskReward, ITEM_CHANGE_REASON.TASK_REWARD);
         if (expItem && expItem.count > 0) {
             await roleLevelup(KING_EXP_RATIO_TYPE.TASK, roleId, expItem.count, session);
             goods.push(expItem);
@@ -123,7 +123,7 @@ export class ShopHandler {
         // 更新数据
         userTask = await UserTaskModel.incInfo(roleId, { mainTaskStage: 1 });
 
-        let goods = await addItems(roleId, roleName, sid, dicMainStage.reward);
+        let goods = await addItems(roleId, roleName, sid, dicMainStage.reward, ITEM_CHANGE_REASON.TASK_STAGE_REWARD);
         let mainTask = await getMainTask(roleId, userTask);
 
         return resResult(STATUS.SUCCESS, {
@@ -151,7 +151,7 @@ export class ShopHandler {
         if (!userTask) return resResult(STATUS.TASK_ACTIVE_NOT_ENOUGH);
 
         let reward = parseGoodStr(TASK.DAILYTASK_POINT_REWARD);
-        let goods = await addItems(roleId, roleName, sid, reward);
+        let goods = await addItems(roleId, roleName, sid, reward, ITEM_CHANGE_REASON.TASK_ACTIVE_REWARD);
 
         return resResult(STATUS.SUCCESS, {
             type: TASK_FUN_TYPE.DAILY,
@@ -205,7 +205,7 @@ export class ShopHandler {
             return resResult(STATUS.WRONG_PARMS);
         }
 
-        let goods = await addItems(roleId, roleName, sid, dicTaskBox.reward);
+        let goods = await addItems(roleId, roleName, sid, dicTaskBox.reward, ITEM_CHANGE_REASON.TASK_BOX_REWARD);
 
         return resResult(STATUS.SUCCESS, {
             type,

game-server/app/services/activity/dailyRMBGiftsService.ts

@@ -1,4 +1,4 @@
-import { ACTIVITY_TYPE, STATUS } from '../../consts';
+import { ACTIVITY_TYPE, ITEM_CHANGE_REASON, STATUS } from '../../consts';
 import { ActivityModel, ActivityModelType } from '../../db/Activity';
 import { ActivityDailyRMBGiftsModel, ActivityDailyRMBGiftsModelType } from '../../db/ActivityDailyRMBGifts';
 import { DailyRMBGiftsData } from '../../domain/activityField/dailyRMBGiftsField';
@@ -100,7 +100,7 @@ export async function makeDailyRMBGiftsReward(roleId: string, roleName: string,
             }
         }
         let rewardParamArr: Array<RewardParam> = stringToRewardParam(item.reward);
-        let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr)
+        let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.DAILY_RMB_GIFT)
         await ActivityDailyRMBGiftsModel.receiveRecord(serverId, activityId, roleId, moment(playerData.beginTime).toDate(), [item.id]);
         item.isReceive = true;
         return {

game-server/app/services/activity/giftPackageService.ts

@@ -1,4 +1,4 @@
-import { GIFT_PACKAGE_TYPE, ACTIVITY_RESOURCES_TYPE } from '../../consts';
+import { GIFT_PACKAGE_TYPE, ACTIVITY_RESOURCES_TYPE, ITEM_CHANGE_REASON } from '../../consts';
 import { gameData } from '../../pubUtils/data';
 import { addItems, createHeroes } from './../rewardService';
 import { RewardParam } from '../../domain/activityField/rewardField';
@@ -39,7 +39,7 @@ export async function useGiftPackage(roleId: string, roleName: string, sid: stri
                     allReward = reward;
                 }
 
-                result = await addReward(roleId, roleName, sid, serverId, allReward);
+                result = await addReward(roleId, roleName, sid, serverId, allReward, ITEM_CHANGE_REASON.USE_GIFT_PACKAGE);
                 break;
             }
         case GIFT_PACKAGE_TYPE.SELECTED_X://手选
@@ -57,7 +57,7 @@ export async function useGiftPackage(roleId: string, roleName: string, sid: stri
                 } else {
                     allReward = selectedReward;
                 }
-                result = await addReward(roleId, roleName, sid, serverId, allReward);
+                result = await addReward(roleId, roleName, sid, serverId, allReward, ITEM_CHANGE_REASON.USE_GIFT_PACKAGE);
                 break;
             }
         case GIFT_PACKAGE_TYPE.RANDOM_X://随机
@@ -69,7 +69,7 @@ export async function useGiftPackage(roleId: string, roleName: string, sid: stri
                     let selectedReward = getSelectedReward(giftPackageData, selectedArray)
                     allReward = allReward.concat(selectedReward);
                 }
-                result = await addReward(roleId, roleName, sid, serverId, allReward);
+                result = await addReward(roleId, roleName, sid, serverId, allReward, ITEM_CHANGE_REASON.USE_GIFT_PACKAGE);
                 break;
             }
         default:
@@ -80,13 +80,13 @@ export async function useGiftPackage(roleId: string, roleName: string, sid: stri
 }
 
 //结算奖励的内容
-export async function addReward(roleId: string, roleName: string, sid: string, serverId: number, reward: Array<RewardParam>) {
+export async function addReward(roleId: string, roleName: string, sid: string, serverId: number, reward: Array<RewardParam>, reason: number) {
     let giftReward = rewardItemData(reward);
     let goodArray = giftReward.goods;
     let heroArray = giftReward.heroes;
 
     //兑换物品
-    let goods = await addItems(roleId, roleName, sid, goodArray)
+    let goods = await addItems(roleId, roleName, sid, goodArray, reason)
     let addHeros = [];
     if (heroArray.length > 0) {
         let heroResult = await createHeroes(roleId, roleName, sid, serverId, heroArray);

game-server/app/services/activity/limitPackageService.ts

@@ -1,5 +1,5 @@
 import moment = require('moment');
-import { ACTIVITY_TYPE, STATUS } from '../../consts';
+import { ACTIVITY_TYPE, ITEM_CHANGE_REASON, STATUS } from '../../consts';
 import { ActivityModel, ActivityModelType } from '../../db/Activity';
 import { ActivityShopModel, ActivityShopModelType } from '../../db/ActivityShop';
 import { RoleModel } from '../../db/Role';
@@ -128,7 +128,7 @@ export async function makeLimitPackageReward(roleId: string, roleName: string, s
     }
 
     let rewardArray = stringToRewardParam(item.reward)
-    let result = await addReward(roleId, roleName, sid, serverId, rewardArray);
+    let result = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.BUY_LIMIT_PACKAGE);
 
     await ActivityShopModel.addRecord(activityId, roleId, playerData.roundIndex, item.id);
 

game-server/app/services/activity/monthlyTicketService.ts

@@ -1,4 +1,4 @@
-import { ACTIVITY_TYPE, MAIL_TYPE, STATUS } from '../../consts';
+import { ACTIVITY_TYPE, ITEM_CHANGE_REASON, MAIL_TYPE, STATUS } from '../../consts';
 import { ActivityModel, ActivityModelType } from '../../db/Activity';
 import { ActivityMonthlyTicketModel, ActivityMonthlyTicketModelType } from '../../db/ActivityMonthlyTicket';
 import { RewardParam } from '../../domain/activityField/rewardField';
@@ -89,7 +89,7 @@ export async function getPlayerMonthlyTicketDayReward(roleId: string, roleName:
         if (playerData.todayIndex > playerData.dayIndex) {//今天还没领取
             await ActivityMonthlyTicketModel.setDayIndex(serverId, roleId, activityId, playerData.todayIndex);
             let rewardParamArr: Array<RewardParam> = stringToRewardParam(playerData.baseReward);
-            let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr)
+            let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.MONTHLY_TICKET_DAILY)
             return result
         }
     }
@@ -121,7 +121,7 @@ export async function makeMonthlyTicketReward(roleId: string, roleName: string,
 
     let firstReward = playerData.firstReward;
     let rewardParamArr: Array<RewardParam> = stringToRewardParam(firstReward);
-    let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr)
+    let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.MONTHLY_TICKET_FIRST)
     return {
         code: 0,
         data: Object.assign(result, { item: { isOpen: true, todayIndex: 1 }, activityId: activityData.activityId })

game-server/app/services/activity/popUpShopService.ts

@@ -1,4 +1,4 @@
-import { ACTIVITY_TYPE, STATUS } from '../../consts';
+import { ACTIVITY_TYPE, ITEM_CHANGE_REASON, STATUS } from '../../consts';
 import { ActivityModel, ActivityModelType } from '../../db/Activity';
 import { PopUpShopData, } from '../../domain/activityField/popUpShopField';
 import { RewardParam } from '../../domain/activityField/rewardField';
@@ -106,7 +106,7 @@ export async function makePopUpShopReward(roleId: string, roleName: string, sid:
     playerData.setPlayerRecords(playerRecord);
 
     let rewardParamArr: Array<RewardParam> = stringToRewardParam(playerData.reward);
-    let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr)
+    let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.POP_UP_BUY_GIFT)
 
 
     return {

game-server/app/services/activity/refreshShopService.ts

@@ -1,5 +1,5 @@
 import moment = require('moment');
-import { ACTIVITY_TYPE, STATUS } from '../../consts';
+import { ACTIVITY_TYPE, ITEM_CHANGE_REASON, STATUS } from '../../consts';
 import { ActivityModel, ActivityModelType } from '../../db/Activity';
 import { ActivityRefreshShopModel, ActivityRefreshShopModelType } from '../../db/ActivityRefreshShop';
 import { RoleModel } from '../../db/Role';
@@ -139,7 +139,7 @@ export async function makeRefreshShopReward(roleId: string, roleName: string, si
     }
 
     let rewardArray = stringToRewardParam(item.reward)
-    let result = await addReward(roleId, roleName, sid, serverId, rewardArray);
+    let result = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.BUY_REFRESH_SHOP);
 
     await ActivityRefreshShopModel.addRecord(activityId, roleId, playerData.roundIndex, item.pageIndex, item.id);
 

game-server/app/services/activity/selfServiceShopActivityService.ts

@@ -1,4 +1,4 @@
-import { ACTIVITY_TYPE, REFRESH_TIME, STATUS } from '../../consts';
+import { ACTIVITY_TYPE, ITEM_CHANGE_REASON, REFRESH_TIME, STATUS } from '../../consts';
 import { ActivityModel, ActivityModelType } from '../../db/Activity';
 import { ActivitySelfServiceGoodsModel, ActivitySelfServiceGoodsModelType } from '../../db/ActivitySelfServiceGoods';
 import { ActivitySelfServiceShopModel, ActivitySelfServiceShopModelType } from '../../db/ActivitySelfServiceShop';
@@ -101,7 +101,7 @@ export async function addSelfServiceShopGiftReward(roleId: string, roleName: str
     for (let obj of rewardArray) {
         goodsStr += `${obj.type}&${obj.id}&${obj.count}|`;
     }
-    let result = await addReward(roleId, roleName, sid, serverId, rewardArray);
+    let result = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.SELF_SERVICE_SHOP_BUY_GIFT);
     //购买记录
     console.log('dddddddd', rewardArray.length, serverId, activityId, roleId, roundIndex, index, goodsStr, JSON.stringify(item))
     await ActivitySelfServiceShopModel.addBuyRecord(serverId, activityId, roleId, roundIndex, index, goodsStr);

game-server/app/services/activity/treasureHuntService.ts

@@ -1,5 +1,5 @@
 import moment = require('moment');
-import { ACTIVITY_TYPE, SERVER_OPEN_TIME, STATUS } from '../../consts';
+import { ACTIVITY_TYPE, ITEM_CHANGE_REASON, SERVER_OPEN_TIME, STATUS } from '../../consts';
 import { ActivityModel, ActivityModelType } from '../../db/Activity';
 import { ActivityTreasureHuntShopModel, ActivityTreasureHuntShopModelType } from '../../db/ActivityTreasureHuntShop';
 import { ActivityTreasureHuntTaskModel, ActivityTreasureHuntTaskModelType } from '../../db/ActivityTreasureHuntTask';
@@ -340,7 +340,7 @@ export async function makeShop(roleId: string, roleName: string, sid: string, se
     await ActivityTreasureHuntShopModel.buyShopRecord(activityId, roleId, huntRoundIndex, playerData.todayIndex, cellIndex);
 
     let rewardParamArr: Array<RewardParam> = stringToRewardParam(item.reward);
-    let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr)
+    let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.TREASURE_HUNT_SHOP_BUY)
 
     item.buyCount += 1;
     return {

game-server/app/services/activity/yuanbaoService.ts

@@ -1,4 +1,4 @@
-import { ACTIVITY_TYPE, STATUS } from '../../consts';
+import { ACTIVITY_TYPE, ITEM_CHANGE_REASON, STATUS } from '../../consts';
 import { ActivityModel, ActivityModelType } from '../../db/Activity';
 import { RoleModel } from '../../db/Role';
 import { ServerlistModel } from '../../db/Serverlist';
@@ -88,7 +88,7 @@ export async function makeYuanbaoShopReward(roleId: string, roleName: string, si
         }
     }
 
-    let result = await addReward(roleId, roleName, sid, serverId, arr)
+    let result = await addReward(roleId, roleName, sid, serverId, arr, ITEM_CHANGE_REASON.YUANBAO_SHOP_BUY)
     item.buyCount += 1;
     return {
         code: 0,

game-server/app/services/comBattleService.ts

@@ -1,6 +1,6 @@
 import { MemComBtlTeam } from './../domain/battleField/ComBattleTeamField';
 import { ItemModel } from './../db/Item';
-import { IT_TYPE } from './../consts';
+import { ITEM_CHANGE_REASON, IT_TYPE } from './../consts';
 import { COM_BTL_QUALITY } from './../consts/constModules/itemConst';
 import { FriendRelationModel } from './../db/FriendRelation';
 import { RoleModel, RoleType } from './../db/Role';
@@ -14,7 +14,6 @@ import { getRandRobot, transBossHpArr } from "./battleService";
 import { difference, omit } from 'underscore';
 import { Channel, ChannelService, pinus } from 'pinus';
 import { TREASURE, EXTERIOR } from '../pubUtils/dicParam';
-import { addItems, decreaseItems, handleCost } from './rewardService';
 import { getFriendLvAdd } from './friendService';
 import { getRoleIds } from '../pubUtils/friendUtil';
 import { getTeamSearchByQuality, rmRoleFromQueue } from './redisService';
@@ -26,6 +25,7 @@ import { getFriendPointObject } from '../pubUtils/itemUtils';
 import { DicWar } from '../pubUtils/dictionary/DicWar';
 import { getZeroPointD } from '../pubUtils/timeUtil';
 import { dispatch } from '../pubUtils/dispatcher';
+import { handleCost } from './rewardService';
 
 /**
  * 在给定的品质列表中随机返回一定数量的藏宝图Id
@@ -261,7 +261,7 @@ export async function handleComBtlProgress(teamStatus: MemComBtlTeam, robotHurtT
         // 战斗胜利队长扣减藏宝图
         if (result && teamStatus.capId != 'robot') {
             const { sid } = channel.getMember(teamStatus.capId);
-            let res = await decreaseItems(teamStatus.capId, sid, [{ id: teamStatus.blueprtId, count: 1 }]);
+            let res = await handleCost(teamStatus.capId, sid, [{ id: teamStatus.blueprtId, count: 1 }], ITEM_CHANGE_REASON.COM_BATTLE_USE_BLUEPRT);
             if (res === true) return resResult(STATUS.COM_BATTLE_BLUEPRT_NOT_ENOUGH);
         }
         // // 为了背包显示，队长藏宝图在创建队伍的时候就扣掉了，如果输了，返还藏宝图

game-server/app/services/equipService.ts

@@ -17,7 +17,7 @@ import { DicQuenchQuality } from '../pubUtils/dictionary/DicQuenchQuality';
  */
 export function checkMaterialEnough(consumes: Array<{ id: number, count: number }>, jewel: number, jewelCount: number) {
     let comJewelMap = new Map<number, number>(); // good_id => count
-    let needConsumes:{ id: number, count: number, ratio?: number }[] = []
+    let needConsumes:{ id: number, count: number }[] = []
     for(let {id, count} of consumes) {
         if(!comJewelMap.has(id)) {
             comJewelMap.set(id, count);

game-server/app/services/rewardService.ts

@@ -1,4 +1,4 @@
-import { ITID, CONSUME_TYPE, ITEM_TABLE, REDIS_KEY, TASK_TYPE, CURRENCY, CURRENCY_TYPE, MAIL_TYPE, HANDLE_REWARD_TYPE, HERO_SYSTEM_TYPE, CURRENCY_BY_TYPE } from './../consts';
+import { ITID, CONSUME_TYPE, ITEM_TABLE, REDIS_KEY, TASK_TYPE, CURRENCY, CURRENCY_TYPE, MAIL_TYPE, HANDLE_REWARD_TYPE, HERO_SYSTEM_TYPE, CURRENCY_BY_TYPE, ITEM_CHANGE_REASON } from './../consts';
 import { EquipModel, EquipType } from './../db/Equip';
 import { getRandSingleEelm, resResult } from '../pubUtils/util';
 import { RoleModel, RoleType } from '../db/Role';
@@ -93,7 +93,7 @@ export class CheckMeterial {
 }
 
 
-export async function handleCost(roleId: string, sid: string, goods: Array<ItemInter>) {
+export async function handleCost(roleId: string, sid: string, goods: Array<ItemInter>, reason: ITEM_CHANGE_REASON) {
 
     let uids = [{ uid: roleId, sid }];
     let { items, equips, gold, coin } = sortItems(goods, HANDLE_REWARD_TYPE.COST);
@@ -118,7 +118,7 @@ export async function handleCost(roleId: string, sid: string, goods: Array<ItemI
     if (items.length > 0) {
         let { hasError, result } = await ItemModel.decreaseItems(roleId, items);
         if (hasError) return false;
-        pinus.app.get('channelService').pushMessageByUids('onItemUpdate', resResult(STATUS.SUCCESS, { goods: result }), uids);
+        pinus.app.get('channelService').pushMessageByUids('onItemUpdate', resResult(STATUS.SUCCESS, { goods: result.map(cur => ({...cur, reason })) }), uids);
     }
 
     //删除装备
@@ -144,8 +144,8 @@ export async function handleCost(roleId: string, sid: string, goods: Array<ItemI
         }
 
 
-        await EquipModel.deleteEquips(roleId, equipSeqIds);
+        let equips = await EquipModel.deleteEquips(roleId, equipSeqIds);
-        pinus.app.get('channelService').pushMessageByUids('onEquipDel', resResult(STATUS.SUCCESS, { equips: equipSeqIds }), uids);
+        pinus.app.get('channelService').pushMessageByUids('onEquipDel', resResult(STATUS.SUCCESS, { equips: equips.map(equip => ({ seqId: equip.seqId, id: equip.id, inc: -1, reason })) }), uids);
     }
 
     //消耗玩家货币
@@ -161,7 +161,7 @@ export async function handleCost(roleId: string, sid: string, goods: Array<ItemI
 }
 
 // TODO: sid 在方法内部获取，且不一定存在
-export async function addItems(roleId: string, roleName: string, sid: string, goods: Array<ItemInter>) {
+export async function addItems(roleId: string, roleName: string, sid: string, goods: Array<ItemInter>, reason: ITEM_CHANGE_REASON) {
     let uids = [{ uid: roleId, sid }];
     let { items, equips, gold, coin, ap, skins, figures } = sortItems(goods, HANDLE_REWARD_TYPE.RECEIVE);
     let showItems: { id: number, seqId?: number, count: number, isBag?: boolean }[] = [];
@@ -178,7 +178,7 @@ export async function addItems(roleId: string, roleName: string, sid: string, go
         }
 
         // 直接加的
-        let { equips: equipInfos, pushMessages } = await addEquips(roleId, roleName, <{id: number, hid?: number}[]>incEquips);
+        let { equips: equipInfos, pushMessages } = await addEquips(roleId, roleName, <{id: number, hid?: number}[]>incEquips, reason);
         for (let equip of equipInfos) {
             showItems.push({ seqId: equip.seqId, id: equip.id, count: 1, isBag: true });
         }
@@ -202,7 +202,7 @@ export async function addItems(roleId: string, roleName: string, sid: string, go
 
     // 2. 道具处理
     if(items.length > 0) {
-        let { items: itemInfos } = await addBags(roleId, roleName, items);
+        let { items: itemInfos } = await addBags(roleId, roleName, items, reason);
         for (let item of items) {
             showItems.push({ id: item.id, count: item.count });
         }
@@ -239,7 +239,7 @@ export async function addItems(roleId: string, roleName: string, sid: string, go
     let figureInfos:{ heads: Figure[], frames: Figure[], spines: Figure[] }[] = []; // 头像变化推送信息
     if(skins.length > 0) {
         let heroskins: {skins: HeroSkin[], hid: number}[] = []; // 皮肤推送信息
-        let skinInfos: {id: number, hid: number }[] = [];
+        let skinInfos: {id: number, hid: number, inc: number, reason: number }[] = [];
         let calAllHeroResult = undefined; // 全局战力变化推送
     
         for (let skinId of skins) {//皮肤推送
@@ -251,7 +251,7 @@ export async function addItems(roleId: string, roleName: string, sid: string, go
                     heroskins.push({ skins: result.hero.skins, hid: result.hero.hid });
                     if(result.calAllHeroResult) calAllHeroResult = result.calAllHeroResult;
                 }
-                skinInfos.push({ id: skinId, hid: result.hero?.hid||0 })
+                skinInfos.push({ id: skinId, hid: result.hero?.hid||0, inc: 1, reason })
             }
         }
         if (!!skinInfos.length) {
@@ -263,7 +263,7 @@ export async function addItems(roleId: string, roleName: string, sid: string, go
 
     // 5. 获得头像和相框等
     if(figures.length > 0) {
-        let figureInfo = await addFigure(roleId, figures);
+        let figureInfo = await addFigure(roleId, figures, reason);
         if(figureInfo) figureInfos.push(figureInfo);
         for (let id of figures) {//皮肤推送        
             showItems.push({ id, count: 1 });
@@ -390,17 +390,6 @@ function sortItems(goods: ItemInter[], handleType: HANDLE_REWARD_TYPE) {
     return { items, equips, gold, coin, ap, skins, figures }
 }
 
-export async function decreaseItems(roleId: string, sid: string, bags: Array<{ id: number, count: number, ratio?: number }>) {
-    let uids = [{ uid: roleId, sid }];
-    if (bags.length > 0) {
-        let { hasError, result } = await ItemModel.decreaseItems(roleId, bags);
-        if (hasError) return true;
-        pinus.app.get('channelService').pushMessageByUids('onItemUpdate', resResult(STATUS.SUCCESS, { goods: result }), uids);
-    }
-    return false;
-}
-
-
 export async function checkGoods(roleId: string, goodIds: Array<number>) {
     let equipIds: Array<number> = [];
     let itemIds: Array<number> = [];
@@ -507,7 +496,7 @@ export async function createHeroes(roleId: string, roleName: string, sid: string
     }
 
     if (pieces.length > 0) {
-        let goods = await addItems(roleId, roleName, sid, pieces);
+        let goods = await addItems(roleId, roleName, sid, pieces, ITEM_CHANGE_REASON.HERO_TRANSFER_PIECE);
         resultItems = goods;
     }
     return { heroes, resultHeroes, goods: resultItems }

game-server/app/services/warRewardService.ts

@@ -4,7 +4,7 @@
  */
 
 import { BattleDropModel } from '../db/BattleDrop';
-import { getRandEelmWithWeight, getRandSingleEelm } from '../pubUtils/util';
+import { getRandEelmWithWeight, getRandSingleEelm, getReasonByWarType } from '../pubUtils/util';
 import { BATTLE_REWARD_TYPE, BLUEPRT_CONST } from '../consts';
 import { addItems, combineItemAndEquips } from './rewardService';
 import { BattleBlueprtDropModel } from '../db/BattleBlueprtDrop'
@@ -186,8 +186,7 @@ export class WarReward {
         if(combine) {
             rewards = combineItemAndEquips(rewards);
         }
-        await addItems(this.roleId, this.roleName, this.sid, rewards);
+        await addItems(this.roleId, this.roleName, this.sid, rewards, getReasonByWarType(this.warInfo.warType));
         return rewards;
     }
-
 }

game-server/config/serverProtos.ts

@@ -55,6 +55,8 @@ module.exports = {
             "message Good": {
                 'required uInt32 id': 1,
                 'required uInt32 count': 2,
+                'required uInt32 reason': 3,
+                'required sInt32 inc': 4,
             },
             'repeated Good goods': 1,
         },
@@ -145,14 +147,14 @@ module.exports = {
     //     'required uInt32 code': 2,
     //     'required Data data': 3
     // },
-    'onEquipDel': {
+    // 'onEquipDel': {
-        'message Data': {
+    //     'message Data': {
-            'repeated uInt32 equips': 1
+    //         'repeated uInt32 equips': 1
-        },
+    //     },
-        'required string msg': 1,
+    //     'required string msg': 1,
-        'required uInt32 code': 2,
+    //     'required uInt32 code': 2,
-        'required Data data': 3
+    //     'required Data data': 3
-    },
+    // },
     // 'onHeadChange': {
     //     'message Data': {
     //         "message FigureInfo": {

shared/consts/constModules/battleConst.ts

@@ -21,8 +21,8 @@ export const WAR_TYPE = {
   WARLOARDS: 7,   // 群雄
   TOWER: 8,       // 天梯
   PVP: 9,         // PVP
-  GUILD_TIMER: 10,  // 军团定时副本
+  GUILD_ACTIVITY: 10,  // 军团活动
-  GUILD_WEEKLY: 11, // 军团周副本
+  GUILD_TRAIN: 11, // 军团练兵场
   MAIN_ELITE: 12,  // 主线精英
   MYSTERY_ELITE: 13, // 秘境精英
   BRANCH: 14,        // 支线
@@ -30,6 +30,8 @@ export const WAR_TYPE = {
   ACT_SELF_SHOP: 16, // 糜家商队
   ACT_DAILY_GK: 17, // 每日关卡活动
   ACT_NEW_HERO_GK: 18, // 新将演绎活动
+  TRY: 19,           // 试用关卡
+  BOSS: 20,          // 演武台
 };
 
 // 藏宝图掉落参数

shared/consts/constModules/sysConst.ts

@@ -746,4 +746,142 @@ export enum THINKING_DATA_MODE_LIST {
     BATCH = 'batch',
     LOGGING = 'logging',
 }
-export let THINKING_DATA_MODE = THINKING_DATA_MODE_LIST.DEBUG;
+export let THINKING_DATA_MODE = THINKING_DATA_MODE_LIST.DEBUG;
+
+export enum ITEM_CHANGE_REASON {
+    DEBUG = 0,                               // debug接口、后台
+    RENAME = 1,                              // 重命名
+    DEFAULT_ITEMS = 2,                       // 初始道具
+    COMPOSE_HERO = 3,                        // 合成武将
+    HERO_LV_UP = 4,                          // 武将升级
+    HERO_STAR_UP = 5,                        // 武将升星
+    HERO_QUALITY_UP = 6,                     // 武将升品
+    HERO_WAKE_UP = 7,                        // 武将升彩星
+    HERO_JOB_TRAIN = 8,                      // 武将训练
+    HERO_JOB_STAGEUP = 9,                    // 武将职业进阶
+    HERO_CONNECT_ACTIVE = 10,                // 武将激活羁绊
+    HERO_GIVE_FAVOR = 11,                    // 武将升名望
+    TITLE_LEVEL_UP = 12,                     // 升爵位
+    TERAPH_STRENGTHEN = 13,                  // 神像强化
+    TERAPH_QUALITY_UP = 14,                  // 神像进阶
+    UNLOCK_SCHOOL_POSITION = 15,             // 解锁百家学宫位置
+    EQUIP_STRENTHEN = 16,                    // 装备强化
+    EQUIP_REFINE = 17,                       // 装备精炼
+    EQUIP_LOCK_RANDSE = 18,                  // 装备洗练锁定
+    EQUIP_RESTRENGTHEN = 19,                 // 装备洗练
+    EQUIP_QUENCH = 20,                       // 装备淬火
+    EQUIP_DIG_HOLE = 21,                     // 装备打孔
+    EQUIP_FILL_HOLE = 22,                    // 装备镶嵌
+    EQUIP_COMPOSE = 23,                      // 装备合成
+    EQUIP_DEL_RETURN_JEWEL = 24,             // 装备合成的时候返回上面镶嵌的宝石
+    EQUIP_DECOMPOSE = 25,                    // 装备分解
+    EQUIP_PIECE_DECOMPOSE = 26,              // 装备碎片分解
+    TAKE_OUT_JEWEL = 27,                     // 取下装备上的宝石
+    JEWEL_COMPOSE = 28,                      // 合成宝石
+    BLUEPRT_COMPOSE = 29,                    // 藏宝图合成
+    BUY_MEAT = 30,                           // 购买烧肉
+    USE_MEAT = 31,                           // 使用烧肉
+    USE_GIFT_PACKAGE = 32,                   // 打开礼包（物品）
+    ADD_SKIN_UNLOCK_FIGURE = 33,             // 获得皮肤解锁头像等
+    GET_HERO_UNLOCK_FIGURE = 34,             // 获得武将解锁头像等
+    HERO_FAVOR_UNLOCK_FIGURE = 35,           // 武将好感解锁头像等
+    PVP_SERIES_UNLOCK_FIGURE = 36,           // pvp连胜解锁头像等
+    GACHA_PULL = 37,                         // 抽卡
+    GACHA_ITEMS = 38,                        // 抽卡中不是武将的那些道具
+    VISIT_HERO = 39,                         // 拜访武将获得碎片
+    HERO_TRANSFER_PIECE = 40,                // 获得重复的武将转换成的碎片
+    FRIEND_SEND_PRESENT = 41,                // 好友间送礼物
+    RECEIVE_FRIEND_HEART = 42,               // 领取好友的红心
+    USE_GIFT_CODE = 43,                      // 礼包码兑换
+    MAIL = 44,                               // 邮件
+    RANK_REWARD = 45,                        // 排行榜奖励
+    SHOP_PURCHASE = 46,                      // 商店购买
+    RECYCLE_SOUL = 47,                       // 将魂回收
+    TASK_REWARD = 48,                        // 领取任务奖励
+    TASK_STAGE_REWARD = 49,                  // 主线任务阶段性奖励
+    COM_BATTLE_REWARD = 50,                  // 寻宝奖励
+    EVENT_REWARD = 51,                       // 奇遇领取奖励
+    EXPEDITION_POINT_REWARD = 52,            // 过关斩将点数宝箱
+    TOWER_HUNG_UP_REWARD = 53,               // 镇念塔挂机奖励
+    TOWER_TASK_REWARD = 54,                  // 镇念塔任务奖励
+    DAILY_BATTLE_BUY_CNT = 55,               // 每日关卡购买次数
+    DUNGEON_BATTLE_BUY_CNT = 56,             // 秘境关卡购买次数
+    PVP_BOX_REWARD = 57,                     // pvp巅峰之路
+    PVP_REFRESH_OPP = 58,                    // pvp刷新对手
+    PVP_BUY_ATTACK_CNT = 59,                 // pvp购买更新挑战次数
+    TOWER_HUNG_UP_SDP_UP = 60,               // 镇念塔挂机加速消耗
+    COM_BATTLE_USE_BLUEPRT = 61,             // 寻宝消耗藏宝图
+    TASK_ACTIVE_REWARD = 62,                 // 每日任务活跃奖励
+    TASK_BOX_REWARD = 63,                    // 每日任务每周奖励
+    NORMAL_BATTLE_END = 64,                  // 主线关卡结算奖励
+    PVP_BATTLE_END = 65,                     // pvp关卡结算奖励
+    VESTIGE_BATTLE_END = 66,                 // 遗迹本结算奖励
+    EVENT_BATTLE_END = 67,                   // 事件本结算奖励
+    DAILY_BATTLE_END = 68,                   // 每日本结算奖励
+    EXPEDITION_BATTLE_END = 69,              // 远征本结算奖励
+    MYSTERY_BATTLE_END = 70,                 // 秘境本结算奖励
+    WARLOARDS_BATTLE_END = 71,               // 群雄结算奖励
+    TOWER_BATTLE_END = 72,                   // 镇念塔结算奖励
+    MAIN_ELITE_BATTLE_END = 73,              // 主线精英结算奖励
+    BRANCH_BATTLE_END = 74,                  // 支线结算奖励
+    ACT_TREASURE_HUNT_BATTLE_END = 75,       // 神州探秘结算奖励
+    ACT_SELF_SHOP_BATTLE_END = 76,           // 糜家商队结算奖励
+    ACT_DAILY_GK_BATTLE_END = 77,            // 每日关卡活动结算奖励
+    ACT_NEW_HERO_GK_BATTLE_END = 78,         // 新将演绎活动结算奖励
+    TRY_BATTLE_END = 79,                     // 试用关卡结算奖励
+    CREATE_GUILD = 80,                       // 创建军团
+    GUILD_IMPEACH = 81,                      // 弹劾团长
+    AUCTION_DIVIDEND = 82,                   // 拍卖行分红
+    AUCTION_OFFER = 83,                      // 拍卖出价
+    DONATE = 84,                             // 捐献奖励
+    DONATE_BOX = 85,                         // 捐献累计宝箱奖励
+    BOSS_BATTLE_END = 86,                    // 演武台战场结算奖励
+    GUILD_ACTIVE_REWARD = 87,                // 军团活跃到达奖励
+    REFINE_EQUIP = 88,                       // 炼器堂炼器
+    TRAIN_BATTLE_END = 89,                   // 练兵场结算奖励
+    TRAIN_BOX_REWARD = 90,                   // 练兵场宝箱
+    TRAIN_LV_REWARD = 91,                    // 练兵场试炼等级奖励
+    TRAIN_BATTLE_BUY_CNT = 92,               // 军团练兵场购买次数
+    WISH_POOL_DONATE = 93,                   // 许愿池捐献
+    WISH_POOL_RECEIVE = 94,                  // 许愿池领取
+    GUILD_BOSS_ENCOURAGE = 95,               // 演武台敲鼓
+    ASSIST_REFINE = 96,                      // 协助点亮科技树
+    CITY_ACT_RESET_CHALLENGE_TIME = 97,      // 诸侯混战重置挑战次数
+    MONOPOLY_MOVE = 98,                      // 活动 大富翁活动移动骰子
+    MONOPOLY_BANK = 99,                      // 活动 大富翁活动存钱
+    MONOPOLY_BUY_GOODS = 100,                // 活动 大富翁商店
+    DAILY_COIN_EXCHANGE = 101,               // 活动 每日铜钱活动兑换
+    DAILY_CHALLENGE_REWARD = 102,            // 活动 每日挑战活动奖励
+    BUY_DAILY_GIFTS = 103,                   // 活动 购买每日特惠礼包
+    DAILY_MEAL_RECEIVE_REPAIRE = 104,        // 活动 午餐晚餐补领
+    DAILY_MEAL_RECEIVE = 105,                // 活动 午餐晚餐
+    DAILY_RMB_GIFT = 106,                    // 活动 每日特惠礼包
+    FIRST_GIFT = 107,                        // 活动 首充礼包
+    GROWTH_FUND = 108,                       // 活动 成长基金奖励
+    GROWTH_REWARD = 109,                     // 活动 成长任务奖励
+    GROWTH_DAY_EXCHANGE = 110,               // 活动 成长任务奖章兑换
+    BUY_LIMIT_PACKAGE = 111,                 // 活动 购买新手限定礼包
+    NEW_HERO_GACHA_PULL = 112,               // 活动 新武将抽卡获得
+    NEW_HERO_EXCHANGE = 113,                 // 活动 新将好礼兑换点数
+    POP_UP_BUY_GIFT = 114,                   // 活动 弹出礼包购买
+    RECHARGE_REWARD = 115,                   // 活动 每日累计充值
+    BUY_REFRESH_SHOP = 116,                  // 活动 购买通用的刷新商店
+    REFRESH_TASK_REWARD = 117,               // 活动 通用刷新任务奖励
+    REFRESH_TASK_EXCHANGE = 118,             // 活动 通用刷新任务兑换奖励
+    SELF_SERVICE_SHOP_BUY_RESOURCE = 119,    // 活动 糜家商队买代币
+    SELF_SERVICE_SHOP_BUY_GIFT = 120,        // 活动 糜家商队商店购买
+    REPAIRE_SIGNIN = 121,                    // 活动 补签
+    SIGNIN = 122,                            // 活动 签到
+    THIRTHDAY_TASK = 123,                    // 活动 30天任务奖励
+    THIRTHDAY_EXCHANGE = 124,                // 活动 30天点数兑换
+    TREASURE_HUNT_FIRST_PAGE_REWARD = 125,   // 活动 寻宝骑兵 首页奖励
+    TREASURE_HUNT_SHOP_BUY = 126,            // 活动 寻宝骑兵商店购买
+    TREASURE_HUNT_TASK_REWARD = 127,         // 活动 寻宝骑兵任务奖励
+    TREASURE_HUNT_CHALLENGE = 128,           // 活动 寻宝骑兵大冒险
+    TREASURE_HUNT_SP_SHOP_BUY = 129,         // 活动 寻宝骑兵天子宝库购买
+    VIP_RECHARGE_MONEY = 130,                // 活动 vip累充奖励
+    MONTHLY_TICKET_DAILY = 131,              // 活动 月卡每日奖励
+    MONTHLY_TICKET_FIRST = 132,              // 活动 月卡首次奖励
+    YUANBAO_SHOP_BUY = 133,                  // 活动 元宝商店购买
+    GET_HERO_UNLOCK_SKIN = 134,              // 获得武将解锁皮肤
+}

shared/db/Equip.ts

@@ -125,9 +125,10 @@ export default class Equip extends BaseModel {
         return result;
     }
     public static async deleteEquips(roleId: string, ids: Array<number>) {
-        let result = await EquipModel.deleteMany({ roleId, seqId: { $in: ids } });
+        let equips = await EquipModel.getEquips(roleId, ids);
+        await EquipModel.deleteMany({ roleId, seqId: { $in: ids } });
         await RoleModel.findOneAndUpdate({ roleId }, { $inc: { equipCount: -1 * ids.length } }, { new: true });
-        return result;
+        return equips;
     }
 
     public static async getEquipsByID(ids: Array<string>) {

shared/db/Item.ts

@@ -66,9 +66,9 @@ export default class Item extends BaseModel {
             if (!!rec) {
                 let index = findIndex(result,{id})
                 if (!!result[index]) {
-                    result[index] = { id: rec.id, count: rec.count }
+                    result[index] = { id: rec.id, count: rec.count, inc: -count }
                 } else {
-                    result.push({ id: rec.id, count: rec.count });
+                    result.push({ id: rec.id, count: rec.count, inc: -count });
                 }
                 updateItems.push({ id, count, ratio });
             } else {

shared/domain/dbGeneral.ts

@@ -222,6 +222,10 @@ export class Figure {
     unlockedId?: number[];			// 当前已经解锁了的type
     @prop({ required: true, default: false })
     unlocked: boolean = false;			// 是否已解锁
+    
+    // 埋点用
+    inc?: number;
+    reason?: number;
 
     public get status () {           // 虚拟字段status，当前头像是否已经解锁
         if(!this.unlocked) return this.unlocked; // 未解锁

shared/pubUtils/itemUtils.ts

@@ -4,7 +4,7 @@ import { HeroModel, HeroType, } from '../db/Hero';
 import { ItemModel } from '../db/Item';
 import { EquipModel, RandSe, Holes, RandMain, equipUpdate } from './../db/Equip';
 import { gameData, getQuenchByQualityAndGrade, getQuenchGradeByValue } from './data';
-import { RANDOM_SE_COUNT, ITID, CURRENCY_BY_TYPE, CURRENCY_TYPE, ROLE_SELECT, FIGURE_UNLOCK_CONDITION, CONSUME_TYPE, HERO_SYSTEM_TYPE, TASK_TYPE } from '../consts';
+import { RANDOM_SE_COUNT, ITID, CURRENCY_BY_TYPE, CURRENCY_TYPE, ROLE_SELECT, FIGURE_UNLOCK_CONDITION, CONSUME_TYPE, HERO_SYSTEM_TYPE, TASK_TYPE, ITEM_CHANGE_REASON } from '../consts';
 import { getRandValueByMinMax, getRandEelm } from './util';
 
 import { findWhere } from 'underscore';
@@ -61,26 +61,26 @@ export async function addSkin(roleId: string, roleName: string, skinId: number,
     }
 }
 
-export async function addBags(roleId: string, roleName: string, datas: { id: number, count: number }[]) {
+export async function addBags(roleId: string, roleName: string, datas: { id: number, count: number }[], reason: number) {
     let items: { id: number, count: number }[] = [];
     for(let data of datas) {
-        let item = await addBag(roleId, roleName, data);
+        let item = await addBag(roleId, roleName, data, reason);
         items.push(item)
     }
     return { items }
 }
 
-export async function addBag(roleId: string, roleName: string, data: { id: number, count: number }) {
+export async function addBag(roleId: string, roleName: string, data: { id: number, count: number }, reason: number) {
     let { id, count } = data;
     let { name: itemName, itid, hid } = gameData.goods.get(id);
     let { type } = ITID.get(itid);
 
     let item = await ItemModel.increaseItem(roleId, id, count, { roleId, roleName, itemName, id, type, hid });
-    return { id: item.id, count: item.count };
+    return { id: item.id, count: item.count, inc: count, reason };
 }
 
 
-export async function addEquips(roleId: string, roleName: string, weapons: { id: number, hid?: number }[]) {
+export async function addEquips(roleId: string, roleName: string, weapons: { id: number, hid?: number }[], reason: number) {
     let equipInfos: equipUpdate[] = [];
     for(let weapon of weapons) {
         let info = await getAddEquipInfo(roleId, roleName, weapon);
@@ -95,7 +95,9 @@ export async function addEquips(roleId: string, roleName: string, weapons: { id:
         pushMessages = [...pushMessages, ...pushMessage];
     }
 
-    return { equips, pushMessages }
+    return { equips: equips.map(equip => {
+        return { ...equip, inc: 1, reason }
+    }), pushMessages }
 }
 
 export async function getAddEquipInfo(roleId: string, roleName: string, weapon: { id: number, hid?: number }) {
@@ -197,20 +199,26 @@ export function getHonourObject(count: number) {
     for (let { type, paramHid, paramFavourLv, paramSkinId, paramWinStreakNum } of conditions) {
         let canUnLockList = gameData.figureCondition.get(type);
         if (canUnLockList) {
+            let reason = 0;
+
             for (let { id, params, gid } of canUnLockList) {
                 let flag = false; // 是否达成条件
                 if (type == FIGURE_UNLOCK_CONDITION.GET_HERO) {
                     let [hid] = params;
                     if (paramHid == hid) flag = true;
+                    reason = ITEM_CHANGE_REASON.GET_HERO_UNLOCK_FIGURE;
                 } else if (type == FIGURE_UNLOCK_CONDITION.HERO_FAVOR) {
                     let [hid, favourLv] = params;
                     if (paramHid == hid && paramFavourLv >= favourLv) flag = true;
+                    reason = ITEM_CHANGE_REASON.HERO_FAVOR_UNLOCK_FIGURE;
                 } else if (type == FIGURE_UNLOCK_CONDITION.GET_SKIN) {
                     let [id] = params;
                     if (paramSkinId == id) flag = true;
+                    reason = ITEM_CHANGE_REASON.ADD_SKIN_UNLOCK_FIGURE;
                 } else if (type == FIGURE_UNLOCK_CONDITION.PVP_WIN_SERIES) {
                     let [winStreakNum] = params;
                     if (paramWinStreakNum >= winStreakNum) flag = true;
+                    reason = ITEM_CHANGE_REASON.PVP_SERIES_UNLOCK_FIGURE;
                 }
                 if (!flag) continue;
                 let dicGood = gameData.goods.get(gid);
@@ -219,13 +227,13 @@ export function getHonourObject(count: number) {
                 if (!dicItid) continue;
 
                 if (dicItid.type == CONSUME_TYPE.HEAD) {
-                    let figure = unlockSingleFigure(heads, gid, false, id);
+                    let figure = unlockSingleFigure(heads, gid, reason, false, id);
                     if (figure && figure.unlocked) figureInfo.heads.push(figure);
                 } else if (dicItid.type == CONSUME_TYPE.FRAME) {
-                    let figure = unlockSingleFigure(frames, gid, false, id);
+                    let figure = unlockSingleFigure(frames, gid, reason, false, id);
                     if (figure && figure.unlocked) figureInfo.frames.push(figure);
                 } else if (dicItid.type == CONSUME_TYPE.SPINE) {
-                    let figure = unlockSingleFigure(spines, gid, false, id);
+                    let figure = unlockSingleFigure(spines, gid, reason, false, id);
                     if (figure && figure.unlocked) figureInfo.spines.push(figure);
                 } else {
                     continue;
@@ -255,7 +263,7 @@ export async function unlockFigure(roleId: string, conditions: { type: number, p
 
 
 // 直接获得形象/相框
-export async function addFigure(roleId: string, ids: number[]) {
+export async function addFigure(roleId: string, ids: number[], reason: number) {
     let role = await RoleModel.findByRoleId(roleId, ROLE_SELECT.GET_HEADS);
 
     if (!role) return false;
@@ -269,13 +277,13 @@ export async function addFigure(roleId: string, ids: number[]) {
         if (!dicItid) continue;
 
         if (dicItid.type == CONSUME_TYPE.HEAD) {
-            let figure = unlockSingleFigure(heads, gid, true);
+            let figure = unlockSingleFigure(heads, gid, reason, true);
             if (figure && figure.unlocked) figureInfo.heads.push(figure);
         } else if (dicItid.type == CONSUME_TYPE.FRAME) {
-            let figure = unlockSingleFigure(frames, gid, true);
+            let figure = unlockSingleFigure(frames, gid, reason, true);
             if (figure && figure.unlocked) figureInfo.frames.push(figure);
         } else if (dicItid.type == CONSUME_TYPE.SPINE) {
-            let figure = unlockSingleFigure(spines, gid, true);
+            let figure = unlockSingleFigure(spines, gid, reason, true);
             if (figure && figure.unlocked) figureInfo.spines.push(figure);
         } else {
             continue;
@@ -293,7 +301,7 @@ export async function addFigure(roleId: string, ids: number[]) {
  * @param unlockDirect 是否不计算解锁条件直接解锁
  * @param conditionId 条件id
  */
-function unlockSingleFigure(dbFigures: Figure[], id: number, unlockDirect = false, conditionId?: number) {
+function unlockSingleFigure(dbFigures: Figure[], id: number, reason: number, unlockDirect = false, conditionId?: number) {
     let figure = dbFigures.find(cur => cur.id == id);
     if (!figure) {
         figure = new Figure(id, false);
@@ -325,6 +333,8 @@ function unlockSingleFigure(dbFigures: Figure[], id: number, unlockDirect = fals
         }
     }
 
+    figure.inc = 1;
+    figure.reason = reason;
     return figure
 }
 

shared/pubUtils/roleUtil.ts

@@ -1,4 +1,4 @@
-import { DEFAULT_HERO_LV, FIGURE_UNLOCK_CONDITION, LINEUP_NUM, REDIS_KEY, STATUS, TASK_TYPE } from "../consts";
+import { DEFAULT_HERO_LV, FIGURE_UNLOCK_CONDITION, ITEM_CHANGE_REASON, LINEUP_NUM, REDIS_KEY, STATUS, TASK_TYPE } from "../consts";
 import { SkinModel } from "../db/Skin";
 import { DEFAULT_HEROES, HERO_SYSTEM_TYPE } from "../consts";
 import { HeroModel, HeroSkin, HeroType, HeroUpdate } from "../db/Hero";
@@ -261,12 +261,13 @@ export class CreateHeroes extends UpdateHeroes {
     private taskPushMessage: TaskListReturn[] = [];
     private activityTaskPushMessage = [];
     private figureInfos: { heads: Figure[], frames: Figure[], spines: Figure[] }[] = [];
-    private skinPushMessages: { heros: {skins: HeroSkin[], hid: number}[], skins: {id: number, hid: number }[]} = { heros: [], skins: [] };
+    private skinPushMessages: { heros: {skins: HeroSkin[], hid: number}[], skins: {id: number, hid: number, inc: number, reason: number }[]} = { heros: [], skins: [] };
     
     private async getSkinsOfThisHero(hid: number, initSkinInfo: SkinUpdate, isInit: boolean) {
         let allSkins = isInit? []: await SkinModel.findbyRoleAndHid(this.roleId, hid);
         let skin = await SkinModel.insertSkins(this.roleId, this.roleName, [initSkinInfo]);
-        this.skinPushMessages.skins.push(...skin);
+        let skinInfos = skin.map(cur => ({ id: cur.id, hid, inc: 1, reason: ITEM_CHANGE_REASON.GET_HERO_UNLOCK_SKIN}))
+        this.skinPushMessages.skins.push(...skinInfos);
         if(skin) allSkins.push(...skin);
         let skins: { id: number, skin: string, enable: boolean, skinId: number }[] = [];
         for(let skin of allSkins) {

shared/pubUtils/util.ts

@@ -5,7 +5,7 @@ import { HeroModel, HeroType } from '../db/Hero';
 const csprng = require('csprng');
 import fs = require('fs');
 import path = require('path');
-import { HERO_CE_RATIO, ABI_STAGE, GACHA_TO_FLOOR, REFRESH_TIME, ROBOT_SYS_TYPE, } from '../consts';
+import { HERO_CE_RATIO, ABI_STAGE, GACHA_TO_FLOOR, REFRESH_TIME, ROBOT_SYS_TYPE, ITEM_CHANGE_REASON, WAR_TYPE } from '../consts';
 
 import { findIndex } from 'underscore';
 import { getTimeFunM } from './timeUtil';
@@ -679,4 +679,51 @@ export async function checkWhiteList(tel: string, ip: string, auth: number) {
         if(!!result) return true;
     }
     return false
+}
+
+export function getReasonByWarType(warType: number) {
+    switch(warType) {
+        case WAR_TYPE.NORMAL:
+            return ITEM_CHANGE_REASON.NORMAL_BATTLE_END;
+        case WAR_TYPE.VESTIGE:
+            return ITEM_CHANGE_REASON.VESTIGE_BATTLE_END;
+        case WAR_TYPE.EVENT:
+            return ITEM_CHANGE_REASON.EVENT_BATTLE_END;
+        case WAR_TYPE.DAILY:
+            return ITEM_CHANGE_REASON.DAILY_BATTLE_END;
+        case WAR_TYPE.EXPEDITION:
+            return ITEM_CHANGE_REASON.EXPEDITION_BATTLE_END;
+        case WAR_TYPE.MYSTERY:
+            return ITEM_CHANGE_REASON.MYSTERY_BATTLE_END;
+        case WAR_TYPE.WARLOARDS:
+            return ITEM_CHANGE_REASON.WARLOARDS_BATTLE_END;
+        case WAR_TYPE.TOWER:
+            return ITEM_CHANGE_REASON.TOWER_BATTLE_END;
+        case WAR_TYPE.PVP:
+            return ITEM_CHANGE_REASON.PVP_BATTLE_END;
+        // case WAR_TYPE.GUILD_ACTIVITY:
+        //     return ITEM_CHANGE_REASON.GUILD_ACTIVITY_BATTLE_END;
+        case WAR_TYPE.GUILD_TRAIN:
+            return ITEM_CHANGE_REASON.TRAIN_BATTLE_END;
+        case WAR_TYPE.MAIN_ELITE:
+            return ITEM_CHANGE_REASON.MAIN_ELITE_BATTLE_END;
+        // case WAR_TYPE.MYSTERY_ELITE:
+        //     return ITEM_CHANGE_REASON.MYSTERY_ELITE_BATTLE_END;
+        case WAR_TYPE.BRANCH:
+            return ITEM_CHANGE_REASON.BRANCH_BATTLE_END;
+        case WAR_TYPE.ACT_TREASURE_HUNT:
+            return ITEM_CHANGE_REASON.ACT_TREASURE_HUNT_BATTLE_END;
+        case WAR_TYPE.ACT_SELF_SHOP:
+            return ITEM_CHANGE_REASON.ACT_SELF_SHOP_BATTLE_END;
+        case WAR_TYPE.ACT_DAILY_GK:
+            return ITEM_CHANGE_REASON.ACT_DAILY_GK_BATTLE_END;
+        case WAR_TYPE.ACT_NEW_HERO_GK:
+            return ITEM_CHANGE_REASON.ACT_NEW_HERO_GK_BATTLE_END;
+        case WAR_TYPE.TRY:
+            return ITEM_CHANGE_REASON.TRY_BATTLE_END;
+        case WAR_TYPE.BOSS:
+            return ITEM_CHANGE_REASON.BOSS_BATTLE_END;
+        default: 
+            return ITEM_CHANGE_REASON.NORMAL_BATTLE_END;
+    }
 }