将两种任务初步合起来

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

@@ -1,7 +1,7 @@
 import { Application, BackendSession, HandlerService, pinus, } from 'pinus';
 import { aesEncrypt, aesEncryptcfb, resResult } from '../../../pubUtils/util';
 import { ENCRYPT_IV, ENCRYPT_KEY, STATUS, TASK_TYPE } from '../../../consts';
-import { checkActivityTask } from '../../../services/taskService';
+import { checkActivityTask } from '../../../services/task/taskService';
 import { ActivityGroupModel } from '../../../db/ActivityGroup';
 import { ServerlistModel } from '../../../db/Serverlist';
 import { getActivity, getActivityById } from '../../../services/activity/activityService';

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

@@ -11,7 +11,7 @@ import { handleCost, createHeroes, addItems } from "../../../services/role/rewar
 import { getZeroPointD, getTimeFun } from "../../../pubUtils/timeUtil";
 import { UserGachaRecModel } from "../../../db/UserGachaRec";
 import { ActivityModel } from "../../../db/Activity";
-import { checkActivityTask, checkTask } from "../../../services/taskService";
+import { checkActivityTask, checkTask } from "../../../services/task/taskService";
 import { RECRUIT } from "../../../pubUtils/dicParam";
 import { getActivityById } from "../../../services/activity/activityService";
 

game-server/app/servers/activity/remote/activityRemote.ts

@@ -2,7 +2,7 @@ import { Application, ChannelService, HandlerService, } from 'pinus';
 import { ActivityModel, ActivityModelType } from '../../../db/Activity';
 import { ServerlistModel } from '../../../db/Serverlist';
 import { reloadResources } from '../../../pubUtils/data';
-import { _getActivitiesByType, _getActivityById, _getActivities } from '../../../services/activity/activityService';
+import { _getActivitiesByType, _getActivityById, _getActivities, _getActivitiesByServerId } from '../../../services/activity/activityService';
 import { getServerMainten, setServerMainten, stopServerMainten } from '../../../services/gmService';
 import { taflush } from '../../../services/sdkService';
 import { ActivityInRemote } from '../../../domain/activityField/activityField';
@@ -173,6 +173,14 @@ export class ActivityRemote {
         }
     }
 
