活动：目标点数兑换奖励过期判断

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

@@ -1,11 +1,14 @@
 import { Application, BackendSession } from 'pinus';
-import { resResult } from '../../../pubUtils/util';
+import { deltaDays, resResult } from '../../../pubUtils/util';
 import { STATUS, ACTIVITY_RESOURCES_TYPE, ACTIVITY_TYPE } from '../../../consts';
-import { getPlayerThirtyDaysData, thirtyDaysActivity } from '../../../services/thirtyDaysService';
+import { getPlayerThirtyDaysData, playerThirtyDaysActivityDays, thirtyDaysActivity } from '../../../services/thirtyDaysService';
-import { ThirtyDaysItem, ThirtyDaysPointItem } from '../../../domain/activityField/thirtyDaysField';
+import { ThirtyDaysData, ThirtyDaysItem, ThirtyDaysPointItem } from '../../../domain/activityField/thirtyDaysField';
 import { addItems, createHeroes } from '../../../services/rewardService';
 import { ActivityThirtyDaysModel } from '../../../db/ActivityThirtyDays';
 import { ActivityThirtyDaysPointRewardModel } from '../../../db/ActivityThirtyDaysPointReward';
+import { RoleModel } from '../../../db/Role';
+import moment = require('moment');
+import { ActivityModel, ActivityModelType } from '../../../db/Activity';
 
 export default function (app: Application) {
     return new thirtyDaysHandler(app);
@@ -28,11 +31,12 @@ export class thirtyDaysHandler {
         const roleId = session.get('roleId');
         const serverId = session.get('serverId');
 
-        let playerData = await thirtyDaysActivity(ACTIVITY_TYPE.THIRTY_DAYS, serverId, roleId);
+        let todayIndex = await playerThirtyDaysActivityDays(roleId)
 
+        let playerData = await thirtyDaysActivity(ACTIVITY_TYPE.THIRTY_DAYS, serverId, roleId);
         if (!playerData) return resResult(STATUS.ACTIVITY_THIRTY_DAYS_END);
 
-        return resResult(STATUS.SUCCESS, playerData);
+        return resResult(STATUS.SUCCESS, { playerData, todayIndex });
     }
 
     /**
@@ -49,6 +53,23 @@ export class thirtyDaysHandler {
         const roleName = session.get('roleName');
         const funcs: number[] = session.get('funcs');
 
+        let todayIndex = await playerThirtyDaysActivityDays(roleId);//玩家当前的天数
+
+        let activityArray: ActivityModelType[] = await ActivityModel.findActivityByType(ACTIVITY_TYPE.THIRTY_DAYS, true)
+        activityArray = activityArray.sort((a, b) => {
+            return a.acvitityId - b.acvitityId
+        });
+
+        let activityDays = 0;
+        for (let i = 0; i < activityArray.length; i++) {
+            let playerData = new ThirtyDaysData(activityArray[i]);
+            if (playerData.activityId != activityId) {
+                activityDays += playerData.days;//周期天数
+            } else {
+                break;
+            }
+        }
+
         let playerData = await getPlayerThirtyDaysData(activityId, serverId, roleId)
         if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
 
@@ -63,6 +84,17 @@ export class thirtyDaysHandler {
             return resResult(STATUS.ACTIVITY_REWARDED);
         }
 
+        if (activityDays < todayIndex && todayIndex <= (activityDays + playerData.days)) {//时间正常范围内
+
+        } else if (todayIndex > (activityDays + playerData.days)) {//活动已经过期
+            console.log('过期奖励')
+            let expiredItems: Array<ThirtyDaysPointItem> = playerData.needMark();
+            let cells = expiredItems.map(obj => obj.cellIndex)
+            await ActivityThirtyDaysPointRewardModel.setExpired(activityId, roleId, cells);
+        } else {//活动未到开启时间
+            return resResult(STATUS.ACTIVITY_TIME_ERROR);
+        }
+
         await ActivityThirtyDaysModel.addRecord(activityId, roleId, pageIndex, cellIndex);
         let reward = thirtyDaysItemData.goodReward();
         let goods = await addItems(roleId, roleName, sid, reward);

game-server/app/services/thirtyDaysService.ts

@@ -2,9 +2,11 @@ import { ACTIVITY_TYPE, TASK_TYPE } from '../consts';
 import { ActivityModel, ActivityModelType } from '../db/Activity';
 import { ActivityThirtyDaysModel, ActivityThirtyDaysModelType } from '../db/ActivityThirtyDays';
 import { ActivityBuyRecordsModel, ActivityBuyRecordsModelType } from '../db/ActivityBuyRecords';
-import { RoleModel } from '../db/Role';
 import { ThirtyDaysData, ThirtyDaysItem } from '../domain/activityField/thirtyDaysField';
 import { ActivityThirtyDaysPointRewardModel, ActivityThirtyDaysPointRewardModelType } from '../db/ActivityThirtyDaysPointReward';
+import Role, { RoleModel } from '../db/Role';
+import moment = require('moment');
+import { deltaDays } from '../pubUtils/util';
 
 /**
    * 获取活动数据
@@ -20,15 +22,14 @@ export async function thirtyDaysActivity(type: number, serverId: number, roleId:
     activityArray = activityArray.sort((a, b) => {
         return a.acvitityId - b.acvitityId
     });
+    let allPlayerActivity = [];
     for (let i = 0; i < activityArray.length; i++) {
         let activityData = activityArray[i];
         let playerData = await getPlayerThirtyDaysData(activityData.acvitityId, serverId, roleId);
-        if (!playerData.isComplete()) {
+        allPlayerActivity.push(playerData)
-            return playerData;
-        }
     }
 
-    return null
+    return allPlayerActivity
 }
 
 /**
@@ -69,3 +70,20 @@ export async function addPlayerThirtyDaysTask(activityId: number, serverId: numb
     return playerData;
 }
 
+/**
+   * 玩家活动第几天
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   *
+   */
+export async function playerThirtyDaysActivityDays(roleId: string) {
+    let { createTime } = await RoleModel.findByRoleId(roleId);
+    let createDate = moment(createTime * 1000).toDate();
+    let todayIndex = deltaDays(createDate, new Date) + 1;
+    return todayIndex;
+}
+{
+
+}

shared/db/ActivityThirtyDays.ts

@@ -22,7 +22,6 @@ export default class ActivityThirtyDays extends BaseModel {
     @prop({ required: true })
     isReceive: boolean;				// 是否领取过奖励
 
-
     //添加领取记录
     public static async addRecord(acvitityId: number, roleId: string, pageIndex: number, cellIndex: number, lean = true) {
         let result: ActivityThirtyDaysModelType = await ActivityThirtyDaysModel.findOneAndUpdate({ roleId, acvitityId, pageIndex, cellIndex },

shared/db/ActivityThirtyDaysPointReward.ts

@@ -15,7 +15,24 @@ export default class ActivityThirtyDaysPointReward extends BaseModel {
     cellIndex: number;			    // 第几个奖励
     @prop({ required: true })
     isReceive: boolean;				// 是否领取过奖励
+    @prop({ required: true })
+    isExpired: boolean;				// 是否过期奖励
 
+    //添加过期记录
+    public static async setExpired(acvitityId: number, roleId: string, cells: Array<number>) {
+        let records = [];
+        for (let cellIndex of cells) {
+            let data = {
+                acvitityId,
+                roleId,
+                cellIndex,
+                isReceive: false,
+                isExpired: true,
+            }
+            records.push(data)
+        }
+        await ActivityThirtyDaysPointRewardModel.insertMany(records);
+    }
 
     //添加领取记录
     public static async addRecord(acvitityId: number, roleId: string, cellIndex: number, lean = true) {

shared/domain/activityField/thirtyDaysField.ts

@@ -16,18 +16,23 @@ export class ThirtyDaysPointItem {
 
     isReceive: boolean = false;          //是否领取过奖励
 
+    isExpired: boolean = false;         //奖励是否已经过期
 
     constructor(data: any) {
         this.cellIndex = data.cellIndex;
         this.consumePoint = data.consumePoint;
         this.reward = data.reward;
         this.expiredReward = data.expiredReward;
-
     }
 
     public heroReward(): CreateHeroParam[] {
+        let data = this.reward;
+        if (this.isExpired && this.expiredReward && this.expiredReward != '') {//过期奖励
+            data = this.expiredReward;
+        }
+
         let rewardArray = [];
-        let rewardData = this.reward.split('|').filter(obj => { return obj && obj != '' });
+        let rewardData = data.split('|').filter(obj => { return obj && obj != '' });
         for (let objStr of rewardData) {
             let reward = parseHeroStrWithType(objStr);
             rewardArray.push(reward);
@@ -36,8 +41,12 @@ export class ThirtyDaysPointItem {
     }
 
     public goodReward(): RewardInter[] {
+        let data = this.reward;
+        if (this.isExpired && this.expiredReward && this.expiredReward != '') {//过期奖励
+            data = this.expiredReward;
+        }
         let rewardArray = [];
-        let rewardData = this.reward.split('|').filter(obj => { return obj && obj != '' });
+        let rewardData = data.split('|').filter(obj => { return obj && obj != '' });
         for (let objStr of rewardData) {
             let reward = parseGoodStrWithType(objStr);
             rewardArray.push(reward);
@@ -62,7 +71,6 @@ export class ThirtyDaysItem {
     isComplete: boolean = false;          //是否完成任务
     isReceive: boolean = false;          //是否领取过奖励
 
-
     constructor(data: any, pageIndex: number) {
         this.pageIndex = pageIndex;
         this.cellIndex = data.cellIndex;
@@ -150,6 +158,42 @@ export class ThirtyDaysData extends ActivityBase {
         return true;
     }
 
+    //查询过期但未标记的点数奖励
+    public needMark(): Array<ThirtyDaysPointItem> {
+        let data = this.pointRewardList.sort((a, b) => { return a.cellIndex - b.cellIndex });
+        let point = this.totalPoint;
+        let expiredData = [];
+        for (let item of data) {
+            if (point < item.consumePoint) {
+                if (!item.isExpired)
+                    expiredData.push(item);
+            } else {
+                point -= item.consumePoint;
+            }
+        }
+        return expiredData
+    }
+
+    //查询过期的点数奖励
+    public expiredPointItem(): Array<ThirtyDaysPointItem> {
+        let data = this.pointRewardList.sort((a, b) => { return a.cellIndex - b.cellIndex });
+        let point = this.totalPoint;
+        let expiredData = [];
+        for (let item of data) {
+            if (point < item.consumePoint) {
+                expiredData.push(item);
+            } else {
+                point -= item.consumePoint;
+            }
+        }
+        return expiredData
+    }
+
+    //还未兑换的点数奖励
+    public notReceivedPointItem(): Array<ThirtyDaysPointItem> {
+        return this.pointRewardList.filter(obj => { return obj && !obj.isReceive })
+    }
+
     //点数兑换的奖励内容
     public findThirtyDaysPointItem(cellIndex: number): ThirtyDaysPointItem {
         let index = this.pointRewardList.findIndex(obj => { return obj && obj.cellIndex == cellIndex })
@@ -175,7 +219,8 @@ export class ThirtyDaysData extends ActivityBase {
             let index = data.findIndex(record => { return obj.cellIndex == record.cellIndex })
             if (index != -1) {
                 this.consumePoint += obj.consumePoint;
-                obj.isReceive = data[index].isReceive;
+                obj.isReceive = data[index].isReceive === true;
+                obj.isExpired = data[index].isExpired === true;
             }
         }
     }
@@ -186,9 +231,11 @@ export class ThirtyDaysData extends ActivityBase {
         for (let record of data) {
             let itemData = this.findThirtyDaysItem(record.pageIndex, record.cellIndex)
             if (itemData) {
-                this.totalPoint += itemData.point;
+                itemData.isReceive = record.isReceive === true;
-                itemData.isReceive = record.isReceive;
                 itemData.isComplete = record.totalCount >= itemData.taskParamArray[0];
+                if (itemData.isReceive) {
+                    this.totalPoint += itemData.point;
+                }
             }
         }
     }