任务：完成每日刷新

game-server/app/servers/connector/handler/entryHandler.ts

@@ -12,7 +12,7 @@ import { getAp } from '../../../services/actionPointService';
 import { ItemModel } from '../../../db/Item';
 import { chackFunOpenWhenLogin } from '../../../services/funcSwitchService';
 import { loginRefresh } from '../../../services/playerEventService';
-import { nowSeconds } from '../../../pubUtils/timeUtil';
+import { nowSeconds, getCurWeekTime } from '../../../pubUtils/timeUtil';
 import { rmRoleFromQueue, roleLeave, getRoleOnlineInfo, roleLogin } from '../../../services/redisService';
 import { UserGuildModel } from '../../../db/UserGuild';
 import { GuildModel } from '../../../db/Guild';
@@ -153,7 +153,7 @@ export class EntryHandler {
             }
         }
         // 任务
-        let { mainTask, dailyTask, achievement } = await getCurTask(role.roleId);
+        let { mainTask, dailyTask, achievement } = await getCurTask(role.roleId, session);
         role['mainTask'] = mainTask;
         role['dailyTask'] = dailyTask;
         role['achievement'] = achievement;

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

@@ -1,15 +1,14 @@
-import { Application, BackendSession } from "pinus";
+import { Application, BackendSession, pinus } from "pinus";
 import { resResult, parseGoodStr } from "../../../pubUtils/util";
 import { STATUS, TASK_FUN_TYPE } from "../../../consts";
 import { gameData } from "../../../pubUtils/data";
 import { UserTaskRecModel } from "../../../db/UserTaskRec";
 import { addItems } from "../../../services/rewardService";
 import { UserTaskModel } from "../../../db/UserTask";
-import { getCurWeekDate } from "../../../pubUtils/timeUtil";
+import { getCurWeekDate, nowSeconds } from "../../../pubUtils/timeUtil";
 import { DicDailyTask, DicAchievement } from "../../../pubUtils/dictionary/DicTask";
-import { getMainTask } from "../../../services/taskService";
+import { getMainTask, refDailyTaskBox, removeHistoryTask } from "../../../services/taskService";
 import { TASK } from "../../../pubUtils/dicParam";
-import { RewardInter } from "../../../pubUtils/interface";
 
 export default function(app: Application) {
     return new ShopHandler(app);
@@ -179,4 +178,21 @@ export class ShopHandler {
             goods
         });
     }
+
+    async debugDailyTaskRef(msg: { }, session: BackendSession) {
+        let roleId = session.get('roleId');
+        let sid = session.get('sid');
+        let uids = [{uid: roleId, sid}];
+
+        // 转移每日任务
+        await removeHistoryTask(roleId, new Date(nowSeconds() * 1000 + 86400000));
+        pinus.app.get('channelService').pushMessageByUids('onDailyTaskRefresh', resResult(STATUS.SUCCESS, { taskList: [] }), uids);
+    }
+
+    async debugTaskBoxRef(msg: { }, session: BackendSession) {
+        let roleId = session.get('roleId');
+        let sid = session.get('sid');
+
+        await refDailyTaskBox(roleId, sid);
+    }
 }

game-server/app/services/refreshService.ts

@@ -1,9 +1,12 @@
 import { FrontendOrBackendSession, pinus } from "pinus";
-import { refreshMails } from '../services/mailService';
+import { refreshMails } from './mailService';
 import { STATUS } from '../consts/statusCode';
-import { resResult } from '../pubUtils/util';
+import { resResult, shouldRefresh, shouldRefreshWeek } from '../pubUtils/util';
 import { nowSeconds } from "../pubUtils/timeUtil";
 import { RoleModel } from '../db/Role';
+import { refDailyTask, refDailyTaskBox } from './taskService'
+import { REFRESH_HOUR } from "../consts";
+
 /**
  * 刷新
  * @param session 
@@ -22,4 +25,27 @@ export async function refresh(session: FrontendOrBackendSession) {
         RoleModel.updatedRoleMailAt(roleId, nowTime);
         await refreshMails(roleId, sid, serverId, updatedMailAt); 
     }
+    await refreshDaily(session);
 }
+
+/**
+ * 每日刷新
+ * @param session 
+ */
+export async function refreshDaily(session: FrontendOrBackendSession) {
+    let refDaily: number = session.get('refDaily');   // 10位时间戳，每天每人更新一次
+    let refWeekly: number = session.get('refWeekly');   // 10位时间戳，每天每人更新一次
+    if(!refDaily || shouldRefresh(new Date(refDaily * 1000), new Date(), REFRESH_HOUR)) {
+        refDaily = nowSeconds();
+        session.set('refDaily', refDaily);
+        session.push('refDaily', () => {});
+        await refDailyTask(session.get('roleId'), session.get('sid'));
+    }
+
+    if(!refWeekly || shouldRefreshWeek(new Date(refWeekly * 1000), new Date(), 1, REFRESH_HOUR)) {
+        refWeekly = nowSeconds();
+        session.set('refWeekly', refWeekly);
+        session.push('refWeekly', () => {});
+        await refDailyTaskBox(session.get('roleId'), session.get('sid'));
+    }
+}