+    public getActivitiesByServerId(serverId: number) {
+        try {
+            return _getActivitiesByServerId(serverId);
+        } catch(e) {
+            errlogger.error(`remote ${__filename} \n ${e.stack}`);
+        }
+    }
+
     public getActivities() {
         try {
             return _getActivities();

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

@@ -24,7 +24,7 @@ import { pushComBtlTeamMsg, pushFriendTeamInviteMsg, pushNormalItemMsg, pushTeam
 import { EXTERIOR } from '../../../pubUtils/dicParam';
 import { getZeroPointD, getTimeFunD, getSeconds, nowSeconds } from '../../../pubUtils/timeUtil';
 import { FriendParams } from '../../../domain/roleField/friend';
-import { checkActivityTask, checkTask, checkTaskInComBattleStart, checkTaskWithArgs, checkTaskWithGoods } from '../../../services/taskService';
+import { checkActivityTask, checkTask, checkTaskInComBattleStart, checkTaskWithArgs, checkTaskWithGoods } from '../../../services/task/taskService';
 import { gameData, getWarByBlueprtId } from '../../../pubUtils/data';
 import { HeroModel } from '../../../db/Hero';
 

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

@@ -6,7 +6,7 @@ import { checkEventStatus, getEventSuccessStatus, getEvent, checkQuiz, startEven
 import { addItems } from '../../../services/role/rewardService';
 import { STATUS } from '../../../consts/statusCode';
 import { resResult } from '../../../pubUtils/util';
-import { checkActivityTask, checkTask } from '../../../services/taskService';
+import { checkActivityTask, checkTask } from '../../../services/task/taskService';
 import { gameData } from '../../../pubUtils/data';
 
 export default function (app: Application) {

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

@@ -13,7 +13,7 @@ import { getAp, setAp } from '../../../services/actionPointService';
 import { STATUS } from '../../../consts/statusCode';
 import { resResult } from '../../../pubUtils/util';
 import { calculateWarStar, checkBattleHeroes, roleLevelup } from '../../../services/normalBattleService';
-import { checkActivityTask, checkTask, checkTaskInBattleEnd } from '../../../services/taskService';
+import { checkActivityTask, checkTask, checkTaskInBattleEnd } from '../../../services/task/taskService';
 import { gameData } from '../../../pubUtils/data';
 import * as dicParam from '../../../pubUtils/dicParam';
 import { getSeconds, nowSeconds } from '../../../pubUtils/timeUtil';

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

@@ -19,7 +19,7 @@ import { gameData } from '../../../pubUtils/data';
 import { pushMysteryFirstMsg, pushTowerMsg, pushVestigeFirstMsg } from '../../../services/chatService';
 import { getSeconds, nowSeconds } from '../../../pubUtils/timeUtil';
 import { Rank } from '../../../services/rankService';
-import { checkTaskWithWar, checkTaskInBattleEnd, checkActivityTask, checkTaskInBattleSweep } from '../../../services/taskService';
+import { checkTaskWithWar, checkTaskInBattleEnd, checkActivityTask, checkTaskInBattleSweep } from '../../../services/task/taskService';
 import { ActivitySelfServiceModel } from '../../../db/ActivitySelfService';
 import { getSelfServiceShopActivityData } from '../../../services/activity/selfServiceShopActivityService';
 import { challengeDailyGK } from '../../../services/activity/dailyGKService';

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

@@ -10,7 +10,7 @@ import { PvpDefenseModel, pvpUpdateInter } from '../../../db/PvpDefense';
 import { PvpSeasonResultModel } from '../../../db/PvpSeasonResult';
 import { PVPConfigModel } from '../../../db/SystemConfig';
 import { Rank } from '../../../services/rankService';
-import { checkActivityTask, checkTask, checkTaskInPvpEnd } from '../../../services/taskService';
+import { checkActivityTask, checkTask, checkTaskInPvpEnd } from '../../../services/task/taskService';
 import { Attack, AttackHero, Defense, DefenseHero, PvpDataReturn } from '../../../domain/battleField/pvp';
 import { DEBUG_MAGIC_WORD, FIGURE_UNLOCK_CONDITION, ITEM_CHANGE_REASON, LINEUP_NUM, REDIS_KEY, TASK_TYPE } from '../../../consts';
 import { PVP } from '../../../pubUtils/dicParam';

game-server/app/servers/chat/handler/chatHandler.ts

@@ -4,7 +4,7 @@ import { resResult } from '../../../pubUtils/util';
 import { DEFAULT_MSG_PER_PAGE, STATUS, TASK_TYPE } from '../../../consts';
 import { createAccuseData, createGroupMsg, createPrivateMsg, getPrivateMessages, pushGroupMsgToRoom, pushMsgToRole, updatePrivateMsgReadInfo, recentPrivateChatInfos, recentWorldMsgs, recentSysMsgs, recentGuildMsgs, updatePrivateMsgIsTop, delPrivateMsg } from '../../../services/chatService';
 import { getSimpleRoleInfo } from '../../../services/roleService';
-import { checkActivityTask, checkTaskWithArgs } from '../../../services/taskService';
+import { checkActivityTask, checkTaskWithArgs } from '../../../services/task/taskService';
 import { RoleModel } from '../../../db/Role';
 
 

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

@@ -16,7 +16,7 @@ import { rmRoleFromQueue, roleLeave, getRoleOnlineInfo, roleLogin } from '../../
 
 import { addRoleToGuildChannel, addRoleToSysChannel, addRoleToWorldChannel, leaveGuildAuctionChannel, leaveGuildChannel, leaveSysChannel, leaveWorldAuctionChannel, leaveWorldChannel, recentGuildMsgs, recentPrivateChatInfos, recentSysMsgs, recentWorldMsgs } from '../../../services/chatService';
 import { reportOneOnline, savePlayTime } from '../../../services/authenticateService';
-import { checkTaskWithRole, } from '../../../services/taskService';
+import { checkTaskWithRole, } from '../../../services/task/taskService';
 import { pushData, everydayRefresh, kickUser } from '../../../services/connectorService';
 // import { setComBtlOnUserLeave } from '../../../services/comBattleService';
 import Counter from '../../../db/Counter';

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

@@ -14,7 +14,7 @@ import { GUILDACTIVITY, SERVER_DEBUG_MODE } from "../../../pubUtils/dicParam";
 import { handleCost } from "../../../services/role/rewardService";
 import { addActive } from "../../../services/guildService";
 import { Rank } from "../../../services/rankService";
-import { checkActivityTask, checkTask } from "../../../services/taskService";
+import { checkActivityTask, checkTask } from "../../../services/task/taskService";
 import { guildInter } from "../../../pubUtils/interface";
 import { dispatch } from "../../../pubUtils/dispatcher";
 import { ServerRecordModel } from "../../../db/ServerRecords";

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

@@ -12,7 +12,7 @@ import { addFund, getDonation } from '../../../services/donateService';
 import { getUserGuildWithRefActive, refreshUserGuild } from '../../../services/guildService';
 import { ARMY } from '../../../pubUtils/dicParam';
 import { addActive } from '../../../services/guildService'
-import { checkActivityTask, checkTask } from '../../../services/taskService';
+import { checkActivityTask, checkTask } from '../../../services/task/taskService';
 import { guildInter } from '../../../pubUtils/interface';
 import { lockData } from '../../../services/redLockService';
 import { getVipDonateConsume } from '../../../services/activity/monthlyTicketService';

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

@@ -14,7 +14,7 @@ import { UserGuildModel } from "../../../db/UserGuild";
 import { GuildActivityCityModel } from "../../../db/GuildActivityCity";
 import { Rank } from "../../../services/rankService";
 import { getTimeFun, getZeroPointD } from "../../../pubUtils/timeUtil";
-import { checkActivityTask, checkTask } from "../../../services/taskService";
+import { checkActivityTask, checkTask } from "../../../services/task/taskService";
 import { guildInter } from "../../../pubUtils/interface";
 import { ServerRecordModel } from "../../../db/ServerRecords";
 

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

@@ -14,7 +14,7 @@ import { GuildModel } from '../../../db/Guild';
 import { gameData, getAuctionRewardByPoolId, getBossByLv } from '../../../pubUtils/data';
 import { lockData } from '../../../services/redLockService';
 import { pushGuildBossSucMsg, getGuildChannelSid } from '../../../services/chatService';
-import { checkTask } from '../../../services/taskService';
+import { checkTask } from '../../../services/task/taskService';
 import { guildInter } from '../../../pubUtils/interface';
 import { addItems, handleCost } from '../../../services/role/rewardService';
 import * as dicParam from '../../../pubUtils/dicParam';

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

@@ -23,7 +23,7 @@ import { removeBossRank } from '../../../services/guildBossService';
 import { removeTrainRank } from '../../../services/guildTrainService';
 import { pushGuildNoticeUpdateMsg, pushGuildUpStructureMsg, addRoleToGuildChannel, getGuildChannelSid, createGroupMsg, pushGroupMsgToRoom } from '../../../services/chatService';
 import { Rank } from '../../../services/rankService';
-import { checkActivityTask, checkTask } from '../../../services/taskService';
+import { checkActivityTask, checkTask } from '../../../services/task/taskService';
 import { guildInter } from '../../../pubUtils/interface';
 import * as dicParam from '../../../pubUtils/dicParam';
 import { reportTAEvent } from '../../../services/sdkService';

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

@@ -13,7 +13,7 @@ import { ARMY } from '../../../pubUtils/dicParam';
 import { CURRENCY_BY_TYPE, CURRENCY_TYPE } from '../../../consts/constModules/itemConst';
 import { checkEquipProduceStructureLv, openGuildRefine, refreshRefinCnt } from '../../../services/guildRefineService';
 import { DATA_NAME } from '../../../consts/dataName';
-import { checkTask } from '../../../services/taskService';
+import { checkTask } from '../../../services/task/taskService';
 import { guildInter } from '../../../pubUtils/interface';
 import { DicArmyDevelopConsume } from '../../../pubUtils/dictionary/DicArmyDevelopConsume';
 

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

@@ -18,7 +18,7 @@ import { addActive } from '../../../services/guildService';
 import { GuildTrainReportModel } from '../../../db/GuildTrainReport';
 import { DATA_NAME } from '../../../consts/dataName';
 import { pushGuildTrainSucMsg } from '../../../services/chatService';
-import { checkActivityTask, checkTask } from '../../../services/taskService';
+import { checkActivityTask, checkTask } from '../../../services/task/taskService';
 import { sendPopUpActivityData } from '../../../services/guildActivity/guildActivityService';
 import { guildInter, RewardInter } from '../../../pubUtils/interface';
 import { getGuildTrainGkInfo } from '../../../pubUtils/data';

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

@@ -7,7 +7,7 @@ import { GuildActivityRecordModel } from "../../../db/GuildActivityRec";
 import { UserGuildActivityRecModel } from "../../../db/UserGuildActivityRec";
 import { addActive } from "../../../services/guildService";
 import { Rank } from "../../../services/rankService";
-import { checkActivityTask, checkTask } from "../../../services/taskService";
+import { checkActivityTask, checkTask } from "../../../services/task/taskService";
 import { guildInter } from "../../../pubUtils/interface";
 import { getGuildChannelSid } from "../../../services/chatService";
 import { ServerRecordModel } from "../../../db/ServerRecords";

game-server/app/servers/order/handler/orderHandler.ts

@@ -10,7 +10,7 @@ import { applyOrder37 } from '../../../services/pay/37Pay';
 import { settleOrder, settleOrderAli, settleOrderWx } from '../../../services/orderService';
 import { addRechargeMoney } from '../../../services/activity/rechargeMoneyService';
 import { addVipRechargeMoney } from '../../../services/activity/vipRechargeMoneyService';
-import { checkActivityTask } from '../../../services/taskService';
+import { checkActivityTask } from '../../../services/task/taskService';
 import { getActivityById } from '../../../services/activity/activityService';
 import { reportTAEvent } from '../../../services/sdkService';
 

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

@@ -21,7 +21,7 @@ import { FRIEND } from "../../../pubUtils/dicParam";
 import { PlayerDetail, PlayerDetailHero } from "../../../domain/battleField/guild";
 import { createPrivateMsg, pushMsgToRole, pushPresent } from "../../../services/chatService";
 import { Rank } from "../../../services/rankService";
-import { checkTaskWithRoles, checkTask, checkActivityTask } from "../../../services/taskService";
+import { checkTaskWithRoles, checkTask, checkActivityTask } from "../../../services/task/taskService";
 import { ComBattleTeamModel } from "../../../db/ComBattleTeam";
 import { JewelModel } from "../../../db/Jewel";
 

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

@@ -13,7 +13,7 @@ import { getDropItems, FIGURE_UNLOCK_CONDITION } from '../../../consts/constModu
 import { pushComposeOrangeHero, pushHeroQualityUpMsg, pushHeroStarMax, pushHeroWakeUp } from '../../../services/chatService';
 import { calculatetopLineup } from '../../../pubUtils/playerCe';
 import { PvpDefenseModel } from '../../../db/PvpDefense';
-import { checkTaskWithHero, checkTask, checkActivityTask } from '../../../services/taskService';
+import { checkTaskWithHero, checkTask, checkActivityTask } from '../../../services/task/taskService';
 import { isNumber, pick } from 'underscore';
 import { updateEplaces } from '../../../services/equipService';
 import { addConsumeToHero } from '../../../services/roleService';

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

@@ -16,7 +16,7 @@ import { HERO_SYSTEM_TYPE, LINEUP_NUM, ROLE_SELECT, REDIS_KEY, TASK_TYPE, DEFAUL
 import { checkBattleHeroesByHid, roleLevelup } from '../../../services/normalBattleService';
 import { Rank } from '../../../services/rankService';
 import { updateUserInfo } from '../../../services/redisService';
-import { checkTaskWithHero, checkTask, checkTaskWithArgs, checkActivityTask } from '../../../services/taskService';
+import { checkTaskWithHero, checkTask, checkTaskWithArgs, checkActivityTask } from '../../../services/task/taskService';
 import { getGoldObject, getCoinObject } from '../../../pubUtils/itemUtils';
 import { RScriptRecordModel } from '../../../db/RScriptRecord';
 import { SkinModel, SkinUpdate } from '../../../db/Skin';

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

@@ -1,13 +1,13 @@
 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, ITEM_CHANGE_REASON, ACTIVITY_TYPE } from "../../../consts";
+import { STATUS, TASK_FUN_TYPE, SHOP_REFRESH_TYPE, KING_EXP_RATIO_TYPE, DEBUG_MAGIC_WORD, ITEM_CHANGE_REASON, ACTIVITY_TYPE, TASK_TYPE } from "../../../consts";
 import { gameData } from "../../../pubUtils/data";
 import { UserTaskRecModel } from "../../../db/UserTaskRec";
 import { addItems } from "../../../services/role/rewardService";
 import { UserTaskModel } from "../../../db/UserTask";
 import { nowSeconds, getZeroPointD } from "../../../pubUtils/timeUtil";
 import { DicDailyTask, DicAchievement, DicMainTask } from "../../../pubUtils/dictionary/DicTask";
-import { getMainTask, refDailyTaskBox, removeHistoryTask, getCurTask, checkTask, getPvpTask } from "../../../services/taskService";
+import { getMainTask, refDailyTaskBox, removeHistoryTask, getCurTask, checkTask, getPvpTask } from "../../../services/task/taskService";
 import { TASK } from "../../../pubUtils/dicParam";
 import { ActivityTaskPointModel, ActivityTaskPointModelType } from "../../../db/ActivityTaskPoint";
 import { ItemInter, RewardInter } from "../../../pubUtils/interface";
@@ -15,6 +15,8 @@ import { RoleModel } from "../../../db/Role";
 import { roleLevelup } from "../../../services/normalBattleService";
 import _ = require("underscore");
 import { addActvityTaskPoint } from "../../../services/activity/activityService";
+import { CheckTask } from "../../../services/task/taskObj";
+import { ServerlistModel } from "../../../db/Serverlist";
 
 export default function (app: Application) {
     new HandlerService(app, {});
@@ -323,4 +325,16 @@ export class ShopHandler {
         console.log('******', _.isEqual([1,2], [1,2,2]))
         return resResult(STATUS.SUCCESS, { tasks: [...gameData.taskType]});
     }
+
+    async test(msg: { magicWord: string }, session: BackendSession) {
+        let roleId = session.get('roleId');
+        let serverId = session.get('serverId');
+        let sid = session.get('sid');
+        let role = await RoleModel.findByRoleId(roleId);
+        let server = await ServerlistModel.findByServerId(serverId);
+        let task = new CheckTask(serverId, roleId, TASK_TYPE.LOGIN_SUM, role.createTime, server.openTime);
+        task.param.setRole(role);
+        task.check(1, sid);
+        return resResult(STATUS.SUCCESS)
+    }
 }

game-server/app/services/actionPointService.ts

@@ -4,7 +4,7 @@
 
 import { ActionPointModel, ActionPointType } from '../db/ActionPoint';
 import { TASK_TYPE, STATUS, TA_EVENT, ITEM_CHANGE_REASON } from '../consts';
-import { checkActivityTask, checkTask } from './taskService';
+import { checkActivityTask, checkTask } from './task/taskService';
 import { getDicApByLv } from '../pubUtils/data';
 import { pinus } from 'pinus';
 import { resResult, shouldRefresh } from '../pubUtils/util';

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

@@ -235,13 +235,15 @@ export async function getActivityById(activityId: number) {
 
 export async function getActivitiesByType(serverId: number, type: number) {
     let serverType = pinus.app.getServerType();
+    let activities: ActivityInRemote[] = [];
     if(serverType == 'activity') {
-        return _getActivitiesByType(serverId, type);
+        activities = _getActivitiesByType(serverId, type);
     } else {
         let servers = pinus.app.getServersByType('activity');
         let server = getRandSingleEelm(servers);
-        return <ActivityModelType[]>await pinus.app.rpc.activity.activityRemote.getActivitiesByType.toServer(server.id, serverId, type);
+        activities = await pinus.app.rpc.activity.activityRemote.getActivitiesByType.toServer(server.id, serverId, type);
     }
+    return activities.map(transActivityInRemoteToModelType);
 }
 
 export async function getActivities() {
@@ -255,6 +257,19 @@ export async function getActivities() {
     }
 }
 
+export async function getActivityByServerId(serverId: number) {
+    let activities: ActivityInRemote[] = [];
+    let serverType = pinus.app.getServerType();
+    if(serverType == 'activity') {
+        activities = _getActivitiesByServerId(serverId);
+    } else {
+        let servers = pinus.app.getServersByType('activity');
+        let server = getRandSingleEelm(servers);
+        activities = await pinus.app.rpc.activity.activityRemote.getActivitiesByServerId.toServer(server.id, serverId);
+    }
+    return activities.map(transActivityInRemoteToModelType);
+}
+
 export function _getActivityById(activityId: number) {
     return <ActivityInRemote>pinus.app.get('activities')?.get(activityId);
 }
@@ -262,11 +277,24 @@ export function _getActivityById(activityId: number) {
 export function _getActivitiesByType(serverId: number, type: number) {
     let activityByType = pinus.app.get('activityByType')?.get(serverId)?.get(type)||[];
     let activities: Map<number, ActivityInRemote> = pinus.app.get('activities');
-    let result: ActivityModelType[] = [];
+    let result: ActivityInRemote[] = [];
     for(let activityId of activityByType) {
         let activity = activities.get(activityId);
         if(activity && activity.beginTime <= Date.now()) {
-            result.push(transActivityInRemoteToModelType(activity));
+            result.push(activity);
+        }
+    }
+    return result;
+}
+
+export function _getActivitiesByServerId(serverId: number) {
+    let activityByServerId = pinus.app.get('activityByServer')?.get(serverId)||[]
+    let activities: Map<number, ActivityInRemote> = pinus.app.get('activities');
+    let result: ActivityInRemote[] = [];
+    for(let activityId of activityByServerId) {
+        let activity = activities.get(activityId);
+        if(activity && activity.beginTime <= Date.now()) {
+            result.push(activity);
         }
     }
     return result;

game-server/app/services/battleService.ts

@@ -9,7 +9,7 @@ import { STATUS } from '../consts/statusCode';
 import { HangUpSpdUpRecModel } from '../db/HangUpSpdUpRec';
 import { TaskHero, TowerTaskRecModel, TowerTaskRecType } from '../db/TowerTaskRec';
 import { Rank } from './rankService';
-import { checkActivityTask, checkTask } from './taskService';
+import { checkActivityTask, checkTask } from './task/taskService';
 import { getRandExpedition, gameData } from '../pubUtils/data';
 import { ItemInter, RewardInter } from '../pubUtils/interface';
 import { getTimeFunM } from '../pubUtils/timeUtil';

game-server/app/services/connectorService.ts

@@ -3,7 +3,7 @@
  */
 import { getMails } from './mailService';
 import { recentGuildMsgs, recentPrivateChatInfos, recentSysMsgs, recentWorldMsgs } from './chatService';
-import { getCurTask, getPvpTask } from './taskService';
+import { getCurTask, getPvpTask } from './task/taskService';
 
 import { RoleType } from '../db/Role';
 import { Application, FrontendOrBackendSession, pinus, RpcClient } from 'pinus';

game-server/app/services/equipService.ts

@@ -3,7 +3,7 @@ import { EPlace, Stone } from "../db/Hero";
 import { gameData, getRandEffectByGroupAndLevel } from "../pubUtils/data";
 import { JewelType, RandSe } from '../db/Jewel';
 import { getJewelRandSe } from '../pubUtils/itemUtils';
-import { checkActivityTask, checkTask, checkTaskWithEplaces, checkTaskWithEplace } from './taskService';
+import { checkActivityTask, checkTask, checkTaskWithEplaces, checkTaskWithEplace } from './task/taskService';
 import { TASK_TYPE } from '../consts';
 import { DicRandomEffectPool } from '../pubUtils/dictionary/DicRandomEffectPool';
 

game-server/app/services/guildActivity/guildActivityService.ts

@@ -26,7 +26,7 @@ import { BossInstanceModel } from "../../db/BossInstance";
 import { UserGuildModel } from "../../db/UserGuild";
 import { raceActivityEnd } from "../timeTaskService";
 import { addActive } from "../guildService";
-import { checkTask, checkActivityTask } from "../taskService";
+import { checkTask, checkActivityTask } from "../task/taskService";
 import { ActivePlayer, GuildRecord, ServerRecordModel } from "../../db/ServerRecords";
 import { Attack } from "../../domain/battleField/pvp";
 

game-server/app/services/guildService.ts

@@ -16,7 +16,7 @@ import { ErrLogModel } from '../db/ErrLog';
 import { DATA_NAME } from '../consts/dataName';
 import { addRoleToGuildChannel } from "./chatService";
 import { Rank } from "./rankService";
-import { checkActivityTask, checkTask } from "./taskService";
+import { checkActivityTask, checkTask } from "./task/taskService";
 import { CounterModel } from "../db/Counter";
 import { getAuction } from "./auctionService";
 import { changeGuildActivity } from "./activity/guildPayService";

game-server/app/services/normalBattleService.ts

@@ -8,7 +8,7 @@ import { FUNC_OPT_TYPE, TASK_TYPE, WAR_TYPE, STATUS, KING_EXP_RATIO_TYPE, ITEM_C
 import { BackendSession, pinus } from 'pinus';
 import { REDIS_KEY } from '../consts';
 import { Rank } from './rankService';
-import { checkActivityTask, checkTask } from './taskService';
+import { checkActivityTask, checkTask } from './task/taskService';
 import { accomplishTask } from '../pubUtils/taskUtil';
 import { RScriptRecordModel } from '../db/RScriptRecord';
 import { setAp } from './actionPointService';

game-server/app/services/orderService.ts

@@ -22,7 +22,7 @@ import { resResult } from '../pubUtils/util';
 import { checkOrderWX } from './pay/weixinPay';
 import { addRechargeMoney } from './activity/rechargeMoneyService';
 import { addVipRechargeMoney } from './activity/vipRechargeMoneyService';
-import { checkActivityTask } from './taskService';
+import { checkActivityTask } from './task/taskService';
 import { checkOrderALI } from './pay/aliPay';
 import { getRoleOnlineInfo } from './redisService';
 import { PayCallback37Data } from '../domain/sdk';

game-server/app/services/pvpService.ts

@@ -22,7 +22,7 @@ import { Rank } from './rankService';
 import { CounterModel } from '../db/Counter';
 import { DicRankRewads } from '../pubUtils/dictionary/DicPvpRankReward';
 import { PvpSeasonResultModel, PvpSeasonResultType } from '../db/PvpSeasonResult';
-import { checkTask } from '../services/taskService';
+import { checkTask } from './task/taskService';
 import { sendMailByContent } from './mailService';
 import { RoleRankInfo } from '../domain/rank';
 import { reportTAEvent } from './sdkService';

game-server/app/services/refreshService.ts

@@ -3,7 +3,7 @@ import { STATUS } from '../consts/statusCode';
 import { resResult, shouldRefresh, shouldRefreshWeek } from '../pubUtils/util';
 import { nowSeconds } from "../pubUtils/timeUtil";
 // import { RoleModel } from '../db/Role';
-import { refDailyTask, refDailyTaskBox } from './taskService'
+import { refDailyTask, refDailyTaskBox } from './task/taskService'
 // import { EVENT_STATUS, FUNCS_ID } from "../consts";
 // import { startEvent } from "./eventSercive";
 import * as dicParam from '../pubUtils/dicParam';

game-server/app/services/role/rewardService.ts

@@ -13,7 +13,7 @@ import { uniq } from 'underscore';
 import { EPlace, HeroModel, HeroType, HeroUpdate } from '../../db/Hero';
 import { Figure } from '../../domain/dbGeneral';
 import { Rank } from '../rankService';
-import { pushTaskUpdate } from '../taskService';
+import { pushTaskUpdate } from '../task/taskService';
 import { CreateHeroParam, HeroShowParam } from '../../domain/roleField/hero';
 import { HeroSkin } from '../../db/Hero';
 import { errlogger } from '../../util/logger';

game-server/app/services/task/taskObj.ts

@@ -0,0 +1,270 @@
+import { pinus } from "pinus";
+import { ACTIVITY_TYPE, STATUS, TASK_SUM_TYPE, TASK_TYPE } from "../../consts";
+import { ActivityBuyRecordsModel } from "../../db/ActivityBuyRecords";
+import { ActivityDailyChallengesModel } from "../../db/ActivityDailyChallenges";
+import { ActivityGrowthModel } from "../../db/ActivityGrowth";
+import { ActivityGrowthFundModel } from "../../db/ActivityGrowthFund";
+import { ActivityRefreshTaskModel } from "../../db/ActivityRefreshTask";
+import { ActivityThirtyDaysModel } from "../../db/ActivityThirtyDays";
+import { ActivityTreasureHuntTaskModel } from "../../db/ActivityTreasureHuntTask";
+import { RoleType } from "../../db/Role";
+import { ServerTempModel, ServerTempModelType } from "../../db/ServerTemp";
+import { UserTaskRecModel } from "../../db/UserTaskRec";
+import { GrowthFundData } from "../../domain/activityField/growthFundField";
+import { RefreshTaskData } from "../../domain/activityField/refreshTaskField";
+import { SevenDaysData } from "../../domain/activityField/sevenDaysField";
+import { ThirtyDaysData } from "../../domain/activityField/thirtyDaysField";
+import { TreasureHuntData } from "../../domain/activityField/treasureHuntField";
+import { TaskListReturn, UpdateTaskParam } from "../../domain/roleField/task";
+import { gameData } from "../../pubUtils/data";
+import { getZeroPoint } from "../../pubUtils/timeUtil";
+import { resResult } from "../../pubUtils/util";
+import { getActivities, getActivitiesByType, getActivityByServerId } from "../activity/activityService";
+import { getRoleOnlineInfo } from "../redisService";
+
+/**
+ * @class CheckTask
+ * @classdesc 检查某个玩家任务的达成情况
+ */
+export class CheckTask {
+    serverId: number;       // 区id
+    roleId: string;         // 玩家id
+    taskType: TASK_TYPE;    // 任务type
+    roleCreateTime: number; // 玩家的创建时间
+    serverCreateTime: number; // 服务器的创建时间
+
+    param: TaskParam;           // 检查任务时传入的参数
+
+    treasureHuntTemp: ServerTempModelType;
+
+    constructor(serverId: number, roleId: string, taskType: TASK_TYPE, roleCreateTime: number, serverCreateTime: number) {
+        this.serverId = serverId;
+        this.roleId = roleId;
+        this.taskType = taskType;
+        this.roleCreateTime = roleCreateTime;
+        this.serverCreateTime = serverCreateTime;
+        this.param = new TaskParam();
+    }
+
+    /**
+     * @description 检查任务的主程序
+     */
+    public async check(count: number, sid: string) {
+        let { taskType, roleId, serverId, roleCreateTime, serverCreateTime } = this;
+        let dicTaskTypeDesc = gameData.taskDescByType.get(taskType);
+        let taskPushMessages: TaskListReturn[] = [];
+        let activityTaskPushMessages = [];
+        
+        // 检查一般任务
+        let dicTasks = gameData.taskType.get(taskType);
+        for (let dicTask of dicTasks) {
+    
+            let taskUpdateParam = this.checkIsMatch(dicTask.taskParam, count);
+            if (taskUpdateParam) {
+                let rec = await UserTaskRecModel.checkAndUpdateTask(roleId, dicTask.type, taskType, dicTask.group, taskUpdateParam);
+                if (!rec) continue;
+                if (rec.received && rec.received.includes(dicTask.id)) continue; // 已领取，不再推送
+                let received = rec.received || [];
+                taskPushMessages.push({ type: dicTask.type, id: dicTask.id, count: rec.count, received: received.includes(dicTask.id) });
+
+            }
+        }
+
+        // 检查活动任务
+        let activities = await getActivityByServerId(serverId);
+        for(let activity of activities) {
+            let { activityId, type: activityType } = activity;
+            switch(activityType) {
+                case ACTIVITY_TYPE.SEVEN_DAY:
+                case ACTIVITY_TYPE.FOURTEEN_DAY://十四天乐活动 28
+                case ACTIVITY_TYPE.COMMON_SEVEN_DAY://通用七天乐活动 29
+                    {
+                        //成长活动统计
+                        let playerData = new SevenDaysData(activity, roleCreateTime, serverCreateTime);
+                        let growthTaskArray = playerData.growth.findTaskByType(taskType); // 所有任务
+                        for (let task of growthTaskArray) {
+                            let taskUpdateParam = this.checkIsMatch(task.taskParamArray, count);
+                            if(taskUpdateParam) {
+                                let rec = await ActivityGrowthModel.checkAndUpdateTask(serverId, activityId, roleId, task.dayIndex, task.cellIndex, taskUpdateParam);
+                                if(!rec) continue;
+                                activityTaskPushMessages.push({...task, totalCount: rec.totalCount, receiveRewardCount: rec.receiveRewardCount||0, activityId, activityType: "growth" });
+                            }
+                        }
+                        //今日挑战统计
+                        let dailyChallengeTaskArray = playerData.dailyChallenge.findTaskByType(taskType);
+                        for (let task of dailyChallengeTaskArray) {
+                            if(dicTaskTypeDesc.sumType == TASK_SUM_TYPE.DO && task.dayIndex != playerData.today()) {
+                                continue;
+                            }
+                            let taskUpdateParam = this.checkIsMatch(task.taskParamArray, count);
+                            if(taskUpdateParam) {
+                                let rec = await ActivityDailyChallengesModel.checkAndUpdateTask(serverId, activityId, roleId, task.dayIndex, task.cellIndex, taskUpdateParam);
+                                if(!rec) continue;
+                                activityTaskPushMessages.push({...task, totalCount: rec.totalCount, receiveRewardCount: rec.receiveRewardCount||0, activityId, activityType: "daily" });
+                            }
+                        }
+                        break;
+                    }
+                case ACTIVITY_TYPE.REFRESH_TASK:
+                    {
+                        // 通用的刷新任务
+                        let taskActivity = new RefreshTaskData(activity, roleCreateTime, serverCreateTime);
+                        let taskArray = taskActivity.findTaskByType(taskType);
+                        for (let task of taskArray) {
+                            let taskUpdateParam = this.checkIsMatch(task.taskParamArray, count);
+                            if(taskUpdateParam) {
+                                let rec = await ActivityRefreshTaskModel.checkAndUpdateTask(serverId, activityId, roleId, taskActivity.roundIndex, task.pageIndex, task.id, taskUpdateParam);
+                                if(!rec) continue;
+                                activityTaskPushMessages.push({...task, totalCount: rec.totalCount, receiveRewardCount: rec.receiveRewardCount||0, activityId });
+                            }
+                        }
+                        break;
+                    }
+                case ACTIVITY_TYPE.TREASURE_HUNT:
+                    {
+                        // 寻宝奇兵任务
+                        let tempData = await this.getTreasureHuntTemp();
+                        if(tempData && tempData.huntActivityId == activityId) {
+                            let playerData = new TreasureHuntData(activity, roleCreateTime, serverCreateTime);
+                            let taskArray = playerData.tasks.findItemByTaskType(taskType);
+                            for (let task of taskArray) {
+                                let taskUpdateParam = this.checkIsMatch(task.taskParamArray, count);
+                                if(taskUpdateParam) {
+                                    let rec = await ActivityTreasureHuntTaskModel.checkAndUpdateTask(serverId, activityId, roleId, tempData.huntRoundIndex, task.cellIndex, taskUpdateParam);
+                                    if(!rec) continue;
+                                    activityTaskPushMessages.push({ ...task, totalCount: rec.totalCount, activityId });
+                                }
+                            }
+                        }
+                        break;
+                    }
+                case ACTIVITY_TYPE.THIRTY_DAYS:
+                    {
+                        //30天任务统计
+                        let thirtyDaysActivity = new ThirtyDaysData(activity, roleCreateTime, serverCreateTime);
+                        let taskArray = thirtyDaysActivity.findTaskByType(taskType);
+                        for (let task of taskArray) {
+                            let taskUpdateParam = this.checkIsMatch(task.taskParamArray, count);
+                            if(taskUpdateParam) {
+                                let rec = await ActivityThirtyDaysModel.checkAndUpdateTask(serverId, thirtyDaysActivity.activityId, roleId, task.pageIndex, task.cellIndex, task.tab, taskUpdateParam);
+                                if(!rec) continue;
+                                activityTaskPushMessages.push({ ...task, totalCount: rec.totalCount, activityId });
+                            }
+                        }
+                        break;
+                    }
+                case ACTIVITY_TYPE.GROWTH_FUND_MAIN:
+                case ACTIVITY_TYPE.GROWTH_FUND_MAIN_VIP:
+                    {
+                        //主线成长基金
+                        if(taskType != TASK_TYPE.BATTLE_MAIN) continue;
+
+                        let growthFundActivity = new GrowthFundData(activity, roleCreateTime, serverCreateTime);
+                        let playerRecords = await ActivityGrowthFundModel.findData(activity.activityId, roleId);
+                        growthFundActivity.setPlayerRecords(playerRecords);
+                        if (growthFundActivity.isVipActivity()) {//vip高阶需要购买
+                            let buyRecords = await ActivityBuyRecordsModel.findRecordsByActivityId(activity.activityId, roleId);
+                            growthFundActivity.initBuyRecords(buyRecords);
+                        }
+                        let taskArray = growthFundActivity.unLockItem(this.param.warId);
+                        //推送
+                        activityTaskPushMessages.push(...taskArray);
+                        break;
+                    }
+                case ACTIVITY_TYPE.GROWTH_FUND_TOWER:
+                case ACTIVITY_TYPE.GROWTH_FUND_TOWER_VIP:
+                    {
+                        //镇念塔成长基金
+                        if(taskType != TASK_TYPE.BATTLE_TOWER_LV) continue;
+
+                        let growthFundActivity = new GrowthFundData(activity, roleCreateTime, serverCreateTime);
+                        let playerRecords = await ActivityGrowthFundModel.findData(activity.activityId, roleId);
+                        growthFundActivity.setPlayerRecords(playerRecords);
+                        if (growthFundActivity.isVipActivity()) {//vip高阶需要购买
+                            let buyRecords = await ActivityBuyRecordsModel.findRecordsByActivityId(activity.activityId, roleId);
+                            growthFundActivity.initBuyRecords(buyRecords);
+                        }
+                        let taskArray = growthFundActivity.unLockItem(this.param.towerLv);
+                        //推送
+                        activityTaskPushMessages.push(...taskArray);
+                        break;
+                    }
+                case ACTIVITY_TYPE.GROWTH_FUND_MAIN_ELITE:
+                case ACTIVITY_TYPE.GROWTH_FUND_MAIN_ELITE_VIP:
+                    {
+                        //精英成长基金
+                        if(taskType != TASK_TYPE.BATTLE_MAIN_ELITE) continue;
+
+                        let growthFundActivity = new GrowthFundData(activity, roleCreateTime, serverCreateTime);
+                        let playerRecords = await ActivityGrowthFundModel.findData(activity.activityId, roleId);
+                        growthFundActivity.setPlayerRecords(playerRecords);
+                        if (growthFundActivity.isVipActivity()) {//vip高阶需要购买
+                            let buyRecords = await ActivityBuyRecordsModel.findRecordsByActivityId(activity.activityId, roleId);
+                            growthFundActivity.initBuyRecords(buyRecords);
+                        }
+                        let taskArray = growthFundActivity.unLockItem(this.param.warId);
+                        //推送
+                        activityTaskPushMessages.push(...taskArray);
+                        break;
+                    }
+            }
+        }
+
+        if (taskPushMessages.length > 0) {
+            if (!sid) {
+                let onlineUser = await getRoleOnlineInfo(roleId);
+                sid = onlineUser.sid;
+            }
+            if (!!sid) {
+                let uids = [{ uid: roleId, sid }];
+                pinus.app.get('channelService').pushMessageByUids('onTaskUpdate', resResult(STATUS.SUCCESS, taskPushMessages), uids);
+            }
+        }
+        if (activityTaskPushMessages?.length > 0) {
+            if (!sid) {
+                let onlineUser = await getRoleOnlineInfo(roleId);
+                sid = onlineUser.sid;
+            }
+            if (!!sid) {
+                let uids = [{ uid: roleId, sid }];
+                pinus.app.get('channelService').pushMessageByUids('onActivityTaskUpdate', resResult(STATUS.SUCCESS, activityTaskPushMessages), uids);
+            }
+        }
+    }
+
+    public checkIsMatch(dicTaskParam: number[], count: number): UpdateTaskParam {
+        let param = this.param;
+        switch(this.taskType) {
+            case TASK_TYPE.LOGIN_SUM:
+                {
+                    let today = getZeroPoint();
+                    if (today > param.role.loginTime) {
+                        return { inc: count }
+                    }
+                }
+        }
+    }
+
+    private async getTreasureHuntTemp() {
+        if(this.treasureHuntTemp) return this.treasureHuntTemp;
+
+        let tempData: ServerTempModelType = await ServerTempModel.findData(this.serverId);
+        if (tempData) {
+            this.treasureHuntTemp = tempData;
+            return tempData
+        } else {
+            return null
+        }    
+    }
+}
+
+class TaskParam {
+    role?: RoleType;          // 玩家数据
+    warId?: number;
+    towerLv?: number;
+
+    public setRole(role: RoleType) {
+        this.role = role;
+    }
+
+}

game-server/app/services/task/taskService.ts

@@ -1,20 +1,20 @@
-import * as taskUtil from '../pubUtils/taskUtil';
-import { RoleModel, RoleType } from '../db/Role';
+import * as taskUtil from '../../pubUtils/taskUtil';
+import { RoleModel, RoleType } from '../../db/Role';
 import { pinus, FrontendOrBackendSession } from 'pinus';
-import { resResult, shouldRefresh } from '../pubUtils/util';
-import { STATUS, TASK_TYPE, TASK_FUN_TYPE, SHOP_REFRESH_TYPE, WAR_TYPE } from '../consts';
-import { TaskParam, TaskListReturn } from '../domain/roleField/task';
-import { EPlace, HeroType } from '../db/Hero';
-import { getRoleOnlineInfo } from './redisService';
-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 { getSeconds, getZeroPointD } from '../pubUtils/timeUtil';
-import { RoleStatus } from '../db/ComBattleTeam';
-import { getActivities } from './activity/activityService';
+import { resResult, shouldRefresh } from '../../pubUtils/util';
+import { STATUS, TASK_TYPE, TASK_FUN_TYPE, SHOP_REFRESH_TYPE, WAR_TYPE } from '../../consts';
+import { TaskParam, TaskListReturn } from '../../domain/roleField/task';
+import { EPlace, HeroType } from '../../db/Hero';
+import { getRoleOnlineInfo } from '../redisService';
+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 { getSeconds, getZeroPointD } from '../../pubUtils/timeUtil';
+import { RoleStatus } from '../../db/ComBattleTeam';
+import { getActivities } from '../activity/activityService';
 
 export async function checkTaskWithRoles(serverId: number, roleId: string, sid: string, taskType: number, roles: RoleType[]) {
     for (let role of roles) {