game-server/app/services/taskService.ts

@@ -1,7 +1,7 @@
 import * as taskUtil from '../pubUtils/taskUtil';
 import { RoleType } from '../db/Role';
-import { pinus } from 'pinus';
-import { resResult } from '../pubUtils/util';
+import { pinus, FrontendOrBackendSession } from 'pinus';
+import { resResult, shouldRefresh } from '../pubUtils/util';
 import { STATUS, TASK_TYPE, TASK_FUN_TYPE } from '../consts';
 import { TaskParam, TaskListReturn } from '../domain/roleField/task';
 import { HeroType } from '../db/Hero';
@@ -11,8 +11,9 @@ import { HeroScores } from '../db/PvpHistoryOpp';
 import { ItemInter } from '../pubUtils/interface';
 import { UserTaskModel, UserTaskType } from '../db/UserTask';
 import { UserTaskRecModel } from '../db/UserTaskRec';
+import { UserTaskHistoryModel } from '../db/UserTaskHistory';
 import { gameData } from '../pubUtils/data';
-import { getCurWeekDate } from '../pubUtils/timeUtil';
+import { getCurWeekDate, getSeconds } from '../pubUtils/timeUtil';
 
 export async function checkTaskWithRoles(roleId: string, sid: string, funcs: number[], taskType: number, roles: RoleType[]) {
     for(let role of roles) {
@@ -114,8 +115,25 @@ export async function checkTaskInPvpEnd(roleId: string, sid: string, funcs: numb
 
 
 // 获取task状态
-export async function getCurTask(roleId: string) {
+export async function getCurTask(roleId: string, session: FrontendOrBackendSession) {
     let userTask = await UserTaskModel.findByRole(roleId);
+
+    let { dailyTaskRefWeekly, dailyTaskRef } = userTask;
+    let curWeekStart = getCurWeekDate(1, 5);
+    if(dailyTaskRefWeekly < curWeekStart) { // 刷新周宝箱
+        dailyTaskRefWeekly = curWeekStart;
+    }
+    session.set('refWeekly', getSeconds(dailyTaskRefWeekly));
+    session.push('refWeekly', ()=> {});
+    
+    if(shouldRefresh(dailyTaskRef, new Date(), 5)) {
+        dailyTaskRef = new Date();
+        userTask = await UserTaskModel.setRefDaily(roleId);
+        await removeHistoryTask(roleId);
+    }
+    session.set('refDaily', getSeconds(dailyTaskRef));
+    session.push('refDaily', ()=> {});
+
     let mainTask = await getMainTask(roleId, userTask);
     let dailyTask = await getDailyTask(roleId, userTask);
     let achievement = await getAchievement(roleId, userTask);
@@ -146,6 +164,7 @@ export async function getDailyTask(roleId: string, userTask: UserTaskType) {
     let { dailyTaskPoint: point, dailyTaskRefWeekly, dailyTaskPointWeekly: weeklyPoint, dailyTaskBox: box } = userTask;
     let curWeekStart = getCurWeekDate(1, 5);
     if(dailyTaskRefWeekly < curWeekStart) { // 刷新
+        dailyTaskRefWeekly = curWeekStart;
         weeklyPoint = 0;
         box = [];
     }
@@ -178,4 +197,40 @@ export async function getAchievement(roleId: string, userTask: UserTaskType) {
         }
     }
     return { point, taskList, box }
+}
+
+// 刷新每日任务
+export async function refDailyTask(roleId: string, sid: string) {
+    let userTask = await UserTaskModel.findByRole(roleId);
+    let taskList = await getDailyTask(roleId, userTask);
+
+    // 转移每日任务
+    await removeHistoryTask(roleId);
+
+    let uids = [{uid: roleId, sid}];
+    pinus.app.get('channelService').pushMessageByUids('onDailyTaskRefresh', resResult(STATUS.SUCCESS, { taskList }), uids);
+
+}
+
+export async function removeHistoryTask(roleId: string, today?: Date) {
+
+    // 转移每日任务
+    let history = await UserTaskRecModel.getHistoryRec(roleId, today);
+    if(history.length > 0) {
+        await UserTaskHistoryModel.pushUserTask(roleId, history);
+        await UserTaskRecModel.deleteHistory(history);
+    } 
+}
+
+// 刷新每日宝箱数量
+export async function refDailyTaskBox(roleId: string, sid: string) {
+    let userTask = await UserTaskModel.refreshWeekly(roleId);
+    if(userTask) {
+        let { dailyTaskPoint: point, dailyTaskPointWeekly: weeklyPoint, dailyTaskBox: box } = userTask;
+        let uids = [{uid: roleId, sid}];
+        pinus.app.get('channelService').pushMessageByUids('onTaskBoxRefresh', resResult(STATUS.SUCCESS, { 
+            type: TASK_FUN_TYPE.DAILY,
+            point, weeklyPoint, box
+         }), uids);
+    }
 }

shared/db/UserTask.ts

@@ -16,6 +16,9 @@ export default class UserTask extends BaseModel {
     @prop({ required: true, default: 1  })
     mainTaskStage: number;			// 主线所处在的阶段
 
+    @prop({ required: true })
+    dailyTaskRef: Date;  		// 每日任务的每周刷新时间
+
     @prop({ required: true, default: 0 })
     dailyTaskPoint: number;  		// 每日任务的累计积分
 
@@ -75,10 +78,25 @@ export default class UserTask extends BaseModel {
       return rec;
     }
 
+    public static async refreshWeekly(roleId: string) {
+      let curWeek = getCurWeekDate(1, 5);
+      let rec: UserTaskType = await UserTaskModel.findOneAndUpdate({ roleId, dailyTaskRefWeekly: { $lt: curWeek } }, {
+        $set: { dailyTaskRefWeekly: curWeek, dailyTaskPointWeekly: 0, dailyTaskBox: [] }
+      }, { new: true }).lean();
+      return rec;
+    }
+
     public static async pushAchievementBox(roleId: string, id: number) {
       let rec = await UserTaskModel.findOneAndUpdate({ roleId }, { $push: { achievementBox: id } }, { new: true }).lean();
       return rec;
     }
+
+    public static async setRefDaily(roleId: string) {
+      let rec: UserTaskType = await UserTaskModel.findOneAndUpdate({ roleId }, {
+        $set: { dailyTaskRef: new Date() }
+      }, { new: true }).lean();
+      return rec;
+    }
 }
 
 export const UserTaskModel = getModelForClass(UserTask);

shared/db/UserTaskHistory.ts

@@ -0,0 +1,29 @@
+import BaseModel from './BaseModel';
+import { index, getModelForClass, prop, DocumentType, modelOptions } from '@typegoose/typegoose';
+import UserTaskRec, { UserTaskRecType } from './UserTaskRec';
+
+/**
+  * 玩家每日任务，每天刷掉的旧任务汇总
+**/
+@modelOptions({ schemaOptions: { id: false } })
+@index({ roleId: 1 })
+
+export default class UserTaskHistory extends BaseModel {
+
+    @prop({ required: true })
+    roleId: string;					// 玩家id
+
+    @prop({ required: true, type: UserTaskRec, default: [] })
+    list: UserTaskRec[];  	    	// 是否已领取
+
+    public static async pushUserTask(roleId: string, userTaskRec: UserTaskRecType[]) {
+        let rec: UserTaskHistoryType = await UserTaskHistoryModel.findOneAndUpdate({ roleId }, { $push: { list: { $each: userTaskRec } } }, { new: true, upsert: true }).lean();
+        return rec;
+    }
+
+}
+
+export const UserTaskHistoryModel = getModelForClass(UserTaskHistory);
+
+export interface UserTaskHistoryType extends Pick<DocumentType<UserTaskHistory>, keyof UserTaskHistory> { }
+export type UserTaskHistoryParam = Partial<UserTaskHistoryType>;

shared/db/UserTaskRec.ts

@@ -5,10 +5,11 @@ import { genCode } from '../pubUtils/util';
 import { getTodayZeroDate } from '../pubUtils/timeUtil';
 
 /**
-  * 玩家购买商店记录表，每个商品一条，每次刷新新建一条
+  * 玩家任务记录表
 **/
 @modelOptions({ schemaOptions: { id: false } })
-@index({ roleId: 1, itemId: 1 })
+@index({ code: 1 })
+@index({ roleId: 1, type: 1, taskType: 1, group: 1 })
 
 export default class UserTaskRec extends BaseModel {
     @prop({ required: true })
@@ -20,9 +21,6 @@ export default class UserTaskRec extends BaseModel {
     @prop({ required: true, enum: TASK_FUN_TYPE })
     type: number;					// 任务类型
 
-    @prop({ required: true })
-    id: number;  					// 任务id，任务表内id
-
     @prop({ required: true })
     taskType: number;  				// 行为类型
 
@@ -98,9 +96,20 @@ export default class UserTaskRec extends BaseModel {
     public static async getReceiveRec(roleId: string, type: number) {
         let condition = this.getRefreshCondition(type);
         let rec = await UserTaskRecModel.find({ roleId, ...condition }).lean();
-        console.log(JSON.stringify(rec))
         return rec
     }
+
+    public static async getHistoryRec(roleId: string, today?: Date) {
+        if(!today) today = getTodayZeroDate(5);
+        let rec: UserTaskRecType[] = await UserTaskRecModel.find({ roleId, type: TASK_FUN_TYPE.DAILY, createdAt: { $lt: today } }).lean();
+        return rec
+    }
+
+    public static async deleteHistory(history: UserTaskRecType[]) {
+        let codes = history.map(cur => cur.code);
+        let result = await UserTaskRecModel.deleteMany({ code: { $in: codes } });
+        return result;
+    }
 }
 
 export const UserTaskRecModel = getModelForClass(UserTaskRec);