diff --git a/game-server/app/servers/activity/handler/gachaHandler.ts b/game-server/app/servers/activity/handler/gachaHandler.ts
index f3a55d971..6af590043 100644
--- a/game-server/app/servers/activity/handler/gachaHandler.ts
+++ b/game-server/app/servers/activity/handler/gachaHandler.ts
@@ -1,6 +1,6 @@
 import { Application, BackendSession } from "pinus";
 import { resResult, getRandEelmWithWeight, shouldRefresh, getRandSingleEelm } from "../../../pubUtils/util";
-import { STATUS, GACHA_ID, HERO_QUALITY_TYPE, TASK_TYPE, REFRESH_HOUR } from "../../../consts";
+import { STATUS, GACHA_ID, HERO_QUALITY_TYPE, TASK_TYPE, REFRESH_TIME, TIME_OUTPUT_TYPE } from "../../../consts";
 import { gameData } from "../../../pubUtils/data";
 import { GachaListReturn, GachaResult, GachaData } from "../../../domain/activityField/gachaField";
 import { UserGachaModel } from "../../../db/UserGacha";
@@ -9,7 +9,7 @@ import { RoleModel } from "../../../db/Role";
 import { HeroModel } from "../../../db/Hero";
 import { RewardInter } from "../../../pubUtils/interface";
 import { handleCost, createHeroes, addItems } from "../../../services/rewardService";
-import { getAfterDateByDay, getTodayZeroDate } from "../../../pubUtils/timeUtil";
+import { getZeroPointD, getTimeFun } from "../../../pubUtils/timeUtil";
 import { UserGachaRecModel } from "../../../db/UserGachaRec";
 import { ActivityModel } from "../../../db/Activity";
 import { checkTask } from "../../../services/taskService";
@@ -133,7 +133,8 @@ export class GachaHandler {
 
         let resultRefFreeTime = 0;
         if (dicGacha.free.count > 0) {
-            resultRefFreeTime = getAfterDateByDay(refFreeTime, dicGacha.free.day);
+            let f = getTimeFun(userGacha.refFreeTime);
+            resultRefFreeTime = <number>f.getAfterDayWithHour(dicGacha.free.day);
         }
         return resResult(STATUS.SUCCESS, {
             gachaId, activityId,
@@ -290,7 +291,7 @@ export class GachaHandler {
         const roleId: string = session.get('roleId');
 
         let { visitedHero, refVisitedTime } = await UserGachaModel.findByRole(roleId, GACHA_ID.NORMAL, 0);
-        if (shouldRefresh(refVisitedTime, new Date(), REFRESH_HOUR)) {
+        if (shouldRefresh(refVisitedTime, new Date())) {
             visitedHero = [];
         }
 
@@ -317,9 +318,9 @@ export class GachaHandler {
         let { pieceId } = dicHero;
 
         let { visitedHero, refVisitedTime } = await UserGachaModel.findByRole(roleId, GACHA_ID.NORMAL, 0);
-        if (shouldRefresh(refVisitedTime, new Date(), REFRESH_HOUR)) {
+        if (shouldRefresh(refVisitedTime, new Date())) {
             visitedHero = [];
-            refVisitedTime = getTodayZeroDate(REFRESH_HOUR);
+            refVisitedTime = getZeroPointD();
         }
         if (visitedHero.includes(hid)) {
             return resResult(STATUS.GACHA_HAS_VISITED);
diff --git a/game-server/app/servers/battle/handler/comBattleHandler.ts b/game-server/app/servers/battle/handler/comBattleHandler.ts
index f08d60090..8a6a8f4b6 100644
--- a/game-server/app/servers/battle/handler/comBattleHandler.ts
+++ b/game-server/app/servers/battle/handler/comBattleHandler.ts
@@ -22,7 +22,7 @@ import { addUserToChannel, getSimpleRoleInfo } from '../../../services/roleServi
 import { ChannelUser } from '../../../domain/ChannelUser';
 import { pushComBtlTeamMsg, pushFriendTeamInviteMsg, pushNormalItemMsg, pushTeamInviteMsg } from '../../../services/chatService';
 import { EXTERIOR } from '../../../pubUtils/dicParam';
-import { getTodayZeroDate } from '../../../pubUtils/timeUtil';
+import { getZeroPointD, getTimeFunD } from '../../../pubUtils/timeUtil';
 import { FriendParams } from '../../../domain/roleField/friend';
 import { checkTask, checkTaskWithGoods } from '../../../services/taskService';
 import { gameData, getWarByBlueprtId } from '../../../pubUtils/data';
@@ -595,7 +595,8 @@ export class ComBattleHandler {
      */
     async getTeamRec(msg: {}, session: BackendSession) {
         let roleId = session.get('roleId');
-        let teams = await ComBattleTeamModel.getTeamByRoleAndTime(roleId, null, new Date(new Date().setHours(0, 0, 0, 0) - 2 * 24 * 60 * 60 * 1000));
+        let timef = getTimeFunD();
+        let teams = await ComBattleTeamModel.getTeamByRoleAndTime(roleId, null, <Date>timef.getBeforeDayWithHour(2));
         if (!teams) return resResult(STATUS.COM_BATTLE_NO_RECENT_REC);
 
         return resResult(STATUS.SUCCESS, {teamInfos: teams});
@@ -707,7 +708,7 @@ export class ComBattleHandler {
     async getRecentTeammates(msg: { }, session: BackendSession) {
         let roleId = session.get('roleId');
 
-        const teams = await ComBattleTeamModel.getTeamByRoleAndTime(roleId, null, getTodayZeroDate());
+        const teams = await ComBattleTeamModel.getTeamByRoleAndTime(roleId, null, getZeroPointD());
         let roleIdList = new Array<string>();
         for(let { roleIds } of teams) {
             for(let r of roleIds) {
diff --git a/game-server/app/servers/battle/handler/dungeonBattleHandler.ts b/game-server/app/servers/battle/handler/dungeonBattleHandler.ts
index e93591d58..81d03dc8f 100644
--- a/game-server/app/servers/battle/handler/dungeonBattleHandler.ts
+++ b/game-server/app/servers/battle/handler/dungeonBattleHandler.ts
@@ -19,7 +19,7 @@ export class DungeonBattleHandler {
         let roleId = session.get('roleId');
         let { dungeonCnt = 0, dungeonBuyCnt = 0, dungeonRefTime, dungeonHeroes=[] } = await RoleModel.findByRoleId(roleId);
         let curTime = new Date();
-        if(shouldRefresh(dungeonRefTime, curTime, DUNGEON_CONST.REFRESH_TIME)) {
+        if(shouldRefresh(dungeonRefTime, curTime)) {
             dungeonCnt = 0; dungeonBuyCnt = 0;
         }
 
@@ -41,7 +41,7 @@ export class DungeonBattleHandler {
 
         let { dungeonCnt = 0, dungeonBuyCnt = 0, dungeonRefTime } = await RoleModel.findByRoleId(roleId);
         let curTime = new Date();
-        let needRefresh = shouldRefresh(dungeonRefTime, curTime, DUNGEON_CONST.REFRESH_TIME);
+        let needRefresh = shouldRefresh(dungeonRefTime, curTime);
         if(needRefresh) {
             dungeonCnt = 0; dungeonBuyCnt = 0;
         }
diff --git a/game-server/app/servers/battle/handler/guildBossHandler.ts b/game-server/app/servers/battle/handler/guildBossHandler.ts
index d3ce5d1a3..8a6dec392 100644
--- a/game-server/app/servers/battle/handler/guildBossHandler.ts
+++ b/game-server/app/servers/battle/handler/guildBossHandler.ts
@@ -1,9 +1,9 @@
 import { Application, BackendSession } from 'pinus';
 import { resResult, genCode, getRandSingleEelm } from '../../../pubUtils/util';
-import { STATUS, TASK_TYPE, AUCTION_SOURCE } from '../../../consts';
+import { STATUS, TASK_TYPE } from '../../../consts';
 import { BossInstanceModel } from '../../../db/BossInstance';
 import { BattleRecordModel } from '../../../db/BattleRecord';
-import { nowSeconds, getTodayZeroPoint } from '../../../pubUtils/timeUtil';
+import { nowSeconds, getZeroPoint } from '../../../pubUtils/timeUtil';
 import { getBossInstanceInfo, bossResult, checkBossBattleMemberExists, pushBossHpMessage, getBossInstanceWhenEnd, addBossInstance } from '../../../services/guildBossService';
 import { findWhere } from 'underscore'
 import { GUILD_STRUCTURE, GUILD_BOSS_STATUS, GUILD_POINT_WAYS } from '../../../consts/constModules/guildConst';
@@ -16,7 +16,6 @@ import { getBossByLv } from '../../../pubUtils/data';
 import { lockData } from '../../../services/redLockService';
 import { pushGuildBossSucMsg } from '../../../services/chatService';
 import { checkTask } from '../../../services/taskService';
-import { genAuction } from '../../../services/auctionService';
 
 export default function (app: Application) {
     return new GuildHandler(app);
@@ -75,7 +74,7 @@ export class GuildHandler {
         if (!!res.err) 
             return resResult(STATUS.REDLOCK_ERR); 
         let bossInstance = await BossInstanceModel.findBossInstance(code);
-        if (!!bossInstance && ( bossInstance.bossHp > 0 || bossInstance.startTime >= getTodayZeroPoint() )) {
+        if (!!bossInstance && ( bossInstance.bossHp > 0 || bossInstance.startTime >= getZeroPoint() )) {
             res.releaseCallback();
             return resResult(STATUS.GUILD_SCRIPT_IS_OPENED_TODAY);
         }
@@ -116,7 +115,7 @@ export class GuildHandler {
         if (bossInstance.bossHp <= 0) 
             return resResult(STATUS.GUILD_SCRIPT_IS_COMPLETE);
         let myRank = findWhere(bossInstance.ranks, {roleId});
-        if (!!myRank && myRank.time > getTodayZeroPoint()) 
+        if (!!myRank && myRank.time > getZeroPoint()) 
             return resResult(STATUS.GUILD_SCRIPT_IS_BATTLED);
         let { warId, ranks } = bossInstance;
         const battleCode = genCode(8); // 关卡唯一值
diff --git a/game-server/app/servers/battle/handler/guildHandler.ts b/game-server/app/servers/battle/handler/guildHandler.ts
index c54977c36..16ac2f0e6 100644
--- a/game-server/app/servers/battle/handler/guildHandler.ts
+++ b/game-server/app/servers/battle/handler/guildHandler.ts
@@ -1,5 +1,5 @@
-import { Application, BackendSession, pinus, ChannelService } from 'pinus';
-import { resResult, getRandEelm, getRefTime, shouldRefresh, sortArrRandom } from '../../../pubUtils/util';
+import { Application, BackendSession, ChannelService } 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 } from '../../../consts';
 import { UserGuildModel } from '../../../db/UserGuild';
 import { checkAuth, joinGuild, getGuildWithRefActive, getUserGuildWithRefActive, addActive, settleGuildWeekly } from '../../../services/guildService';
@@ -8,9 +8,9 @@ import { RoleModel, RoleType } from '../../../db/Role';
 import { ARMY } from '../../../pubUtils/dicParam';
 import { handleCost, addItems } from '../../../services/rewardService';
 import { getGoldObject } from '../../../pubUtils/itemUtils';
-import { nowSeconds, getBeforeDaySeconds, getSeconds } from '../../../pubUtils/timeUtil';
+import { nowSeconds, getTimeFun } from '../../../pubUtils/timeUtil';
 import { GuildListInfo } from '../../../domain/battleField/guild';
-import { GuildRankParam, GuildLeader } from '../../../domain/rank';
+import { GuildLeader } from '../../../domain/rank';
 import { UserGuildApplyModel } from '../../../db/UserGuildApply';
 import { hasStructureConsume, getStructureConsume, gameData } from '../../../pubUtils/data';
 import { GuildRecModel } from '../../../db/GuildRec';
@@ -420,13 +420,13 @@ export class GuildHandler {
 
         let guild = await GuildModel.findByCode(myGuild.guildCode, serverId, GUILD_SELECT.INVITED_MEMBER);
         let invitedMembers = guild.invitedMembers;
-        if(shouldRefresh(guild.inviteTime, new Date(), 0)) {
+        if(shouldRefresh(guild.inviteTime, new Date())) {
             invitedMembers = [];
         }
 
         // 离线时间，三天内在线且尚未加入军团。按以下规则排序  离线时间 玩家等级 玩家战力
         
-        const day = getBeforeDaySeconds(3);
+        const day = <number>getTimeFun().getBeforeDay(3);
 
         const { quitGuildTime: quitTime = 0 } = await RoleModel.findByRoleId(roleId);
         let allList = await RoleModel.getInviteList(day, serverId);
@@ -472,7 +472,7 @@ export class GuildHandler {
                 }
             }
         }
-        await GuildModel.recordInvitedMember(code, serverId, roleIds, shouldRefresh(guild.inviteTime, new Date(), 0));
+        await GuildModel.recordInvitedMember(code, serverId, roleIds, shouldRefresh(guild.inviteTime, new Date()));
         this.channelService.pushMessageByUids('onGuildInvite', resResult(STATUS.SUCCESS, { code }), uids);
 
         return resResult(STATUS.SUCCESS, { roleIds: result });
@@ -717,7 +717,7 @@ export class GuildHandler {
 
         // 离线72小时
         const { roleName: oldRoleName, quitTime } = await RoleModel.findByRoleId(leaderRoleId);
-        if (quitTime > getBeforeDaySeconds(3)) {
+        if (quitTime > <number>getTimeFun().getBeforeDay(3)) {
             return resResult(STATUS.GUILD_LEADER_LOGIN);
         }
         // 上周周功勋最高的人
@@ -830,9 +830,8 @@ export class GuildHandler {
         const checkResult = await checkAuth(GUILD_OPERATE.GET_REC, roleId, code);
         if (!checkResult) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
 
-        let startTime = getRefTime(new Date(), 0, -3);
         // console.log(startTime)
-        const list = await GuildRecModel.getGuildRec(code, getSeconds(startTime));
+        const list = await GuildRecModel.getGuildRec(code, <number>getTimeFun().getBeforeDayWithHour(3));
 
         return resResult(STATUS.SUCCESS, { list });
     }
@@ -987,7 +986,7 @@ export class GuildHandler {
         const serverId = session.get('serverId');
         const guild = await GuildModel.findByCode(code, serverId);
         const leader = <RoleType>guild.leader;
-        let threeDaysBefore = getBeforeDaySeconds(3);
+        let threeDaysBefore = <number>getTimeFun().getBeforeDay(3);
         await RoleModel.updateRoleInfo(leader.roleId, { quitTime: threeDaysBefore } );
 
         return resResult(STATUS.SUCCESS, { code });
diff --git a/game-server/app/servers/battle/handler/guildTrainHandler.ts b/game-server/app/servers/battle/handler/guildTrainHandler.ts
index c0a382750..83a5ecff3 100644
--- a/game-server/app/servers/battle/handler/guildTrainHandler.ts
+++ b/game-server/app/servers/battle/handler/guildTrainHandler.ts
@@ -3,11 +3,11 @@ import { resResult, genCode, getRandSingleEelm } from '../../../pubUtils/util';
 import { STATUS, TASK_TYPE } from '../../../consts';
 import { GuildTrainModel } from '../../../db/GuildTrain';
 import { BattleRecordModel } from '../../../db/BattleRecord';
-import { nowSeconds, getHourPoint, getCurHourPoint } from '../../../pubUtils/timeUtil';
+import { nowSeconds, getTimeFun, getZeroPoint } from '../../../pubUtils/timeUtil';
 import { getUserGuild, getGuildTrainInfo, unlockTrain, getGuildTrainRewards } from '../../../services/guildTrainService';
 import { findIndex, findWhere } from 'underscore'
 import { lockData } from '../../../services/redLockService';
-import { REFRESH_HOUR, GUILD_REPORT_NUM, GUILD_POINT_WAYS } from '../../../consts/constModules/guildConst';
+import { GUILD_REPORT_NUM, GUILD_POINT_WAYS } from '../../../consts/constModules/guildConst';
 import { UserGuildModel } from '../../../db/UserGuild';
 import { GuildModel } from '../../../db/Guild';
 import { getArmyTrainJuDian, getTrainSoloReward, getTrainBaseByLv } from '../../../pubUtils/data';
@@ -171,10 +171,11 @@ export class GuildTrainHandler {
             return resResult(STATUS.WRONG_PARMS);
         }
 
-        if (time < getCurHourPoint(REFRESH_HOUR) && nowSeconds() > getCurHourPoint(REFRESH_HOUR)) {
+        let todayRef = <number>getTimeFun().getTimeWithHour(); // 今天的5点
+        if (time < todayRef && nowSeconds() > todayRef) {
             return resResult(STATUS.GUILD_TRAIN_IS_RESETED);//重置前进入战斗，重置后回调该接口
         }
-        if (time > getHourPoint(REFRESH_HOUR)) {
+        if (time > getZeroPoint()) { // 刷新时间，如果是4点算前一天的5点
             userGuild = await UserGuildModel.updateInfo(roleId, {}, { trainCount: -1 });//扣除一次挑战次数
         }
         await BattleRecordModel.updateBattleRecordByCode(battleCode, {
diff --git a/game-server/app/servers/battle/handler/towerBattleHandler.ts b/game-server/app/servers/battle/handler/towerBattleHandler.ts
index 76e7a2824..d6e679d01 100644
--- a/game-server/app/servers/battle/handler/towerBattleHandler.ts
+++ b/game-server/app/servers/battle/handler/towerBattleHandler.ts
@@ -86,7 +86,7 @@ export class TowerBattleHandler {
         let {timeReward, startTime, deltaTime} = result.data;
         let {hangUpSpdUpCnt, lastSpdUpTime} = await RoleModel.findByRoleId(roleId);
         let curTime = new Date();
-        if (!lastSpdUpTime || (shouldRefresh(lastSpdUpTime, curTime, HANG_UP_CONSTS.REFRESH_TIME, 1) && hangUpSpdUpCnt <= HANG_UP_CONSTS.MAX_SPD_UP_CNT)) {
+        if (!lastSpdUpTime || (shouldRefresh(lastSpdUpTime, curTime) && hangUpSpdUpCnt <= HANG_UP_CONSTS.MAX_SPD_UP_CNT)) {
             hangUpSpdUpCnt = HANG_UP_CONSTS.MAX_SPD_UP_CNT;
         }        
         let num = HANG_UP_CONSTS.MAX_SPD_UP_CNT - hangUpSpdUpCnt + 1;
@@ -167,7 +167,7 @@ export class TowerBattleHandler {
         let { towerLv, towerTaskRefTime, towerTaskReCnt = 0 } = await RoleModel.findByRoleId(roleId);
         let curTasks = await TowerTaskRecModel.getCurTasks(roleId); // 当前显示中的任务
 
-        const needRefresh = shouldRefresh(towerTaskRefTime, curTime, TOWER_TASK_CONST.REFRESH_TIME);
+        const needRefresh = shouldRefresh(towerTaskRefTime, curTime);
 
         if(needRefresh) {
             const batchCode = genCode(8);
diff --git a/game-server/app/servers/connector/handler/entryHandler.ts b/game-server/app/servers/connector/handler/entryHandler.ts
index 9b2263651..994b263e5 100644
--- a/game-server/app/servers/connector/handler/entryHandler.ts
+++ b/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, getCurWeekTime } from '../../../pubUtils/timeUtil';
+import { nowSeconds } from '../../../pubUtils/timeUtil';
 import { rmRoleFromQueue, roleLeave, getRoleOnlineInfo, roleLogin } from '../../../services/redisService';
 import { UserGuildModel } from '../../../db/UserGuild';
 import { GuildModel } from '../../../db/Guild';
diff --git a/game-server/app/servers/guild/handler/cityActivityHandler.ts b/game-server/app/servers/guild/handler/cityActivityHandler.ts
index d079c057e..063faf12f 100644
--- a/game-server/app/servers/guild/handler/cityActivityHandler.ts
+++ b/game-server/app/servers/guild/handler/cityActivityHandler.ts
@@ -8,7 +8,7 @@ import { UserGuildActivityRecModel } from "../../../db/UserGuildActivityRec";
 import { leaveCityChannel, addRoleToCityChannel, getCityChannelSid } from "../../../services/chatService";
 import { UserGuildModel } from "../../../db/UserGuild";
 import { GuildActivityRecordModel } from "../../../db/GuildActivityRec";
-import { nowSeconds, getBeforeSeconds, getNextHourPoint } from "../../../pubUtils/timeUtil";
+import { nowSeconds, getTimeFun } from "../../../pubUtils/timeUtil";
 import { getGoldObject } from "../../../pubUtils/itemUtils";
 import { GUILDACTIVITY } from "../../../pubUtils/dicParam";
 import { handleCost } from "../../../services/rewardService";
@@ -233,14 +233,15 @@ export class CityActivityHandler {
         let pushResult = await UserGuildActivityRecModel.pushCityRecord(code, { round, hid, damage });
         if (!pushResult) return resResult(STATUS.WRONG_PARMS);
 
+        let tomorrow = <number>getTimeFun().getAfterDayWithHour();
         // 更新redis数据
         let myR = new Rank(REDIS_KEY.USER_CITY_ACTIVITY, { serverId, guildCode });
         let myScore = await myR.setRankWithRoleInfo(roleId, damage, Date.now(), null, true);
-        await myR.setExpire(getNextHourPoint(5));
+        await myR.setExpire(tomorrow);
 
         let r = new Rank(REDIS_KEY.CITY_ACTIVITY, { serverId, cityId }, true);
         let guildScore = await r.setRankWithGuildInfo(guildCode, damage, Date.now(), null, true);
-        await r.setExpire(getNextHourPoint(5));
+        await r.setExpire(tomorrow);
 
         gateHp = obj.getGateHpAndInc(serverId, cityId, dicCity.hp, -1 * damage);
         if (gateHp <= 0) {
@@ -278,7 +279,7 @@ export class CityActivityHandler {
         if (!dicCity) return resResult(STATUS.DIC_DATA_NOT_FOUND);
 
         // 更新userGuildActivityRecord
-        let challengeTime = getBeforeSeconds(-1 * GUILDACTIVITY.CITYACTIVITY_CHALLENGE_CD);
+        let challengeTime = <number>getTimeFun().getBeforeSeconds(-1 * GUILDACTIVITY.CITYACTIVITY_CHALLENGE_CD);
         let myGuildActivityRec = await UserGuildActivityRecModel.updateInfo(code, { isSuccess, isCompleted: true, cityId, challengeTime });
         if (!myGuildActivityRec) return resResult(STATUS.INTERNAL_ERR);
 
diff --git a/game-server/app/servers/guild/handler/gateActivityHandler.ts b/game-server/app/servers/guild/handler/gateActivityHandler.ts
index a6678ee69..596316ec8 100644
--- a/game-server/app/servers/guild/handler/gateActivityHandler.ts
+++ b/game-server/app/servers/guild/handler/gateActivityHandler.ts
@@ -13,7 +13,7 @@ import { getGuildChannelSid } from "../../../services/chatService";
 import { UserGuildModel } from "../../../db/UserGuild";
 import { GuildActivityCityModel } from "../../../db/GuildActivityCity";
 import { Rank } from "../../../services/rankService";
-import { getNextHourPoint } from "../../../pubUtils/timeUtil";
+import { getTimeFun } from "../../../pubUtils/timeUtil";
 import { checkTask } from "../../../services/taskService";
 import { accomplishTask } from "../../../pubUtils/taskUtil";
 
@@ -139,14 +139,15 @@ export class GateActivityHandler {
         let { score, newRecords, memberRecord: newMemberRecord } = scoreResult;
         obj.setMemberRecord(code, newMemberRecord);
 
+        let tomorrow = <number>getTimeFun().getAfterDayWithHour();
         // 更新redis数据
         let myR = new Rank(REDIS_KEY.USER_GATE_ACTIVITY, { serverId, guildCode }, false);
         let myScore = await myR.setRankWithRoleInfo(roleId, score, Date.now(), null, true);
-        await myR.setExpire(getNextHourPoint(5));
+        await myR.setExpire(tomorrow);
 
         let r = new Rank(REDIS_KEY.GATE_ACTIVITY, { serverId }, true);
         let guildScore = await r.setRankWithGuildInfo(guildCode, score, Date.now(), null, true);
-        await r.setExpire(getNextHourPoint(5));
+        await r.setExpire(tomorrow);
 
         // 更新数据库
         let rec = await UserGuildActivityRecModel.pushRecord(code, newRecords, round);
diff --git a/game-server/app/servers/role/handler/friendHandler.ts b/game-server/app/servers/role/handler/friendHandler.ts
index df41becde..60789db04 100644
--- a/game-server/app/servers/role/handler/friendHandler.ts
+++ b/game-server/app/servers/role/handler/friendHandler.ts
@@ -1,8 +1,8 @@
 import { Application, BackendSession, ChannelService } from "pinus";
-import { resResult, getRandEelm, getResStr, shouldRefresh, getRefTime, sortArrRandom } from "../../../pubUtils/util";
+import { resResult, getRandEelm, getResStr, shouldRefresh, sortArrRandom } 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 } from "../../../consts";
-import Role, { RoleModel, RoleType } from "../../../db/Role";
-import { getBeforeHourSeconds } from "../../../pubUtils/timeUtil";
+import { RoleModel, RoleType } from "../../../db/Role";
+import { getTimeFun, getZeroPointD } from "../../../pubUtils/timeUtil";
 import { FriendApplyModel } from "../../../db/FriendApply";
 import { FriendApplyParams, FriendListParam, FriendRecommendParams, BlackListParam, FriendValueListParam } from "../../../domain/roleField/friend";
 import { FriendShipModel, FriendShipType } from "../../../db/FriendShip";
@@ -40,13 +40,13 @@ export class FriendHandler {
     public async getRecommend(msg: { }, session: BackendSession) {
         let roleId: string = session.get('roleId');
         
-        const day = getBeforeHourSeconds(FRIEND.FRIEND_RECONMMEND_ACTIVETIME);
+        const day = <number>getTimeFun().getBeforeHour(FRIEND.FRIEND_RECONMMEND_ACTIVETIME);
 
         const { lv, serverId: myServerId, userInfo: { serverType: myServerType } } = await RoleModel.findByRoleId(roleId, ROLE_SELECT.GET_MY_SERVER); 
         let allList = await RoleModel.getRecommedList(lv - FRIEND.FRIEND_RECONMMEND_LEVEL, lv + FRIEND.FRIEND_RECONMMEND_LEVEL, day);
 
         // 筛掉自己今天申请过的人
-        let applyList = await FriendApplyModel.getSentApplyList(roleId, getRefTime(new Date(), 0));
+        let applyList = await FriendApplyModel.getSentApplyList(roleId, getZeroPointD());
         allList = allList.filter(cur => {
             return !applyList.find(ccur => ccur.roleId == cur.roleId);
         });
@@ -294,7 +294,7 @@ export class FriendHandler {
             if(!friendRole || !friendShip) continue;
 
             let fs = <FriendShipType>friend.friendShip;
-            let ref = shouldRefresh(fs.refTime, new Date(), 0);
+            let ref = shouldRefresh(fs.refTime, new Date());
             if(ref) {
                 friendShip = await FriendShipModel.refreshSendAndReceive(roleId, friendRole.roleId);
             }
@@ -525,7 +525,7 @@ export class FriendHandler {
 
             if(todaySendCnt + FRIEND.FRIEND_FRIENDPOINT_ADD > max) break;
             let fs = <FriendShipType>relation.friendShip;
-            let ref = shouldRefresh(fs.refTime, new Date(), 0);
+            let ref = shouldRefresh(fs.refTime, new Date());
             let sendHeartRec = await FriendShipModel.sendHeart(roleId, relation.roleId, 1, FRIEND.FRIEND_RECEIVE_SINGLE, ref);
             if(!sendHeartRec) continue;
 
@@ -592,7 +592,7 @@ export class FriendHandler {
 
                 // 收取爱心
                 let fs = <FriendShipType>relation.friendShip;
-                let ref = shouldRefresh(fs.refTime, new Date(), 0);
+                let ref = shouldRefresh(fs.refTime, new Date());
                 let receiveHeartRec = await FriendShipModel.receiveHeart(roleId, relation.roleId, 1, relation.beSentHeart, ref);
                 if(!receiveHeartRec) continue;
     
diff --git a/game-server/app/servers/role/handler/taskHandler.ts b/game-server/app/servers/role/handler/taskHandler.ts
index 04c1e90b3..058a5984d 100644
--- a/game-server/app/servers/role/handler/taskHandler.ts
+++ b/game-server/app/servers/role/handler/taskHandler.ts
@@ -1,11 +1,11 @@
 import { Application, BackendSession, pinus } from "pinus";
 import { resResult, parseGoodStr, getRandSingleEelm } from "../../../pubUtils/util";
-import { STATUS, TASK_FUN_TYPE } from "../../../consts";
+import { STATUS, TASK_FUN_TYPE, SHOP_REFRESH_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, nowSeconds } from "../../../pubUtils/timeUtil";
+import { nowSeconds, getZeroPointD } from "../../../pubUtils/timeUtil";
 import { DicDailyTask, DicAchievement, DicMainTask } from "../../../pubUtils/dictionary/DicTask";
 import { getMainTask, refDailyTaskBox, removeHistoryTask, getCurTask, checkTask } from "../../../services/taskService";
 import { TASK } from "../../../pubUtils/dicParam";
@@ -41,7 +41,7 @@ export class ShopHandler {
         if(type == TASK_FUN_TYPE.DAILY) { // 增加积分
             let userTask = await UserTaskModel.findByRole(roleId);
             let dic = <DicDailyTask>dicTask;
-            let curWeek = getCurWeekDate(1, 5);
+            let curWeek = getZeroPointD(SHOP_REFRESH_TYPE.WEEKLY);
             if(curWeek > userTask.dailyTaskRefWeekly) {
                 userTask = await UserTaskModel.resetDailyScore(roleId, dic.point, curWeek);
             } else {
@@ -139,7 +139,7 @@ export class ShopHandler {
         let point = 0, weeklyPoint = 0, box: number[] = [];
         // 每日、成就增加积分
         if(type == TASK_FUN_TYPE.DAILY) { // 增加积分
-            let curWeek = getCurWeekDate(1, 5);
+            let curWeek = getZeroPointD(SHOP_REFRESH_TYPE.WEEKLY);
             let shouldRefresh = false;
             let { dailyTaskPointWeekly, dailyTaskBox, dailyTaskRefWeekly } = userTask;
 
@@ -263,7 +263,7 @@ export class ShopHandler {
         let point = 0, weeklyPoint = 0;
         if(type == TASK_FUN_TYPE.DAILY) { // 增加积分
             let userTask = await UserTaskModel.findByRole(roleId);
-            let curWeek = getCurWeekDate(1, 5);
+            let curWeek = getZeroPointD(SHOP_REFRESH_TYPE.WEEKLY);
             if(curWeek > userTask.dailyTaskRefWeekly) {
                 userTask = await UserTaskModel.resetDailyScore(roleId, incPoint, curWeek);
             } else {
diff --git a/game-server/app/services/auctionService.ts b/game-server/app/services/auctionService.ts
index 5aebfd667..869537597 100644
--- a/game-server/app/services/auctionService.ts
+++ b/game-server/app/services/auctionService.ts
@@ -4,7 +4,7 @@ import { LOT_CODE_LEN, AUCTION_STAGE, AUCTION_TIME, DIVIDEND_CODE_LEN, DIVIDEND_
 import { DividendRec, ItemReward } from "../domain/dbGeneral";
 import { genCode, resResult } from '../pubUtils/util';
 import { LotModel, LotParam } from '../db/Lot';
-import { getNextTime, getTodayZeroDate, getZeroDateByDeltaDay } from '../pubUtils/timeUtil';
+import { getZeroPointD, getTimeFunD } from '../pubUtils/timeUtil';
 import { gameData, getGoodById } from '../pubUtils/data';
 import { DividendParam, DividendType } from '../db/Dividend';
 import { pushMail } from '../pubUtils/interface';
@@ -53,31 +53,31 @@ export async function officialAuctionLots(session: BackendSession, begin: Date)
 }
 
 export function auctionBegin() {
-    return getNextTime(new Date(), AUCTION_TIME.GUILD_BEGIN_HOUR, AUCTION_TIME.GUILD_BEGIN_MIN);
+    return <Date>getTimeFunD().getAfterDayWithHour(0, AUCTION_TIME.GUILD_BEGIN_HOUR, AUCTION_TIME.GUILD_BEGIN_MIN);
 }
 
 export function guildAuctionEnd() {
-    return getNextTime(new Date(), AUCTION_TIME.GUILD_END_HOUR, AUCTION_TIME.GUILD_END_MIN);
+    return <Date>getTimeFunD().getAfterDayWithHour(0, AUCTION_TIME.GUILD_END_HOUR, AUCTION_TIME.GUILD_END_MIN);
 }
 
-export function auctionEnd() {
-    return getNextTime(new Date(), AUCTION_TIME.WORLD_END_HOUR, AUCTION_TIME.WORLD_END_MIN);
+export function auctionEnd() {    
+    return <Date>getTimeFunD().getAfterDayWithHour(0, AUCTION_TIME.WORLD_END_HOUR, AUCTION_TIME.WORLD_END_MIN);
 }
 
 export function todayGuildBegin() {
-    return getNextTime(getTodayZeroDate(), AUCTION_TIME.GUILD_BEGIN_HOUR, AUCTION_TIME.GUILD_BEGIN_MIN);
+    return <Date>getTimeFunD(getZeroPointD()).getAfterDayWithHour(0, AUCTION_TIME.GUILD_BEGIN_HOUR, AUCTION_TIME.GUILD_BEGIN_MIN);
 }
 
-export function yestodayGuildBegin() {
-    return getNextTime(getZeroDateByDeltaDay(-1), AUCTION_TIME.GUILD_BEGIN_HOUR, AUCTION_TIME.GUILD_BEGIN_MIN);
+export function yestodayGuildBegin() {    
+    return <Date>getTimeFunD(getZeroPointD()).getAfterDayWithHour(-1, AUCTION_TIME.GUILD_BEGIN_HOUR, AUCTION_TIME.GUILD_BEGIN_MIN);
 }
 
 export function todayWorldBegin() {
-    return getNextTime(getTodayZeroDate(), AUCTION_TIME.WORLD_BEGIN_HOUR, AUCTION_TIME.WORLD_BEGIN_MIN);
+    return <Date>getTimeFunD(getZeroPointD()).getAfterDayWithHour(0, AUCTION_TIME.WORLD_BEGIN_HOUR, AUCTION_TIME.WORLD_BEGIN_MIN);
 }
 
 export function todayWorldEnd() {
-    return getNextTime(getTodayZeroDate(), AUCTION_TIME.WORLD_END_HOUR, AUCTION_TIME.WORLD_END_MIN);
+    return <Date>getTimeFunD(getZeroPointD()).getAfterDayWithHour(0, AUCTION_TIME.WORLD_END_HOUR, AUCTION_TIME.WORLD_END_MIN);
 }
 
 /**
diff --git a/game-server/app/services/battleService.ts b/game-server/app/services/battleService.ts
index 1970859d3..97e63312e 100644
--- a/game-server/app/services/battleService.ts
+++ b/game-server/app/services/battleService.ts
@@ -1,11 +1,11 @@
 import { HeroModel } from './../db/Hero';
 import { HangUpRecordModel } from './../db/HangUpRecord';
 import { pinus } from 'pinus';
-import { HANG_UP_CONSTS, TOWER_TASK_CONST, REDIS_KEY, TASK_TYPE } from './../consts';
+import { HANG_UP_CONSTS, TOWER_TASK_CONST, REDIS_KEY, TASK_TYPE, TIME_OUTPUT_TYPE } from './../consts';
 import { BattleRecordModel } from './../db/BattleRecord';
 import { TowerRecordModel } from './../db/TowerRecord';
 import { RoleModel } from './../db/Role';
-import { shouldRefresh, resResult, cal, getRandEelmWithWeight, getRefTime } from '../pubUtils/util';
+import { shouldRefresh, resResult, cal, getRandEelmWithWeight } from '../pubUtils/util';
 import { STATUS } from '../consts/statusCode';
 import { HangUpSpdUpRecModel } from '../db/HangUpSpdUpRec';
 import { TowerTaskRecModel } from '../db/TowerTaskRec';
@@ -14,6 +14,7 @@ import { Rank } from './rankService';
 import { checkTask } from './taskService';
 import { getRandExpedition, gameData } from '../pubUtils/data';
 import { ItemInter, RewardInter } from '../pubUtils/interface';
+import { getTimeFunM } from '../pubUtils/timeUtil';
 
 export async function checkTowerWar(roleId: string, battleId: number, heroes: Array<number>) {
     let { towerLv } = await RoleModel.findByRoleId(roleId);
@@ -113,7 +114,7 @@ async function startHangUp(roleId: string, roleName: string) {
 export async function checkHangUpSpdUpCnt(roleId: string, cnt: number, curTime: Date) {
     const role = await RoleModel.findByRoleId(roleId);
     let {hangUpSpdUpCnt, gold, lastSpdUpTime} = role;
-    if (!lastSpdUpTime || (shouldRefresh(lastSpdUpTime, curTime, HANG_UP_CONSTS.REFRESH_TIME, 1) && hangUpSpdUpCnt <= HANG_UP_CONSTS.MAX_SPD_UP_CNT)) {
+    if (!lastSpdUpTime || (shouldRefresh(lastSpdUpTime, curTime) && hangUpSpdUpCnt <= HANG_UP_CONSTS.MAX_SPD_UP_CNT)) {
         hangUpSpdUpCnt = HANG_UP_CONSTS.MAX_SPD_UP_CNT;
     }        
     if (cnt > hangUpSpdUpCnt) {
@@ -145,7 +146,7 @@ export async function calcuHangUpReward(roleId: string, speedUp = false, speedUp
     }
 
     if (speedUp) { // 加速，直接收取6小时收益，小数的累积和普通收取独立
-        if (hangUpSpdUpCnt >= speedUpCnt || !lastSpdUpTime || shouldRefresh(lastSpdUpTime, new Date, HANG_UP_CONSTS.REFRESH_TIME, 1)) { // 可加速
+        if (hangUpSpdUpCnt >= speedUpCnt || !lastSpdUpTime || shouldRefresh(lastSpdUpTime, new Date)) { // 可加速
             let multi = Math.floor(HANG_UP_CONSTS.SPD_UP_REC_TIME / HANG_UP_CONSTS.UNIT_TIME);
             let spdUpRec = await HangUpSpdUpRecModel.getSpdUpRec(roleId, towerLv - 1);
             let goods = [];
@@ -293,8 +294,8 @@ export async function createCurTasks(towerLv: number, batchCode: string, roleId:
 }
 
 export function getRemainTime(curTime: Date) {
-    let nextTime = getRefTime(curTime, TOWER_TASK_CONST.REFRESH_TIME, 1);
-    return Math.floor((nextTime.getTime() - curTime.getTime())/1000);
+    let nextTime = <number>getTimeFunM(curTime).getAfterDayWithHour(1);
+    return Math.floor((nextTime - curTime.getTime())/1000);
 }
 
 export function treatTask(recs: Array<any>, curTime: Date) {
diff --git a/game-server/app/services/comBattleService.ts b/game-server/app/services/comBattleService.ts
index 925635ad1..a2dc97aee 100644
--- a/game-server/app/services/comBattleService.ts
+++ b/game-server/app/services/comBattleService.ts
@@ -24,6 +24,7 @@ import { checkTaskInComBattleEnd } from './taskService';
 import { getRewardByBlueprtId, gameData, comBtlRangeByLv, getBossHpByBlueprtId } from '../pubUtils/data';
 import { getFriendPointObject } from '../pubUtils/itemUtils';
 import { DicWar } from '../pubUtils/dictionary/DicWar';
+import { getZeroPointD } from '../pubUtils/timeUtil';
 
 /**
  * 在给定的品质列表中随机返回一定数量的藏宝图Id
@@ -170,7 +171,7 @@ export async function getRealReward(blueprtId: number, roleSt: RoleStatus) {
 }
 
 export async function getAssistTimesByQuality(roleId: string, qualityArr?: number[]) {
-    let teams = await ComBattleTeamModel.getAssistTeamsByTime(roleId, qualityArr, new Date(new Date().setHours(0, 0, 0, 0)), true);
+    let teams = await ComBattleTeamModel.getAssistTeamsByTime(roleId, qualityArr, getZeroPointD(), true);
     let cntMap = new Map<number, number>();
     teams.forEach(team => {
         if (team && team.quality && team.roleStatus) {
diff --git a/game-server/app/services/donateService.ts b/game-server/app/services/donateService.ts
index 699434643..d268d3845 100644
--- a/game-server/app/services/donateService.ts
+++ b/game-server/app/services/donateService.ts
@@ -1,6 +1,6 @@
 
 import { DonationModel } from '../db/Donation';
-import { getTodayZeroPoint, nowSeconds } from '../pubUtils/timeUtil';
+import { getZeroPoint, nowSeconds } from '../pubUtils/timeUtil';
 import { GuildModel } from '../db/Guild';
 import { findWhere } from 'underscore';
 import { GUILD_STRUCTURE } from '../consts/constModules/guildConst';
@@ -14,7 +14,7 @@ export async function getDonation(code: string, serverId: number) {
     if (!donation) {
         donation = await createDonation(code, serverId);
     }
-    if (donation.refTime < getTodayZeroPoint()) {
+    if (donation.refTime < getZeroPoint()) {
         let { structure } = await GuildModel.findGuild(code, serverId, 'structure');
         let { lv } = findWhere(structure, {id: GUILD_STRUCTURE.DONATE});
         donation = await DonationModel.updateDonation(code, { donateFund:0, reports:[], refTime: nowSeconds(), donationLv: lv});
diff --git a/game-server/app/services/dungeonService.ts b/game-server/app/services/dungeonService.ts
index 151c87334..46696019f 100644
--- a/game-server/app/services/dungeonService.ts
+++ b/game-server/app/services/dungeonService.ts
@@ -11,7 +11,7 @@ import { DUNGEON_CONST } from '../consts';
 export async function checkDungeonNum(roleId: string, inc: number) {
     let { dungeonCnt = 0, dungeonBuyCnt = 0, dungeonRefTime } = await RoleModel.findByRoleId(roleId);
     let curTime = new Date();
-    let needRefresh = shouldRefresh(dungeonRefTime, curTime, DUNGEON_CONST.REFRESH_TIME);
+    let needRefresh = shouldRefresh(dungeonRefTime, curTime);
     if(needRefresh) {
         dungeonCnt = 0; dungeonBuyCnt = 0;
     }
@@ -38,7 +38,7 @@ export async function checkDungeonAndIncrease(roleId: string, inc: number, isRef
     let { dungeonCnt = 0, dungeonBuyCnt = 0, dungeonRefTime } = await RoleModel.findByRoleId(roleId);
     let curTime = new Date();
 
-    let needRefresh = isRef && shouldRefresh(dungeonRefTime, curTime, DUNGEON_CONST.REFRESH_TIME);
+    let needRefresh = isRef && shouldRefresh(dungeonRefTime, curTime);
     if(needRefresh) {
         dungeonCnt = 0; dungeonBuyCnt = 0;
     }
diff --git a/game-server/app/services/expeditionService.ts b/game-server/app/services/expeditionService.ts
index 4483721ab..3f780fb2b 100644
--- a/game-server/app/services/expeditionService.ts
+++ b/game-server/app/services/expeditionService.ts
@@ -9,6 +9,7 @@ import { ExpeditionWarRecordModel } from '../db/ExpeditionWarRecord';
 import { HeroType } from '../db/Hero';
 import { gameData } from '../pubUtils/data';
 import { getPlayerAttribute, getRobotAttribute } from './pvpService';
+import { getTimeFunD } from '../pubUtils/timeUtil';
 
 /**
  * 根据存下的战力获取当前远征关卡的对手
@@ -167,9 +168,8 @@ export async function matchRobots(scale: number, myCe: number, robotCe: number,
 export async function getCEScaleAndRange(roleId: string, curDicExpedition: any) {
     // 匹配，判断是不是新手期
     const role = await RoleModel.findByRoleId(roleId);
-    let now = new Date();
-    let today = now.setHours(0, 0, 0, 0);;
-    let isNew = today - role.createdAt.getTime() <= 3*24*60*60*1000;
+    let timef = getTimeFunD(role.createdAt)
+    let isNew = timef.getDayGap() <= 3;
     let scale = isNew?curDicExpedition.CEScaleNew:curDicExpedition.CEScale;
     let range = isNew?curDicExpedition.CERangeNew:curDicExpedition.CERange;
     return {scale, range, lv: role.lv}
@@ -206,7 +206,7 @@ export async function getResetRemainCnt(curTime: Date, roleId: string, role?: Ro
     }
 
     let { expeditionResetCnt, expeditionResetRefTime } = role;
-    let needRefresh = !expeditionResetRefTime || shouldRefresh(expeditionResetRefTime, curTime, EXPEDITION_CONST.REFRESH_TIME);
+    let needRefresh = !expeditionResetRefTime || shouldRefresh(expeditionResetRefTime, curTime);
     if(needRefresh) {
         expeditionResetCnt = 0; expeditionResetRefTime = curTime;
     }
diff --git a/game-server/app/services/gachaService.ts b/game-server/app/services/gachaService.ts
index 1344347e1..aff866f0a 100644
--- a/game-server/app/services/gachaService.ts
+++ b/game-server/app/services/gachaService.ts
@@ -3,8 +3,8 @@ import { ActivityModel } from "../db/Activity";
 import { DicGacha } from "../pubUtils/dictionary/DicGacha";
 import { UserGachaType, UserGachaModel } from "../db/UserGacha";
 import { shouldRefresh, getRandEelm, getRandEelmWithWeight } from "../pubUtils/util";
-import { REFRESH_HOUR, GACHA_TO_FLOOR, GACHA_FLOOR_TYPE, GACHA_CONTENT_TYPE, HERO_QUALITY_TYPE, GACHA_OCCUPY_HID, IT_TYPE, ITID, CONSUME_TYPE, SPECIAL_ATTR } from "../consts";
-import { getNextDayByGap, getTodayZeroDate } from "../pubUtils/timeUtil";
+import { REFRESH_TIME, GACHA_TO_FLOOR, GACHA_FLOOR_TYPE, GACHA_CONTENT_TYPE, HERO_QUALITY_TYPE, GACHA_OCCUPY_HID, IT_TYPE, ITID, CONSUME_TYPE, SPECIAL_ATTR, TIME_OUTPUT_TYPE } from "../consts";
+import { getTimeFunD, getZeroPointD } from "../pubUtils/timeUtil";
 import { gameData, getDicGachaFloor } from "../pubUtils/data";
 
 /**
@@ -38,13 +38,13 @@ export async function refreshGacha(dicGacha: DicGacha, userGacha: UserGachaType)
     }
 
     let { roleId, gachaId, refFreeTime, refHopeTime, hope } = userGacha;
-    if(shouldRefresh(refFreeTime, new Date(), REFRESH_HOUR, day)) {
-        let ref = getNextDayByGap(refFreeTime, new Date(), day);
+    if(shouldRefresh(refFreeTime, new Date(), REFRESH_TIME, day)) {
+        let ref = <Date>getTimeFunD().getAfterDayByGap(refFreeTime, day);
         userGacha = await UserGachaModel.refreshFreeCount(roleId, gachaId, 0, ref);
     }
-    if(shouldRefresh(refHopeTime, new Date(), REFRESH_HOUR)) {
+    if(shouldRefresh(refHopeTime, new Date(), REFRESH_TIME)) {
         hope = hope.map(cur => { return { ...cur, hasGet: false}});
-        let ref = getTodayZeroDate(REFRESH_HOUR);
+        let ref = getZeroPointD();
         userGacha = await UserGachaModel.refreshHopeCount(roleId, gachaId, 0, hope, ref);
     }
     return userGacha
diff --git a/game-server/app/services/guildActivityObjService.ts b/game-server/app/services/guildActivityObjService.ts
index 359becf20..d21becf19 100644
--- a/game-server/app/services/guildActivityObjService.ts
+++ b/game-server/app/services/guildActivityObjService.ts
@@ -12,7 +12,7 @@ import { getGuildChannelSid } from "./chatService";
 import { pinus } from "pinus";
 import { getRandEelm, sortArrRandom, resResult } from "../pubUtils/util";
 import { Rank } from "./rankService";
-import { getNextHourPoint } from "../pubUtils/timeUtil";
+import { getTimeFun } from "../pubUtils/timeUtil";
 
 export class GateActivityObject {
     private gateHp: Map<string, number> = new Map(); // 城门血条，每个军团有一条血条 guildCode => hp
@@ -268,7 +268,8 @@ export class RaceActivityObject {
         if(woodenHorse.status == 1 || woodenHorse.status == 2) { // 更新距离  // TODO 写进const表
             let r = new Rank(REDIS_KEY.RACE_ACTIVITY, { serverId }, true, 5);
             await r.setRank({guildCode}, Math.floor(woodenHorse.distance * 1000), woodenHorse.time - woodenHorse.startTime, false);
-            await r.setExpire(getNextHourPoint(5));
+            let tomorrow = <number>getTimeFun().getAfterDayWithHour();
+            await r.setExpire(tomorrow);
             if (needSendEnd) { // 抵达后发送奖励，发送消息，结算
                 await sendSingleRaceActEndMsg(guildCode, woodenHorse);
             }
diff --git a/game-server/app/services/guildActivityService.ts b/game-server/app/services/guildActivityService.ts
index ca23b9771..cb4d3f641 100644
--- a/game-server/app/services/guildActivityService.ts
+++ b/game-server/app/services/guildActivityService.ts
@@ -3,7 +3,7 @@ import { RoleModel } from "../db/Role";
 import { reduceCe } from "../pubUtils/util";
 import { GUILDACTIVITY } from "../pubUtils/dicParam";
 import { gameData, getGuildAuctionRewards, getCityActivityRewards } from "../pubUtils/data";
-import { getCurHourPoint, getCurDay, nowSeconds } from "../pubUtils/timeUtil";
+import { getCurDay, nowSeconds, getTimeFun } from "../pubUtils/timeUtil";
 import { GUILD_ACTIVITY_STATUS, GET_POINT_WAYS, GUILD_ACTIVITY_TYPE, REDIS_KEY, AUCTION_SOURCE, MAIL_TYPE, CITY_STATUS } from "../consts";
 import { Record, UserGuildActivityRecModel } from "../db/UserGuildActivityRec";
 import { GateMembersRec, CityParam, Member, WoodenHorse } from "../domain/battleField/guildActivity";
@@ -92,8 +92,9 @@ export function getGuildActivityStatus(id: number) {
 }
 
 export function getGuildActivityByDic(dicGuildActivity: DicGuildActivity) {
-    let startTime = getCurHourPoint(dicGuildActivity.startTime, dicGuildActivity.startMinute, dicGuildActivity.startSeconds);
-    let countdownTime = getCurHourPoint(dicGuildActivity.countDown);
+    let t = getTimeFun();
+    let startTime = <number>t.getTimeWithHour(dicGuildActivity.startTime, dicGuildActivity.startMinute, dicGuildActivity.startSeconds);
+    let countdownTime = <number>t.getTimeWithHour(dicGuildActivity.countDown);
     let { duringTime, openDay } = dicGuildActivity;
     let endTime = startTime + duringTime;
 
diff --git a/game-server/app/services/guildBossService.ts b/game-server/app/services/guildBossService.ts
index 02293902e..8d3014a6b 100644
--- a/game-server/app/services/guildBossService.ts
+++ b/game-server/app/services/guildBossService.ts
@@ -1,5 +1,5 @@
 import { BossInstanceType, BossInstanceModel } from '../db/BossInstance';
-import { getTodayZeroPoint } from '../pubUtils/timeUtil';
+import { getZeroPoint } from '../pubUtils/timeUtil';
 import { lockData } from '../services/redLockService';
 import { findIndex } from 'underscore';
 import { MailModel, MailType } from '../db/Mail';
@@ -25,14 +25,14 @@ export async function getBossInstanceInfo(bossInstance: BossInstanceType, roleId
         return b.score - a.score + a.time - b.time;
     });
     let result:any = {};
-    if (!!winWarId && winTime > getTodayZeroPoint() && roleIdRecords.indexOf(roleId) == -1) {
+    if (!!winWarId && winTime > getZeroPoint() && roleIdRecords.indexOf(roleId) == -1) {
         //今日通关过，且首次点开boss界面，提示某某boss已通关
         result = { showParam: { winWarId, winBossLv } };
         await BossInstanceModel.recordRoleIdWhenCheck(guildCode, roleId);
     }
     if ( bossHp <= 0 ) { 
         result = { warId };
-        if (startTime < getTodayZeroPoint()) {
+        if (startTime < getZeroPoint()) {
             //今日未开启过boss，等待开启
             result.status = GUILD_BOSS_STATUS.WAIT_OPEN;
             return result;
@@ -47,7 +47,7 @@ export async function getBossInstanceInfo(bossInstance: BossInstanceType, roleId
     let lastRanks = ranks.map(({roleId: battleRoleId, score, time}, index) => {
         if (roleId == battleRoleId) {
             myRank = { roleId, score, rankLv: index + 1 };
-            if (time >= getTodayZeroPoint())
+            if (time >= getZeroPoint())
                 isBattled = true;
         }
         return {roleId, score, rankLv: index + 1};
@@ -80,7 +80,7 @@ export async function getBossInstanceWhenEnd(bossInstance: BossInstanceType, rol
     pushRanks.forEach(({roleId: battleRoleId, score, time}, index) => {
         if (roleId == battleRoleId) {
             myRank = {roleId, score, rankLv: index + 1};
-            if (time >= getTodayZeroPoint())
+            if (time >= getZeroPoint())
                 isBattled = true;
         }
         return {roleId, score, rankLv: index + 1};
diff --git a/game-server/app/services/guildService.ts b/game-server/app/services/guildService.ts
index 665b636fe..81889db20 100644
--- a/game-server/app/services/guildService.ts
+++ b/game-server/app/services/guildService.ts
@@ -119,7 +119,7 @@ export async function getGuildWithRefActive(guildCode: string, serverId: number)
     const now = new Date();
     let { activeDaily, refTimeDaily } = guild;
 
-    let isRefDaily = shouldRefresh(refTimeDaily, now, 0);
+    let isRefDaily = shouldRefresh(refTimeDaily, now);
     if (isRefDaily) {
         activeDaily = 0; refTimeDaily = now;
         guild = await GuildModel.updateInfoWithLeader(guildCode, { activeDaily, refTimeDaily }, {});
@@ -198,7 +198,7 @@ export async function getUserGuildWithRefActive(roleId: string, select: string,
     let { receivedActive, refTimeDaily, activeDaily, activeRecord, wishGoods } = userGuild;
 
     const now = new Date();
-    let isRefDaily = shouldRefresh(refTimeDaily, now, 0);
+    let isRefDaily = shouldRefresh(refTimeDaily, now);
     if (isRefDaily) {
         let mails = new Array<MailType>();
         let pushMessage = new Array<pushMail>();
diff --git a/game-server/app/services/guildTrainService.ts b/game-server/app/services/guildTrainService.ts
index c6939ea24..0f62d927f 100644
--- a/game-server/app/services/guildTrainService.ts
+++ b/game-server/app/services/guildTrainService.ts
@@ -1,7 +1,7 @@
 import { UserGuildModel } from '../db/UserGuild';
 import { getArmyTrainJuDian, getTrainBaseByLv } from '../pubUtils/data';
-import { nowSeconds, getHourPoint } from '../pubUtils/timeUtil';
-import { REFRESH_HOUR, GUILD_STRUCTURE } from '../consts/constModules/guildConst';
+import { nowSeconds, getZeroPoint } from '../pubUtils/timeUtil';
+import { GUILD_STRUCTURE } from '../consts';
 import { GuildTrainType, GuildTrainModel, TrainInstance } from '../db/GuildTrain';
 import { GuildModel } from '../db/Guild';
 import { findWhere } from 'underscore';
@@ -26,7 +26,7 @@ export async function getUserGuild(roleId: string, serverId: number) {
         return;
     let { trainCount, trainTime, buyTrainCount, guildCode} = userGuild;
     await resetTrain(guildCode, serverId);//检查重置练兵场
-    if (trainTime < getHourPoint(REFRESH_HOUR)) {//重置挑战次数和购买次数
+    if (trainTime < getZeroPoint()) {//重置挑战次数和购买次数
         trainCount = ARMY.ARMY_TRAIN_BUYTIMES;
         buyTrainCount = 0;
         userGuild = await UserGuildModel.updateInfo(roleId, {trainCount, trainTime: nowSeconds(), buyTrainCount}, {});
diff --git a/game-server/app/services/pvpService.ts b/game-server/app/services/pvpService.ts
index 99380bb3e..a356de73e 100644
--- a/game-server/app/services/pvpService.ts
+++ b/game-server/app/services/pvpService.ts
@@ -4,12 +4,12 @@ import { RoleType } from '../db/Role';
 import { PVP_HERO_POS, REDIS_KEY, PVP_CONST } from '../consts';
 import { setPvpDefResult } from '../services/timeTaskService';
 import { dicPvpOpponent, DicPvpOpponent } from "../pubUtils/dictionary/DicPvpOpponent";
-import { getRandSingleIndex, genCode, shouldRefresh, reduceCe, getChineseName } from '../pubUtils/util';
+import { getRandSingleIndex, genCode, shouldRefresh, getChineseName } from '../pubUtils/util';
 import { oppPlayersInter, pvpEndParamInter } from '../pubUtils/interface';
 import { gameData, getPLvByScore } from "../pubUtils/data";
 import { PVP } from '../pubUtils/dicParam';
 import { SystemConfigModel } from '../db/SystemConfig'
-import { nowSeconds, checkTodayTime } from '../pubUtils/timeUtil';
+import { nowSeconds, getTimeFun } from '../pubUtils/timeUtil';
 import { HeroesRecord } from '../db/PvpRecord';
 import { HeroModel } from '../db/Hero';
 import { MainAttrNumber, Attribute, CeAttrData, CeAttrDataRole } from '../domain/roleField/attribute';
@@ -405,7 +405,7 @@ export function refresh(challengeCnt: number, challengeRefTime: number, seasonEn
         return {challengeCnt, challengeRefTime};
     }
     let period = PVP.PVP_CHALLENGE_NORMALTIMES * 60;
-    if (checkTodayTime(seasonEndTime)) {
+    if (getTimeFun(seasonEndTime).checkDay()) {
         period = PVP.PVP_CHALLENGE_FINALTIMES * 60;
     }
     let time = nowSeconds();
@@ -452,7 +452,7 @@ export async function findPvpDefByRoleId(roleId: string) {
 // 获取刷新对手次数及消耗
 export function getRefOppCnt(refOppCnt: number, refOppTime: Date) {
     let curTime = new Date();
-    let shouldRefOpp = shouldRefresh(refOppTime, curTime, PVP_CONST.REFRESH_TIME);
+    let shouldRefOpp = shouldRefresh(refOppTime, curTime);
     if(shouldRefOpp) {
         refOppCnt = 0; refOppTime = curTime;
     }
diff --git a/game-server/app/services/refreshService.ts b/game-server/app/services/refreshService.ts
index 6ed34ecef..473cd4fc1 100644
--- a/game-server/app/services/refreshService.ts
+++ b/game-server/app/services/refreshService.ts
@@ -5,7 +5,6 @@ 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";
 
 /**
  * 刷新
@@ -37,14 +36,14 @@ export async function refreshDaily(session: FrontendOrBackendSession) {
     if(session.get('roleId')) {
         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)) {
+        if(!refDaily || shouldRefresh(new Date(refDaily * 1000), new Date())) {
             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)) {
+        if(!refWeekly || shouldRefreshWeek(new Date(refWeekly * 1000), new Date())) {
             refWeekly = nowSeconds();
             session.set('refWeekly', refWeekly);
             session.push('refWeekly', () => {});
diff --git a/game-server/app/services/taskService.ts b/game-server/app/services/taskService.ts
index adc2fd75d..37af237d9 100644
--- a/game-server/app/services/taskService.ts
+++ b/game-server/app/services/taskService.ts
@@ -2,7 +2,7 @@ import * as taskUtil from '../pubUtils/taskUtil';
 import { RoleType } from '../db/Role';
 import { pinus, FrontendOrBackendSession } from 'pinus';
 import { resResult, shouldRefresh } from '../pubUtils/util';
-import { STATUS, TASK_TYPE, TASK_FUN_TYPE } from '../consts';
+import { STATUS, TASK_TYPE, TASK_FUN_TYPE, SHOP_REFRESH_TYPE } from '../consts';
 import { TaskParam, TaskListReturn } from '../domain/roleField/task';
 import { HeroType } from '../db/Hero';
 import { EquipType } from '../db/Equip';
@@ -13,7 +13,7 @@ import { UserTaskModel, UserTaskType } from '../db/UserTask';
 import { UserTaskRecModel } from '../db/UserTaskRec';
 import { UserTaskHistoryModel } from '../db/UserTaskHistory';
 import { gameData, getGoodById } from '../pubUtils/data';
-import { getCurWeekDate, getSeconds } from '../pubUtils/timeUtil';
+import { getSeconds, getZeroPointD } from '../pubUtils/timeUtil';
 import { RoleStatus } from '../db/ComBattleTeam';
 
 export async function checkTaskWithRoles(roleId: string, sid: string, funcs: number[], taskType: number, roles: RoleType[]) {
@@ -125,14 +125,14 @@ export async function getCurTask(roleId: string, session: FrontendOrBackendSessi
     let userTask = await UserTaskModel.findByRole(roleId);
 
     let { dailyTaskRefWeekly, dailyTaskRef } = userTask;
-    let curWeekStart = getCurWeekDate(1, 5);
+    let curWeekStart = getZeroPointD(SHOP_REFRESH_TYPE.WEEKLY);
     if (dailyTaskRefWeekly < curWeekStart) { // 刷新周宝箱
         dailyTaskRefWeekly = curWeekStart;
     }
     session.set('refWeekly', getSeconds(dailyTaskRefWeekly));
     session.push('refWeekly', () => { });
 
-    if (shouldRefresh(dailyTaskRef, new Date(), 5)) {
+    if (shouldRefresh(dailyTaskRef, new Date())) {
         dailyTaskRef = new Date();
         userTask = await UserTaskModel.updateInfo(roleId, { dailyTaskRef });
         await removeHistoryTask(roleId, TASK_FUN_TYPE.DAILY);
@@ -168,7 +168,7 @@ export async function getMainTask(roleId: string, userTask: UserTaskType) {
 export async function getDailyTask(roleId: string, userTask: UserTaskType) {
     let type = TASK_FUN_TYPE.DAILY;
     let { dailyTaskPoint: point, dailyTaskRefWeekly, dailyTaskPointWeekly: weeklyPoint, dailyTaskBox: box } = userTask;
-    let curWeekStart = getCurWeekDate(1, 5);
+    let curWeekStart = getZeroPointD(SHOP_REFRESH_TYPE.WEEKLY);
     if (dailyTaskRefWeekly < curWeekStart) { // 刷新
         dailyTaskRefWeekly = curWeekStart;
         weeklyPoint = 0;
diff --git a/game-server/app/services/timeTaskService.ts b/game-server/app/services/timeTaskService.ts
index 99ffcb417..290c26f36 100644
--- a/game-server/app/services/timeTaskService.ts
+++ b/game-server/app/services/timeTaskService.ts
@@ -3,12 +3,12 @@ import { scheduleJob, Job  } from 'node-schedule';
 import { SystemConfigModel } from '../db/SystemConfig';
 import PvpDefenseType,{ PvpDefenseModel } from '../db/PvpDefense';
 import { PVP } from '../pubUtils/dicParam';
-import { nowSeconds, getTodayZeroPoint, getAge } from '../pubUtils/timeUtil';
+import { nowSeconds, getAge, getTimeFun } from '../pubUtils/timeUtil';
 import { getPvpGkWarIds, getPvpRankRewards, getPvpHeroRewards, getResultMaxRank, getTodayGuildActivity } from '../pubUtils/data';
 import { deepCopy, resResult, getRandSingleEelm } from '../pubUtils/util';
 import { getLvByScore } from './pvpService';
 import { getAllOnlineRoles, getAllServers, initSingleRank, delGuildActivityRank } from './redisService';
-import { MAIL_TYPE, REDIS_KEY, ADULT_AGE, GUEST_MAX_TIME, ADDICTION_PREVENTION_CODE, GUILD_ACTIVITY_STATUS, GUILD_ACTIVITY_TYPE, TASK_TYPE } from '../consts';
+import { MAIL_TYPE, REDIS_KEY, ADULT_AGE, GUEST_MAX_TIME, ADDICTION_PREVENTION_CODE, GUILD_ACTIVITY_STATUS, GUILD_ACTIVITY_TYPE, TASK_TYPE, TIME_OUTPUT_TYPE, REFRESH_TIME } from '../consts';
 import { RoleModel } from '../db/Role';
 import { MailModel, MailType } from '../db/Mail';
 import { pinus } from 'pinus';
@@ -48,12 +48,12 @@ export async function init() {
         console.log('create season seasonNum = '+ systemConfig?.seasonNum);
         let warIds = getPvpGkWarIds();
         let warId = warIds[0];
-        seasonEndTime = PVP.PVP_SEASON_DAYS * PER_DAY + getTodayZeroPoint();
+        seasonEndTime = <number>getTimeFun().getAfterDay(PVP.PVP_SEASON_DAYS);
         systemConfig = await SystemConfigModel.createSystemConfig( seasonEndTime, warId );
     } else {
         seasonEndTime = systemConfig.seasonEndTime;
         if (systemConfig.seasonEndTime - SETTLE_DIFF <= nowSeconds()) {//服务器启动时，检查当前时间是否大于实际结算的时间，若大于则重新开启定时任务，若小于则按照结束时间开启定时任务
-            seasonEndTime = PVP.PVP_SEASON_DAYS * PER_DAY + getTodayZeroPoint();
+            seasonEndTime = <number>getTimeFun().getAfterDay(PVP.PVP_SEASON_DAYS);
             console.log('update season seasonNum = '+ systemConfig.seasonNum);
             systemConfig.seasonNum++;//赛季值增加1
             await SystemConfigModel.updateSystemConfig({ seasonEndTime, seasonNum: systemConfig.seasonNum, oldSeasonEndTime: systemConfig.seasonEndTime});
@@ -241,7 +241,7 @@ async function setNextPvpTime(notSetNext: boolean) {
         return { seasonEndTime, seasonNum , oldSeasonEndTime: 0};
     }
     let oldSeasonEndTime = seasonEndTime;
-    seasonEndTime = (PVP.PVP_SEASON_DAYS + 1) * PER_DAY + getTodayZeroPoint();
+    seasonEndTime = <number>getTimeFun().getAfterDay(PVP.PVP_SEASON_DAYS + 1);
     await SystemConfigModel.updateSeason(seasonEndTime, oldSeasonEndTime);
     let settleTime = (seasonEndTime - SETTLE_DIFF)* PER_SECOND;
     seasonJobId = scheduleJob('setPvpSeasonResult', settleTime, setPvpSeasonSchdule);
@@ -273,10 +273,10 @@ export async function resetPvpSeasonTime(hour: number) {
     if (!systemConfig) {
         let warIds = getPvpGkWarIds();
         let warId = warIds[0];
-        seasonEndTime = hour * 60 * 60 + getTodayZeroPoint();
+        seasonEndTime = <number>getTimeFun().getTimeWithHour(REFRESH_TIME - hour);
         systemConfig = await SystemConfigModel.createSystemConfig( seasonEndTime, warId );
     } else {
-        seasonEndTime = hour * 60 * 60 + getTodayZeroPoint();
+        seasonEndTime = <number>getTimeFun().getTimeWithHour(REFRESH_TIME - hour);
         seasonNum = systemConfig.seasonNum + 1;
         await SystemConfigModel.updateSystemConfig({ seasonEndTime, seasonNum, oldSeasonEndTime: 0});
         await setPvpSeasonResult({name: 'simpleJobExample' + systemConfig.seasonNum, notSetNext: true });
diff --git a/game-server/app/services/warRewardService.ts b/game-server/app/services/warRewardService.ts
index 395846545..5739cc2b6 100644
--- a/game-server/app/services/warRewardService.ts
+++ b/game-server/app/services/warRewardService.ts
@@ -4,7 +4,7 @@
  */
 
 import { BattleDropModel } from '../db/BattleDrop';
-import { getRefTime, getRandEelmWithWeight, getRandSingleEelm } from '../pubUtils/util';
+import { getRandEelmWithWeight, getRandSingleEelm } from '../pubUtils/util';
 import { BATTLE_REWARD_TYPE, BLUEPRT_CONST } from '../consts';
 import { addItems } from './rewardService';
 import { BattleBlueprtDropModel } from '../db/BattleBlueprtDrop'
@@ -12,6 +12,7 @@ import { RoleModel } from '../db/Role';
 import { gameData } from '../pubUtils/data';
 import { DicWar } from '../pubUtils/dictionary/DicWar';
 import { RewardInter } from '../pubUtils/interface';
+import { getZeroPointD } from '../pubUtils/timeUtil';
 
 export class WarReward {
     private roleId: string;
@@ -117,7 +118,7 @@ export class WarReward {
     }
 
     private async handlerBlueprtReward(num: number) {
-        const refTime = getRefTime(new Date(), BLUEPRT_CONST.REFRESH_TIME);
+        const refTime = getZeroPointD();
         const battleBlueprtDrop = await BattleBlueprtDropModel.findByTime(this.roleId, refTime);
         if(battleBlueprtDrop) {
             let { getNum = 0, curCostAp = 0, getSum = 0, costAp = 0 } = battleBlueprtDrop;
diff --git a/game-server/test/timeUtils.test.ts b/game-server/test/timeUtils.test.ts
index dacf5783d..d54f7d1e2 100644
--- a/game-server/test/timeUtils.test.ts
+++ b/game-server/test/timeUtils.test.ts
@@ -1,6 +1,7 @@
 import 'mocha';
 import { expect } from 'chai';
-import { getNextTime } from '../app/pubUtils/timeUtil';
+import { getTimeFunD } from '../app/pubUtils/timeUtil';
+import { TIME_OUTPUT_TYPE } from '../app/consts';
 
 const millisecondsPerDay = 24 * 60 * 60 * 1000;
 
@@ -15,7 +16,7 @@ describe('测试时间工具方法', function () {
     const baseDate = new Date();
     const newHour = 9, newMin = 9, newSec = 9;
     baseDate.setHours(newHour - 1, 0, 0);
-    const newDate = getNextTime(baseDate, newHour, newMin, newSec);
+    const newDate = <Date>getTimeFunD(baseDate).getAfterDayWithHour(0, newHour, newMin, newSec);
     checkTime(newDate, newHour, newMin, newSec);
     expect(newDate.getDate()).to.be.equal(baseDate.getDate());
   });
@@ -24,7 +25,7 @@ describe('测试时间工具方法', function () {
     const baseDate = new Date();
     const newHour = 9, newMin = 9, newSec = 9;
     baseDate.setHours(newHour + 1, 0, 0);
-    const newDate = getNextTime(baseDate, newHour, newMin, newSec);
+    const newDate = <Date>getTimeFunD(baseDate).getAfterDayWithHour(0, newHour, newMin, newSec);
     checkTime(newDate, newHour, newMin, newSec);
     expect(newDate.getDate()).to.be.equal(new Date(baseDate.getTime() + millisecondsPerDay).getDate());
   });
diff --git a/shared/consts/constModules/guildConst.ts b/shared/consts/constModules/guildConst.ts
index 6e9eb8be8..51602604b 100644
--- a/shared/consts/constModules/guildConst.ts
+++ b/shared/consts/constModules/guildConst.ts
@@ -126,7 +126,6 @@ export enum GUILD_BOSS_STATUS {
 }
 
 export const GUILD_REPORT_NUM = 40;
-export const REFRESH_HOUR = 5;
 
 // 获得活跃值途径id
 export enum GUILD_POINT_WAYS {
diff --git a/shared/consts/constModules/sysConst.ts b/shared/consts/constModules/sysConst.ts
index 2e4ed3057..17a92fce1 100644
--- a/shared/consts/constModules/sysConst.ts
+++ b/shared/consts/constModules/sysConst.ts
@@ -17,6 +17,11 @@ export const GUEST_MAX_TIME = 60 * 60; // 游客体验时间
 export const GUEST_DAY = 15; // 同一设备15天内不得重复体验游客模式
 
 export const REFRESH_TIME = 5; // 统一一天刷新时间
+export enum TIME_OUTPUT_TYPE {
+    DATE = 1,
+    STAMP_10 = 2,
+    STAMP_13 = 3
+}
 
 export const COUNTER = {
     UID: { name: 'uid', def: 1 },
diff --git a/shared/db/DailyRecord.ts b/shared/db/DailyRecord.ts
index 34bcdd70d..2022ab479 100644
--- a/shared/db/DailyRecord.ts
+++ b/shared/db/DailyRecord.ts
@@ -1,6 +1,7 @@
 import BaseModel from './BaseModel';
 import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
 import { DAILY_CONST } from './../consts';
+import { getZeroPoint } from '../pubUtils/timeUtil';
 
 
 /**
@@ -28,8 +29,7 @@ export default class DailyRecord extends BaseModel {
   public static async refreshRecord(roleId: string, type: number, lean = true) {
     const dailyRecord: DailyRecordType = await DailyRecordModel.findOne({ roleId, type }).lean(lean);
     let {count = 0, refTime = 0, buyCount = 0} = dailyRecord||{};
-    let now = new Date();
-    let today = now.setHours(DAILY_CONST.REFRESH_TIME, 0, 0, 0);
+    let today = getZeroPoint();
 
     if(today > refTime) {
         refTime = today; count = 0; buyCount = 0;
diff --git a/shared/db/FriendPoint.ts b/shared/db/FriendPoint.ts
index 9e9b35db2..1e7806679 100644
--- a/shared/db/FriendPoint.ts
+++ b/shared/db/FriendPoint.ts
@@ -1,5 +1,6 @@
 import BaseModel from './BaseModel';
 import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
+import { getZeroPointD } from '../pubUtils/timeUtil';
 
 /**
   * 情谊点记录
@@ -29,14 +30,14 @@ export default class FriendPoint extends BaseModel {
      * @memberof FriendPoint
      */
     public static async updatePointToday(roleId: string, roleName: string, cntInc: number, maxPerDay: number, type: number, lean = true) {
-        const curTime = new Date((new Date()).setHours(0, 0, 0, 0));
+        const curTime = getZeroPointD();
         // 当 oldCnt + cntInc > maxPerDay 时需计算实际可以获得的点数：cntInc - (newCnt - maxPerDay)
         const rec: FriendPointType = await FriendPointModel.findOneAndUpdate({roleId, roleName, createdAt: {$gte: curTime}, cnt: {$lt: maxPerDay}, type}, {$inc: {cnt: cntInc, sendCnt: 0}}, {upsert: true, new: true}).lean(lean);
         return rec;
     }
 
     public static async updateSendCntToday(roleId: string, roleName: string, cntInc: number, maxPerDay: number, type: number, lean = true) {
-        const curTime = new Date((new Date()).setHours(0, 0, 0, 0));
+        const curTime = getZeroPointD();
         // 当 oldCnt + cntInc > maxPerDay 时需计算实际可以获得的点数：cntInc - (newCnt - maxPerDay)
         const rec: FriendPointType = await FriendPointModel.findOneAndUpdate({roleId, roleName, createdAt: {$gte: curTime}, sendCnt: {$lt: maxPerDay}, type}, {$inc: {sendCnt: cntInc, cnt: 0}}, {upsert: true, new: true}).lean(lean);
         return rec;
@@ -52,7 +53,7 @@ export default class FriendPoint extends BaseModel {
      * @memberof FriendPoint
      */
     public static async getFrdPointRecToday(roleId: string, type: number, lean = true) {
-        const curTime = new Date((new Date()).setHours(0, 0, 0, 0));
+        const curTime = getZeroPointD();
         const rec: FriendPointType = await FriendPointModel.findOne({roleId, createdAt: {$gte: curTime}, type}).lean(lean);
         return rec;
     }
diff --git a/shared/db/Guild.ts b/shared/db/Guild.ts
index 36a015bfd..61244e695 100644
--- a/shared/db/Guild.ts
+++ b/shared/db/Guild.ts
@@ -2,8 +2,8 @@ import BaseModel from './BaseModel';
 import { index, getModelForClass, prop, DocumentType, Ref } from '@typegoose/typegoose';
 import Role, { RoleType } from './Role';
 import { genCode } from '../pubUtils/util';
-import { GUILD_STRUCTURE, GUILD_STATUS, GUILD_PER_PAGE, GUILD_SELECT, REDIS_KEY } from '../consts';
-import { getCurWeekTime, nowSeconds } from '../pubUtils/timeUtil';
+import { GUILD_STRUCTURE, GUILD_STATUS, GUILD_PER_PAGE, GUILD_SELECT, REDIS_KEY, SHOP_REFRESH_TYPE } from '../consts';
+import { getZeroPoint, nowSeconds } from '../pubUtils/timeUtil';
 import { reduceCe } from '../pubUtils/util';
 
 class Structure {
@@ -229,7 +229,7 @@ export default class Guild extends BaseModel {
      * @param lean 
      */
     public static async resetGuildTrain(code: string, serverId: number, trainLv: number, lean = true) {
-        const time = getCurWeekTime(1, 5);//每周一，5点刷新
+        const time = getZeroPoint(SHOP_REFRESH_TYPE.WEEKLY);//每周一，5点刷新
         const result = await GuildModel.findOneAndUpdate({ code, status: GUILD_STATUS.RUNNING, serverId, resetTrainTime:{$ne:time}},{$set: {trainId: 1, resetTrainTime: time, trainLv}}, {new: true}).lean(lean);
         return result;
     }
diff --git a/shared/db/GuildActivityCity.ts b/shared/db/GuildActivityCity.ts
index 7f5059d9c..0108a4e58 100644
--- a/shared/db/GuildActivityCity.ts
+++ b/shared/db/GuildActivityCity.ts
@@ -1,6 +1,7 @@
 import BaseModel from './BaseModel';
 import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
-import { getCurWeekDate} from '../pubUtils/timeUtil';
+import { getZeroPointD } from '../pubUtils/timeUtil';
+import { SHOP_REFRESH_TYPE } from '../consts';
 
 @index({ serverId: 1, cityId: 1, createdAt: 1   })
 export default class GuildActivityCity extends BaseModel {
@@ -28,14 +29,14 @@ export default class GuildActivityCity extends BaseModel {
 
     // 每天宣战一次
     public static async getAllCities(serverId: number) {
-        let curWeek = getCurWeekDate(1, 0);
+        let curWeek = getZeroPointD(SHOP_REFRESH_TYPE.WEEKLY);
         let rec: GuildActivityCityType[] = await GuildActivityCityModel.find({ serverId, createdAt: { $gte: curWeek }}).lean();
         
         return rec;
     }
 
     public static async getCity(serverId: number, cityId: number) {
-        let curWeek = getCurWeekDate(1, 0);
+        let curWeek = getZeroPointD(SHOP_REFRESH_TYPE.WEEKLY);
         let rec: GuildActivityCityType = await GuildActivityCityModel.findOne({ serverId, cityId, createdAt: { $gte: curWeek }}).lean();
         
         return rec;
@@ -43,7 +44,7 @@ export default class GuildActivityCity extends BaseModel {
 
     // 检查是否宣战过
     public static async checkDeclartion(serverId: number, guildCode: string) {
-        let curWeek = getCurWeekDate(1, 0);
+        let curWeek = getZeroPointD(SHOP_REFRESH_TYPE.WEEKLY);
         let rec: GuildActivityCityType = await GuildActivityCityModel.findOne(
             { serverId, createdAt: { $gte: curWeek }, declareGuilds: { $in: [guildCode]}}).lean();
 
@@ -52,7 +53,7 @@ export default class GuildActivityCity extends BaseModel {
 
     // 宣言
     public static async declare(serverId: number, cityId: number, guildCode: string) {
-        let curWeek = getCurWeekDate(1, 0);
+        let curWeek = getZeroPointD(SHOP_REFRESH_TYPE.WEEKLY);
         let rec: GuildActivityCityType = await GuildActivityCityModel.findOneAndUpdate(
             { serverId, cityId, createdAt: { $gte: curWeek } }, 
             { $setOnInsert: { serverId, cityId }, $push: { declareGuilds: guildCode }, $inc: {declareCount: 1 } }, 
@@ -63,7 +64,7 @@ export default class GuildActivityCity extends BaseModel {
 
     // 占领
     public static async guard(serverId: number, cityId: number, guildCode: string, guildName: string) {
-        let curWeek = getCurWeekDate(1, 0);
+        let curWeek = getZeroPointD(SHOP_REFRESH_TYPE.WEEKLY);
         let rec: GuildActivityCityType = await GuildActivityCityModel.findOneAndUpdate(
             { serverId, cityId, createdAt: { $gte: curWeek } }, 
             { $set: { guardGuildCode: guildCode, guardGuildName: guildName, guardTime: new Date()} }, 
@@ -74,7 +75,7 @@ export default class GuildActivityCity extends BaseModel {
 
     // 活动结束后需要清空占领情况
     public static async clearGuard(serverId: number, cityId: number) {
-        let curWeek = getCurWeekDate(1, 0);
+        let curWeek = getZeroPointD(SHOP_REFRESH_TYPE.WEEKLY);
         let rec: GuildActivityCityType = await GuildActivityCityModel.findOneAndUpdate(
             { serverId, cityId, createdAt: { $gte: curWeek } }, 
             { $set: { guardGuildCode: "", guardGuildName: "", declareCount: 0, declareGuilds: [] } }, 
diff --git a/shared/db/GuildActivityRec.ts b/shared/db/GuildActivityRec.ts
index e5295fb1b..81b47c90a 100644
--- a/shared/db/GuildActivityRec.ts
+++ b/shared/db/GuildActivityRec.ts
@@ -1,7 +1,7 @@
 import BaseModel from './BaseModel';
 import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
 import { ItemReward } from '../domain/dbGeneral';
-import { getTodayZeroDate } from '../pubUtils/timeUtil';
+import { getZeroPointD } from '../pubUtils/timeUtil';
 import { genCode } from '../pubUtils/util';
 import { Member, WoodenHorse, Event } from '../domain/battleField/guildActivity'
 
@@ -63,7 +63,7 @@ export default class GuildActivityRecord extends BaseModel {
     
     // 每天一条记录
     public static async getRecord(guildCode: string, serverId: number, aid: number, events?: Event[]) {
-        let today = getTodayZeroDate();
+        let today = getZeroPointD();
         let docs = new GuildActivityRecordModel();
         let code = genCode(10);
         let update = Object.assign(docs, { code, guildCode, serverId, aid, createdAt: new Date() });
@@ -76,7 +76,7 @@ export default class GuildActivityRecord extends BaseModel {
     }
     
     public static async updateInfo(guildCode: string, update: GuildActivityRecordUpdateParam) {
-        let today = getTodayZeroDate();
+        let today = getZeroPointD();
 
         let rec: GuildActivityRecordType = await GuildActivityRecordModel.findOneAndUpdate(
             { guildCode, createdAt: { $gte: today } }, 
@@ -86,7 +86,7 @@ export default class GuildActivityRecord extends BaseModel {
 
 
     public static async pushEvent(guildCode: string, event: Event) {
-        let today = getTodayZeroDate();
+        let today = getZeroPointD();
 
         let rec: GuildActivityRecordType = await GuildActivityRecordModel.findOneAndUpdate(
             { guildCode, createdAt: { $gte: today } }, 
diff --git a/shared/db/PvpRecord.ts b/shared/db/PvpRecord.ts
index c0ecf8ee8..9d8a1d48c 100644
--- a/shared/db/PvpRecord.ts
+++ b/shared/db/PvpRecord.ts
@@ -1,6 +1,6 @@
 import BaseModel from './BaseModel';
 import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
-import { getBeforeDayDate } from '../pubUtils/timeUtil';
+import { getTimeFun } from '../pubUtils/timeUtil';
 import { genCode } from '../pubUtils/util';
 import { PvpHeroInfo } from '../domain/dbGeneral';
 import { EXTERIOR } from '../pubUtils/dicParam';
@@ -96,7 +96,8 @@ export default class PvpRecord extends BaseModel {
     }
 
     public static async delPvpRecords() {
-        let result = await PvpRecordModel.deleteMany({ createTime: {$lt: getBeforeDayDate(3)}});//删除小于三天的战报
+        let t = <number>getTimeFun().getBeforeDayWithHour(3);
+        let result = await PvpRecordModel.deleteMany({ createTime: {$lt: t}});//删除小于三天的战报
         return result;
     }
 }
diff --git a/shared/db/Role.ts b/shared/db/Role.ts
index 89f08152c..dfda633e3 100644
--- a/shared/db/Role.ts
+++ b/shared/db/Role.ts
@@ -1,10 +1,10 @@
-import { HANG_UP_CONSTS, ROLE_TERAPH, ROLE_SELECT, ABI_TYPE } from './../consts';
+import { HANG_UP_CONSTS, ROLE_TERAPH, ROLE_SELECT, ABI_TYPE, TIME_OUTPUT_TYPE } from './../consts';
 import BaseModel from './BaseModel';
 import { index, getModelForClass, prop, DocumentType, Ref, mongoose } from '@typegoose/typegoose';
 import User from './User';
 import { shouldRefresh, reduceCe } from '../pubUtils/util';
 import { initRoleAtrr } from '../pubUtils/playerCe';
-import { nowSeconds, getBeforeDayDate } from '../pubUtils/timeUtil';
+import { nowSeconds, getTimeFunD } from '../pubUtils/timeUtil';
 import { Figure } from '../domain/dbGeneral';
 import { EXTERIOR } from '../pubUtils/dicParam';
 import Hero from './Hero';
@@ -360,7 +360,7 @@ export default class Role extends BaseModel {
         const result = await RoleModel.findOne({ roleId }).lean(lean);
         const lastSpdUpTime = result?.lastSpdUpTime;
         let role: RoleType;
-        if (!lastSpdUpTime || (shouldRefresh(lastSpdUpTime, curTime, HANG_UP_CONSTS.REFRESH_TIME, 1) && cnt <= HANG_UP_CONSTS.MAX_SPD_UP_CNT)) {
+        if (!lastSpdUpTime || (shouldRefresh(lastSpdUpTime, curTime) && cnt <= HANG_UP_CONSTS.MAX_SPD_UP_CNT)) {
             role = await RoleModel.findOneAndUpdate({ roleId }, { hangUpSpdUpCnt: HANG_UP_CONSTS.MAX_SPD_UP_CNT - cnt, lastSpdUpTime: curTime }, { new: true }).lean(lean);
         } else {
             role = await RoleModel.findOneAndUpdate({ roleId, hangUpSpdUpCnt: { $gte: cnt } }, { $inc: { hangUpSpdUpCnt: -cnt }, lastSpdUpTime: curTime }, { new: true }).lean(lean);
@@ -634,8 +634,8 @@ export default class Role extends BaseModel {
 
     // 获取战力在中位数的玩家
     public static async getMedianRole(serverId: number) {
-        let yesterday = getBeforeDayDate(1);
-        const roles: RoleType[] = await RoleModel.find({ serverId, updatedAt: { $gte: new Date(yesterday) } })
+        let yesterday = <Date>getTimeFunD().getBeforeDayWithHour(1);
+        const roles: RoleType[] = await RoleModel.find({ serverId, updatedAt: { $gte: yesterday } })
             .select('topLineup')
             .sort({ ce: -1 }).lean();
         return roles[Math.floor(roles.length / 2)]
diff --git a/shared/db/UserGacha.ts b/shared/db/UserGacha.ts
index d9ef81359..5cd7eed04 100644
--- a/shared/db/UserGacha.ts
+++ b/shared/db/UserGacha.ts
@@ -1,7 +1,6 @@
 import BaseModel from './BaseModel';
 import { index, getModelForClass, prop, DocumentType, modelOptions } from '@typegoose/typegoose';
-import { getTodayZeroDate } from '../pubUtils/timeUtil';
-import { REFRESH_HOUR } from '../consts';
+import { getZeroPointD } from '../pubUtils/timeUtil';
 import { RECRUIT } from '../pubUtils/dicParam';
 
 class Floor {
@@ -61,13 +60,13 @@ export default class UserGacha extends BaseModel {
     @prop({ required: true, default: 0 })
     freeCount: number;		    // 免费次数
 
-    @prop({ required: true, default: () => { return getTodayZeroDate(REFRESH_HOUR) } })
+    @prop({ required: true, default: getZeroPointD })
     refFreeTime: Date;		    // 免费次数刷新时间
 
     @prop({ required: true, type: () => Hope, default: [], _id: false })
     hope: Hope[];             // 心愿单
 
-    @prop({ required: true, default: () => { return getTodayZeroDate(REFRESH_HOUR) } })
+    @prop({ required: true, default: getZeroPointD })
     refHopeTime: Date;		    // 心愿单刷新时间
 
     @prop({ required: true, default: 0 })
@@ -87,7 +86,7 @@ export default class UserGacha extends BaseModel {
     @prop({ required: true, default: [], type: Number })
     visitedHero: number[];            // 玩家指定武将
 
-    @prop({ required: true, default: () => { return getTodayZeroDate(REFRESH_HOUR) }  })
+    @prop({ required: true, default: getZeroPointD  })
     refVisitedTime: Date;            // 玩家指定武将
 
     public static async findAllByRole(roleId: string) {
diff --git a/shared/db/UserGuild.ts b/shared/db/UserGuild.ts
index 210b55a85..babe8af25 100644
--- a/shared/db/UserGuild.ts
+++ b/shared/db/UserGuild.ts
@@ -2,7 +2,7 @@ import BaseModel from './BaseModel';
 import { index, getModelForClass, prop, DocumentType, Ref } from '@typegoose/typegoose';
 import Role, { RoleType } from './Role';
 import { GUILD_AUTH, USER_GUILD_STATUS, GUILD_JOB } from '../consts';
-import { getTodayZeroDate, nowSeconds } from '../pubUtils/timeUtil';
+import { getZeroPointD, nowSeconds } from '../pubUtils/timeUtil';
 import { ARMY } from '../pubUtils/dicParam';
 class ActiveRecord {
     @prop({ required: true })
@@ -187,7 +187,7 @@ export default class UserGuild extends BaseModel {
     }
 
     public static async getWishPoolGoods(guildCode: string, select?: string, lean = true) {
-        const userGuilds: UserGuildType[] = await UserGuildModel.find({ guildCode, status: USER_GUILD_STATUS.ON, refTimeDaily: { $gte: getTodayZeroDate() } })
+        const userGuilds: UserGuildType[] = await UserGuildModel.find({ guildCode, status: USER_GUILD_STATUS.ON, refTimeDaily: { $gte: getZeroPointD() } })
         .select(select).lean(lean);
         return userGuilds;
     }
diff --git a/shared/db/UserGuildActivityRec.ts b/shared/db/UserGuildActivityRec.ts
index f95ac8497..8ff983237 100644
--- a/shared/db/UserGuildActivityRec.ts
+++ b/shared/db/UserGuildActivityRec.ts
@@ -1,6 +1,6 @@
 import BaseModel from './BaseModel';
 import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
-import { getTodayZeroDate } from '../pubUtils/timeUtil';
+import { getZeroPointD } from '../pubUtils/timeUtil';
 import { genCode } from '../pubUtils/util';
 
 export class Record {
@@ -89,7 +89,7 @@ export default class UserGuildActivityRec extends BaseModel {
 
     // 每天一条记录
     public static async getRecord(roleId: string, roleName: string, guildCode: string, serverId: number, sourceCode: string, aid: number) {
-        let today = getTodayZeroDate();
+        let today = getZeroPointD();
         let docs = new UserGuildActivityRecModel();
         let code = genCode(10);
         let update = Object.assign(docs, { code, roleId, roleName, guildCode, serverId, aid });
@@ -104,7 +104,7 @@ export default class UserGuildActivityRec extends BaseModel {
 
 
     public static async findByRoleId(roleId: string, aid: number) {
-        let today = getTodayZeroDate();
+        let today = getZeroPointD();
         let rec: UserGuildActivityRecType = await UserGuildActivityRecModel.findOne({ roleId, aid, createdAt: { $gte: today }}).lean();
 
         return rec;
@@ -139,7 +139,7 @@ export default class UserGuildActivityRec extends BaseModel {
     }
 
     public static async updateInfoByRoleId(roleId: string, update: UserGuildActivityRecUpdateParam) {
-        let today = getTodayZeroDate();
+        let today = getZeroPointD();
         let rec: UserGuildActivityRecType = await UserGuildActivityRecModel.findOneAndUpdate(
             { roleId, createdAt: { $gte: today } }, { $set: update }, { new: true }).lean();
         return rec;
diff --git a/shared/db/UserShop.ts b/shared/db/UserShop.ts
index efa9e50dd..4f861b8f4 100644
--- a/shared/db/UserShop.ts
+++ b/shared/db/UserShop.ts
@@ -1,7 +1,7 @@
 import BaseModel from './BaseModel';
 import { index, getModelForClass, prop, DocumentType, modelOptions } from '@typegoose/typegoose';
 import { genCode } from '../pubUtils/util';
-import { getCurWeekDate, getCurMonthDate, getTodayZeroDate } from '../pubUtils/timeUtil';
+import { getZeroPointD } from '../pubUtils/timeUtil';
 import { SHOP_REFRESH_TYPE } from '../consts';
 import { DicShop } from '../pubUtils/dictionary/DicShop';
 
@@ -37,9 +37,9 @@ export default class UserShop extends BaseModel {
     count: number; 		        	// 数量
 
     private static getRefreshCondition() {
-        let today = getTodayZeroDate(5);
-        let cutWeek = getCurWeekDate(1, 5);
-        let curMonth = getCurMonthDate(1, 5);
+        let today = getZeroPointD();
+        let cutWeek = getZeroPointD(SHOP_REFRESH_TYPE.WEEKLY);
+        let curMonth = getZeroPointD(SHOP_REFRESH_TYPE.MONTHLY);
 
         return [
             { createdAt: { $gte: today }, refreshType: SHOP_REFRESH_TYPE.DAILY },
diff --git a/shared/db/UserTask.ts b/shared/db/UserTask.ts
index 55e953b69..f71dceecb 100644
--- a/shared/db/UserTask.ts
+++ b/shared/db/UserTask.ts
@@ -1,6 +1,7 @@
 import BaseModel from './BaseModel';
 import { index, getModelForClass, prop, DocumentType, modelOptions } from '@typegoose/typegoose';
-import { getCurWeekDate } from '../pubUtils/timeUtil';
+import { getZeroPointD } from '../pubUtils/timeUtil';
+import { SHOP_REFRESH_TYPE } from '../consts';
 
 /**
   * 玩家购买商店记录表，每个商品一条，每次刷新新建一条
@@ -39,7 +40,7 @@ export default class UserTask extends BaseModel {
 
     
     public static async findByRole(roleId: string) {
-      let curWeek = getCurWeekDate(1, 5);
+      let curWeek = getZeroPointD(SHOP_REFRESH_TYPE.WEEKLY);
       let rec: UserTaskType = await UserTaskModel.findOneAndUpdate({ roleId }, { $setOnInsert: {
         mainTaskStage: 1, dailyTaskPoint: 0, dailyTaskRefWeekly: curWeek, dailyTaskPointWeekly: 0, dailyTaskBox: [], achievementPoint: 0, achievementBox: []
       } }, { new: true, upsert: true }).lean();
@@ -86,7 +87,7 @@ export default class UserTask extends BaseModel {
     }
 
     public static async refreshWeekly(roleId: string, debug = false) {
-      let curWeek = getCurWeekDate(1, 5);
+      let curWeek = getZeroPointD(SHOP_REFRESH_TYPE.WEEKLY);
       let condition = { roleId };
       if(!debug) {
         condition['dailyTaskRefWeekly'] = { $lt: curWeek }
diff --git a/shared/db/UserTaskRec.ts b/shared/db/UserTaskRec.ts
index 0e75d576b..8cd6bbf3b 100644
--- a/shared/db/UserTaskRec.ts
+++ b/shared/db/UserTaskRec.ts
@@ -2,7 +2,7 @@ import BaseModel from './BaseModel';
 import { index, getModelForClass, prop, DocumentType, modelOptions } from '@typegoose/typegoose';
 import { TASK_FUN_TYPE } from '../consts';
 import { genCode } from '../pubUtils/util';
-import { getTodayZeroDate } from '../pubUtils/timeUtil';
+import { getZeroPointD } from '../pubUtils/timeUtil';
 
 /**
   * 玩家任务记录表
@@ -34,7 +34,7 @@ export default class UserTaskRec extends BaseModel {
     received: number[];  	    	// 是否已领取
 
     private static getRefreshCondition(type: number) {
-        let today = getTodayZeroDate(5);
+        let today = getZeroPointD();
 
         if(type == TASK_FUN_TYPE.DAILY) {
             return { type, createdAt: { $gte: today } };
@@ -100,7 +100,7 @@ export default class UserTaskRec extends BaseModel {
     }
 
     public static async getHistoryRec(roleId: string, type: number, today?: Date) {
-        if(!today) today = getTodayZeroDate(5);
+        if(!today) today = getZeroPointD();
         let rec: UserTaskRecType[] = await UserTaskRecModel.find({ roleId, type, createdAt: { $lt: today } }).lean();
         return rec
     }
diff --git a/shared/db/WishPoolReport.ts b/shared/db/WishPoolReport.ts
index 15f665c71..2a701adfa 100644
--- a/shared/db/WishPoolReport.ts
+++ b/shared/db/WishPoolReport.ts
@@ -1,6 +1,6 @@
 import BaseModel from './BaseModel';
 import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
-import { nowSeconds, getTodayZeroPoint } from '../pubUtils/timeUtil';
+import { nowSeconds, getTimeFun } from '../pubUtils/timeUtil';
 
 @index({ guildCode: 1 })
 
@@ -37,7 +37,7 @@ export default class WishPoolReport extends BaseModel {
     }
     //获得day天之前的许愿池战报
     public static async getReportsByTime(guildCode: string, day: number) {
-        let time = getTodayZeroPoint() - day * 24 * 60;
+        let time = <number>getTimeFun().getBeforeDayWithHour(day);
         const reports = await WishPoolReportModel.find({ guildCode,  dntTime: {$gte: time}}).sort({ dntTime : -1 });
         return reports;
     }
diff --git a/shared/domain/activityField/gachaField.ts b/shared/domain/activityField/gachaField.ts
index 6e485607f..36ef02d8e 100644
--- a/shared/domain/activityField/gachaField.ts
+++ b/shared/domain/activityField/gachaField.ts
@@ -2,7 +2,7 @@ import { ActivityModelType } from '../../db/Activity';
 import { ActivityBase } from './activityField';
 import { prop } from '@typegoose/typegoose';
 import { UserGachaType } from '../../db/UserGacha';
-import { getAfterDateByDay } from '../../pubUtils/timeUtil';
+import { getTimeFun } from '../../pubUtils/timeUtil';
 import { DicGacha } from '../../pubUtils/dictionary/DicGacha';
 import { GACHA_OCCUPY_HID } from '../../consts';
 import { gameData } from '../../pubUtils/data';
@@ -31,7 +31,8 @@ export class GachaData extends ActivityBase {
         this.pickHero = userGacha.pickHero;
         this.freeCount = userGacha.freeCount;
         if(dicGacha.free.count > 0) {
-            this.refFreeTime = getAfterDateByDay(userGacha.refFreeTime, dicGacha.free.day);
+            let f = getTimeFun(userGacha.refFreeTime);
+            this.refFreeTime = <number>f.getAfterDayWithHour(dicGacha.free.day);
         }
         this.count = userGacha.count;
         this.floor = userGacha.floor;
@@ -97,7 +98,8 @@ export class GachaListReturn {
         if(userGacha) {
             this.freeCount = userGacha.freeCount;
             if(dicGacha.free.count > 0) {
-                this.refFreeTime = getAfterDateByDay(userGacha.refFreeTime, dicGacha.free.day);
+                let f = getTimeFun(userGacha.refFreeTime);
+                this.refFreeTime = <number>f.getAfterDayWithHour(dicGacha.free.day);
             }
             this.count = userGacha.count;
             this.floor = getFloorStatus(dicGacha.id, userGacha.floor);
diff --git a/shared/pubUtils/itemUtils.ts b/shared/pubUtils/itemUtils.ts
index 849afd6e3..5b1e8c680 100644
--- a/shared/pubUtils/itemUtils.ts
+++ b/shared/pubUtils/itemUtils.ts
@@ -11,7 +11,7 @@ import { getRandValueByMinMax, getRandEelm } from './util';
 import { findWhere } from 'underscore';
 import { RoleModel, RoleType } from '../db/Role';
 import { Figure } from '../domain/dbGeneral';
-import { getBeforeDaySeconds, nowSeconds } from './timeUtil';
+import { getTimeFun, nowSeconds } from './timeUtil';
 import { calPlayerCeAndSave, reCalAllHeroCe } from './playerCe';
 import { checkTask, checkTaskWithHeroes, checkTaskWithEquip, accomplishTask } from './taskUtil';
 import { CreateHeroParam } from '../domain/roleField/hero';
@@ -223,7 +223,7 @@ function unlockSingleFigure(dbFigures: Figure[], id: number, unlockDirect = fals
         delete figure.unlockedId;
 
         if (dicGoods.timeLimit) {
-            figure.time = getBeforeDaySeconds(-1 * dicGoods.timeLimit); // timeLimit天以后 
+            figure.time = <number>getTimeFun().getAfterDay(dicGoods.timeLimit); // timeLimit天以后 
         }
     }
 
diff --git a/shared/pubUtils/taskUtil.ts b/shared/pubUtils/taskUtil.ts
index 7f8b3c0bc..9420d0dc2 100644
--- a/shared/pubUtils/taskUtil.ts
+++ b/shared/pubUtils/taskUtil.ts
@@ -4,7 +4,7 @@ import { TASK_TYPE, ABI_STAGE, WAR_TYPE, GUILD_JOB, TASK_FUN_TYPE, FUNCS_ID } fr
 import { UserTaskRecModel, UserTaskRecType } from '../db/UserTaskRec'
 import { RoleType, RoleModel } from '../db/Role';
 import { TaskParam, TaskListReturn } from '../domain/roleField/task';
-import { getTodayZeroPoint } from './timeUtil';
+import { getZeroPoint } from './timeUtil';
 import { HeroType } from '../db/Hero';
 import { EquipType, EquipModel } from '../db/Equip';
 import { ItemInter } from './interface';
@@ -35,7 +35,7 @@ export async function checkTaskWithRole(roleId: string, taskType: number, role:
     let pushMessage = new Array<TaskListReturn>();
 
     if (taskType == TASK_TYPE.LOGIN_SUM) {
-        let today = getTodayZeroPoint();
+        let today = getZeroPoint();
         if (today > role.loginTime) {
             pushMessage = await checkTask(roleId, taskType, 1, true, {}, funcs);
             //成长任务-累计登录游戏天数
@@ -43,7 +43,7 @@ export async function checkTaskWithRole(roleId: string, taskType: number, role:
         }
     }
     else if (taskType == TASK_TYPE.LOGIN_SERIES) {
-        let today = getTodayZeroPoint();
+        let today = getZeroPoint();
         if (today > role.loginTime) {
             if (today - role.loginTime > 24 * 60 * 60) {
                 pushMessage = await checkTask(roleId, taskType, 1, false, {}, funcs);
diff --git a/shared/pubUtils/timeUtil.ts b/shared/pubUtils/timeUtil.ts
index 826741045..546473798 100644
--- a/shared/pubUtils/timeUtil.ts
+++ b/shared/pubUtils/timeUtil.ts
@@ -1,172 +1,473 @@
-import { TIME_FORMAT, REFRESH_TIME, REFRESH_HOUR } from '../consts';
+import { TIME_FORMAT, REFRESH_TIME, TIME_OUTPUT_TYPE, SHOP_REFRESH_TYPE } from '../consts';
 
-const PER_SECOND = 1 * 1000;
-const PER_DAY = 24 * 60 * 60;
-const PER_MINUTE = 60;
-const PER_HOUR = 60 * 60;
+/**
+ * 时间
+ * @class
+ */
+class Time {
+    WEEK_TO_MS = 7 * 24 * 60 * 60 * 1000;
+    DAY_TO_HOUR = 24;
+    DAY_TO_SECOND = 24 * 60 * 60;
+    DAY_TO_MS = 24 * 60 * 60 * 1000;
+    HOUR_TO_MINUTE = 60;
+    HOUR_TO_SECOND = 60 * 60;
+    HOUR_TO_MS = 60 * 60 * 1000;
+    MINUTE_TO_MS = 60 * 1000;
+    SECOND_TO_MS = 1000;
 
+    now: Date;              // 当前时间
+    time: Date;             // 处理时间原料
+    outputType: number;     // 输出格式
+
+    /**
+     * 
+     * @param {number} outputType 输出格式 1-Date 2-10位时间戳 3-13位时间戳
+     * @param {Date|number} time 传入的时间，如果不传默认为现在，可以传Date或10位或13位时间戳
+     */
+    constructor(outputType: TIME_OUTPUT_TYPE, time?: Date|number) {
+        this.outputType = outputType;
+        this.now = new Date();
+        if(time) {
+            if(typeof time == 'number') {
+                if(time.toString().length == 10) {
+                    this.time = new Date(time * 1000);
+                } else {
+                    this.time = new Date(time);
+                }
+            } else if (time instanceof Date) {
+                this.time = time;
+            }
+        } else {
+            this.time = new Date();
+        }
+    }
+
+    /**
+     * @description 将得出的时间按输出格式转换
+     * @param time {Date|number} 时间结果
+     */
+    private _returnResult(time: Date| number) {
+        if(this.outputType == 1) {
+            if(typeof time == 'number') {
+                if(time.toString().length == 10) {
+                    return new Date(time * 1000);
+                } else if (time.toString().length == 13) {
+                    return new Date(time);
+                }
+            } else if (time instanceof Date) {
+                return time;
+            }
+        } else if (this.outputType == 2) {
+            if(typeof time == 'number') {
+                if(time.toString().length == 10) {
+                    return time;
+                } else if (time.toString().length == 13) {
+                    return Math.floor(time / 1000);
+                }
+            } else if (time instanceof Date) {
+                return Math.floor(time.getTime() / 1000);
+            }
+        } else if (this.outputType == 3) {
+            if(typeof time == 'number') {
+                if(time.toString().length == 10) {
+                    return time * 1000;
+                } else if (time.toString().length == 13) {
+                    return time;
+                }
+            } else if (time instanceof Date) {
+                return time.getTime();
+            }
+        }
+    }
+
+    /**
+     * @description 设置时间
+     * @param time 设置的时间
+     * @param hour 几点
+     * @param minute 几分
+     * @param seconds 几秒
+     */
+    private _setHour(time: Date, hour: number, minute = 0, seconds = 0) {
+        let t = new Date(time);
+        t.setHours(hour, minute, seconds);
+        return t;
+    }
+
+    /**
+     * @description 获得一天的刷新时间，如果是5点刷新，4点进入的话算前一天
+     * @param time 设置的时间
+     * @param hour 几点
+     * @param minute 几分
+     * @param seconds 几秒
+     */
+    private _getDayZeroPoint(time: Date, hour = REFRESH_TIME, minute = 0, seconds = 0) {
+        let t = this._setHour(time, hour, minute, seconds);
+        if(this.now > t) {
+            return t;
+        } else {
+            return new Date(t.getTime() - this.DAY_TO_MS);
+        }
+    }
+
+    /**
+     * 获取一周的某个时间
+     * @param time 设置的时间
+     * @param day 周几 周日为0
+     * @param hour 几点，默认为刷新时间
+     * @param minute 几分
+     * @param seconds 几秒
+     */
+    private _getTimeWithWeek(time: Date, day: number, hour = REFRESH_TIME, minute = 0, seconds = 0) {
+        let dayOfWeek = time.getDay();
+        if(dayOfWeek == 0) dayOfWeek = 7;
+    
+        let d = time.getDate();
+        let y = time.getFullYear(); //当前年
+        let m = time.getMonth(); //月
+        let t = new Date(y, m, d - dayOfWeek + day, hour, minute, seconds);
+        return t;
+    }
+
+    /**
+     * @description 获取一月的某个时间
+     * @param time 设置的时间
+     * @param day 几号
+     * @param hour 几点，默认为刷新时间
+     * @param minute 几分
+     * @param seconds 几秒
+     */
+    private _getTimeWithMonth(time: Date, day: number, hour = REFRESH_TIME, minute = 0, seconds = 0) {
+        let y = time.getFullYear(); //当前年
+        let m = time.getMonth(); //月
+        let t = new Date(y, m, day, hour, minute, seconds);
+        return t;
+    }
+
+    /**
+     * @description 计算某个月有几天
+     * @param year 年份
+     * @param month 月份，0-11，1月为0
+     */
+    private _countDaysInYearMonth(year: number, month: number){
+        var date = new Date(year, month, 0);
+        return date.getDate();
+    }
+
+    /**
+     * @description 获取几个月前的某一天
+     * @param time 设置的时间
+     * @param month 几个月前
+     * @param day 几号
+     * @param hour 几点，默认为刷新时间
+     * @param minute 几分
+     * @param seconds 几秒
+     */
+    private _getBeforeMonthWithDay(time: Date, month: number, day: number, hour = REFRESH_TIME, minute = 0, seconds = 0) {
+        let y = time.getFullYear(); //当前年
+        let m = time.getMonth(); //月
+        if(m - month < 0) {
+            m = m - month + 12;
+            y --;
+        } else {
+            m -= month;
+        }
+        let days = this._countDaysInYearMonth(y, m);
+        if(day > days) day = days;
+        let t = new Date(y, m, day, hour, minute, seconds);
+        return t;
+    }
+
+    /**
+     * @description 获取两个日期之间差几天
+     * @param preDate 前一天
+     * @param curDate 后一天
+     */
+    private _getDayGap(preDate: Date, curDate: Date) {
+        let cur = this._getDayZeroPoint(curDate);
+        let pre = this._getDayZeroPoint(preDate);
+
+        return Math.floor((cur.getTime() - pre.getTime()) / this.DAY_TO_MS)
+    }
+
+    /**
+     * @description 直接获取时间
+     */
+    public getTime() {
+        return this._returnResult(this.time);
+    }
+
+    /**
+     * @description 返回某填的指定时分秒
+     * @param hour 几点
+     * @param minute 几分
+     * @param seconds 几秒
+     */
+    public getTimeWithHour(hour = REFRESH_TIME, minute = 0, seconds = 0) {
+        let t = this._setHour(this.time, hour, minute, seconds);
+        return this._returnResult(t);
+    }
+
+    /**
+     * 获取一周的某个时间
+     * @param time 设置的时间
+     * @param day 周几 周日为0
+     * @param hour 几点，默认为刷新时间
+     * @param minute 几分
+     * @param seconds 几秒
+     */
+    public getTimeWithWeek(day: number, hour = REFRESH_TIME, minute = 0, seconds = 0) {
+        let t = this._getTimeWithWeek(this.time, day, hour, minute, seconds);
+        return this._returnResult(t);
+    }
+
+    /**
+     * 获取这个月的某个时间
+     * @param day 几号
+     * @param hour 几点，默认为刷新时间
+     * @param minute 几分
+     * @param seconds 几秒
+     */
+    public getTimeWithMonth(day: number, hour = REFRESH_TIME, minute = 0, seconds = 0) {
+        let t = this._getTimeWithMonth(this.time, day, hour, minute, seconds);
+        return this._returnResult(t);
+    }
+
+    /**
+     * @description 获得一天的刷新时间，如果是5点刷新，4点进入的话算前一天
+     * @param hour 几点，默认为刷新时间
+     * @param minute 几分
+     * @param seconds 几秒
+     */
+    public getDayZeroPoint(hour = REFRESH_TIME, minute = 0, seconds = 0) {
+        let t = this._getDayZeroPoint(this.time, hour, minute, seconds);
+        return this._returnResult(t);
+    }
+
+    /**
+     * @description 获得一周的刷新时间，如果是5点刷新，4点进入的话算前一周
+     * @param day 星期几
+     * @param hour 几点，默认为刷新时间
+     * @param minute 几分
+     * @param seconds 几秒
+     */
+    public getWeekZeroPoint(day: number = 1, hour = REFRESH_TIME, minute = 0, seconds = 0) {
+        let t = this._getTimeWithWeek(this.time, day, hour, minute, seconds);
+        if(this.now > t) {
+            return this._returnResult(t);
+        } else {
+            return this._returnResult(t.getTime() - this.WEEK_TO_MS);
+        }
+    }
+
+    /**
+     * @description 获得一个月的刷新时间，如果是5点刷新，4点进入的话算前一月
+     * @param day 几号
+     * @param hour 几点，默认为刷新时间
+     * @param minute 几分
+     * @param seconds 几秒
+     */
+    public getMonthZeroPoint(day: number = 1, hour = REFRESH_TIME, minute = 0, seconds = 0) {
+        let t = this._getTimeWithWeek(this.time, day, hour, minute, seconds);
+        if(this.now > t) {
+            return this._returnResult(t);
+        } else {
+            let tt = this._getBeforeMonthWithDay(this.time, 1, day, hour, minute, seconds);
+            return this._returnResult(tt);
+        }
+    }
+
+    /**
+     * @description 获取几天前的指定时分秒
+     * @param day 几天前，（如果是输入3号3点，5点刷新，1天前指1号5点）
+     * @param hour 几点，默认为刷新时间
+     * @param minute 几分
+     * @param seconds 几秒
+     */
+    public getBeforeDayWithHour(day: number = 0, hour = REFRESH_TIME, minute = 0, seconds = 0) {
+        let t = this._setHour(this.time, hour, minute, seconds);
+        if(this.time > t) {
+            let timestamp = t.getTime() - day * this.DAY_TO_MS;
+            return this._returnResult(timestamp);
+        } else {
+            let timestamp = t.getTime() - (day + 1) * this.DAY_TO_MS;
+            return this._returnResult(timestamp);
+        }
+    }
+
+    /**
+     * @description 获取几天后的指定时分秒，如果是指定5点刷新，6点进入的话算后一天
+     * @param day 几天后，（如果是输入3号6点，5点刷新，1天后指5号5点）
+     * @param hour 几点，默认为刷新时间
+     * @param minute 几分
+     * @param seconds 几秒
+     */
+    public getAfterDayWithHour(day: number = 0, hour = REFRESH_TIME, minute = 0, seconds = 0) {
+        let t = this._setHour(this.time, hour, minute, seconds);
+        if(this.time > t) {
+            let timestamp = t.getTime() + (day + 1) * this.DAY_TO_MS;
+            return this._returnResult(timestamp);
+        } else {
+            let timestamp = t.getTime() + day * this.DAY_TO_MS;
+            return this._returnResult(timestamp);
+        }
+    }
+
+    /**
+     * @description 获取某个时间的纯粹的几天前
+     * @param day 几天前
+     */
+    public getBeforeDay(day: number) {
+        let timestamp = this.time.getTime() - day * this.DAY_TO_MS;
+        return this._returnResult(timestamp);
+    }
+
+    /**
+     * @description 获取某个时间的纯粹的几天前
+     * @param day 几天后
+     */
+    public getAfterDay(day: number) {
+        let timestamp = this.time.getTime() + day * this.DAY_TO_MS;
+        return this._returnResult(timestamp);
+    }
+
+    /**
+     * @description 获取某个时间的纯粹的几小时前
+     * @param hour 几小时前
+     */
+    public getBeforeHour(hour: number) {    
+        let timestamp = this.time.getTime() - hour * this.HOUR_TO_MS; 
+        return this._returnResult(timestamp);
+    }
+
+    /**
+     * @description 获取某个时间的纯粹的几分钟前
+     * @param hour 几分钟前
+     */
+    public getBeforeMinute(minute: number) {    
+        let timestamp = this.time.getTime() - minute * this.MINUTE_TO_MS; 
+        return this._returnResult(timestamp);
+    }
+
+    /**
+     * @description 获取某个时间的几秒前
+     * @param seconds 几秒前
+     */
+    public getBeforeSeconds(seconds: number) {    
+        let timestamp = this.time.getTime() - seconds; 
+        return this._returnResult(timestamp);
+    }
+
+    /**
+     * 获取今天距离preDate整数个day天之后的时间
+     * @param preDate 前一个时间点
+     * @param day 几天
+     */
+    public getAfterDayByGap(preDate: Date, day: number) {
+        let gap = this._getDayGap(preDate, this.time);
+        let n = Math.floor(gap / day);
+        return this.getAfterDayWithHour(n * day);
+    }
+
+    /**
+     * @description 获取某个日期到今天之间差几天
+     */
+    public getDayGap() {
+        return this._getDayGap(this.now, this.time);
+    }
+
+    /**
+     * 检查某个时间距离今天是否在day天以内
+     * @param day day天以内
+     */
+    public checkDay(day: number = 1) {
+        if (this.time.getTime() - this.now.getTime() <= day * this.DAY_TO_MS) {
+            return true;
+        }
+        return false;
+    }
+
+}
+
+/**
+ * @description 获取时间对象，10位时间戳
+ * @param time 输入时间
+ */
+export function getTimeFun(time?: number|Date) {
+    let t = new Time(TIME_OUTPUT_TYPE.STAMP_10, time);
+    return t
+}
+
+/**
+ * @description 获取时间对象，13位时间戳
+ * @param time 输入时间
+ */
+export function getTimeFunM(time?: number|Date) {
+    let t = new Time(TIME_OUTPUT_TYPE.STAMP_13, time);
+    return t
+}
+
+/**
+ * @description 获取时间对象，Date格式
+ * @param time 输入时间
+ */
+export function getTimeFunD(time?: number|Date) {
+    let t = new Time(TIME_OUTPUT_TYPE.DATE, time);
+    return t
+}
+
+/**
+ * @description 将某个Date格式转换为10位时间戳
+ * @param time 时间
+ */
 export function getSeconds(time: Date) {
-    return Math.floor(time.getTime() / PER_SECOND);
+    let t = new Time(TIME_OUTPUT_TYPE.STAMP_10, time);
+    return <number>t.getTime();
 }
 
+/**
+ * @description 获取现在的10位时间戳时间
+ */
 export function nowSeconds() {
-    return Math.floor(Date.now() / PER_SECOND );
+    let t = new Time(TIME_OUTPUT_TYPE.STAMP_10);
+    return <number>t.getTime();
 }
 
-export function getTodayZeroPoint(hour = REFRESH_TIME) {
-    var date = new Date();
-    date.setHours(hour);
-    date.setMinutes(0);
-    date.setSeconds(0);
-    var time = Math.floor(date.getTime() / PER_SECOND);
-    return time;
-}
-
-export function checkTodayTime(seasonEndTime: number) {
-    if (seasonEndTime - nowSeconds() <= PER_DAY) {
-        return true;
+/**
+ * 获取刷新时间点 10位时间戳
+ * @param refreshType 刷新类型，每天/每周/每月，默认每天
+ */
+export function getZeroPoint(refreshType: SHOP_REFRESH_TYPE = SHOP_REFRESH_TYPE.DAILY) {
+    let t = new Time(TIME_OUTPUT_TYPE.STAMP_10);
+    if(refreshType == SHOP_REFRESH_TYPE.DAILY) {
+        return <number>t.getDayZeroPoint();
+    } else if (refreshType == SHOP_REFRESH_TYPE.WEEKLY) {
+        return <number>t.getWeekZeroPoint();
+    } else if (refreshType == SHOP_REFRESH_TYPE.MONTHLY) {
+        return <number>t.getMonthZeroPoint();
     }
-    return false;
-}
-
-export function getBeforeDayDate(day: number) {     
-    let time = getTodayZeroPoint() - day * PER_DAY;
-    return time;     
 }
 
 /**
- * 获取几天以前（按秒获取）
- * @param day 几天以前
+ * 获取刷新时间点 Date类型
+ * @param refreshType 刷新类型，每天/每周/每月，默认每天
  */
-export function getBeforeDaySeconds(day: number) {     
-    let time = nowSeconds() - day * PER_DAY;
-    return time;
-}
-
-export function getBeforeHourSeconds(hour: number) {     
-    let time = nowSeconds() - hour * PER_HOUR;
-    return time;
-}
-
-export function getBeforeMinuteSeconds(minute: number) {     
-    let time = nowSeconds() - minute * PER_MINUTE;
-    return time;
-}
-
-export function getBeforeSeconds(seconds: number) {     
-    let time = nowSeconds() - seconds;
-    return time;
-}
-
-
-export function getCurWeekDate(day: number, hour: number) {
-    return getWeekDate(new Date(), day, hour);
-}
-
-export function getWeekDate(now: Date, day: number, hour: number){ //获得本周的开端日期
-    var nowDayOfWeek = now.getDay();
-    if(nowDayOfWeek == 0) nowDayOfWeek = 7;
-
-    let nowDay = now.getDate();
-    let nowYear = now.getFullYear(); //当前年
-    let nowMonth = now.getMonth(); //月
-    return new Date(nowYear, nowMonth, nowDay - nowDayOfWeek + day, hour);
-};
-
-export function getCurWeekTime(day: number, hour: number) {
-    let data = getWeekDate(new Date(), day, hour);
-    return Math.floor(data.getTime()/PER_SECOND);
-}
-
-export function getCurMonthDate(day: number, hour: number) {
-    return getMonthDate(new Date(), day, hour);
-}
-
-export function getCurMonthTime(day: number, hour: number) {
-    let data = getMonthDate(new Date(), day, hour);
-    return Math.floor(data.getTime()/PER_SECOND);
-}
-
-/**
- * @description 获取某个时间的当月的某一天的某一时
- * @param {{Date}} now 时间
- * @param {{number}} day 哪天
- * @param {{number}} hour 几点
- */
-export function getMonthDate(now: Date, day: number, hour: number){ //获得本周的开端日期
-    let nowYear = now.getFullYear(); //当前年
-    let nowMonth = now.getMonth(); //月
-    return new Date(nowYear, nowMonth, day, hour);
-};
-
-
-export function getHourPoint(hour: number) {
-    var date = new Date();
-    date.setHours(hour);
-    date.setMinutes(0);
-    date.setSeconds(0);
-    var time = Math.floor(date.getTime() / PER_SECOND);
-    if (nowSeconds() < time) {
-        return time - PER_DAY;
+export function getZeroPointD(refreshType: SHOP_REFRESH_TYPE = SHOP_REFRESH_TYPE.DAILY) {
+    let t = new Time(TIME_OUTPUT_TYPE.DATE);
+    if(refreshType == SHOP_REFRESH_TYPE.DAILY) {
+        return <Date>t.getDayZeroPoint();
+    } else if (refreshType == SHOP_REFRESH_TYPE.WEEKLY) {
+        return <Date>t.getWeekZeroPoint();
+    } else if (refreshType == SHOP_REFRESH_TYPE.MONTHLY) {
+        return <Date>t.getMonthZeroPoint();
     }
-    return time;
 }
 
-export function getCurHourPoint(hour: number, minute: number = 0, seconds: number = 0) {
-    var date = new Date();
-    date.setHours(hour);
-    date.setMinutes(minute);
-    date.setSeconds(seconds);
-    var time = Math.floor(date.getTime() / PER_SECOND);
-    return time;
-}
 
 /**
- * 获取第2天凌晨几点的时间戳
- * @param hour 
+ * 根据 yy-dd-mm格式获取年龄
+ * 
+ * @param {string} birthday 
  */
-export function getNextHourPoint(hour: number) {
-    var date = new Date();
-    date.setHours(hour);
-    date.setMinutes(0);
-    date.setSeconds(0);
-    var time = Math.floor(date.getTime() / PER_SECOND);
-    if (nowSeconds() > time) {
-        return time + PER_DAY;
-    }
-    return time;
-}
-
-/**
- * 返回今天的某个时间点
- * @param time 
- * @param hour 
- */
-export function getTodayZeroDate(hour = 0) {
-    return getZeroDate(new Date(), hour);
-}
-
-/**
- * 根据给定的时间获得某个时间点
- * @param time 
- * @param hour 
- */
-export function getZeroDate(time: Date, hour = 0) {
-    let date = new Date(time.getTime());
-    date.setHours(hour);
-    date.setMinutes(0);
-    date.setSeconds(0);
-    return date;
-}
-
-export function getZeroDateByDeltaDay(delta: number) {
-    var date = new Date(new Date().getTime() + delta * PER_DAY * PER_SECOND);
-    date.setHours(0);
-    date.setMinutes(0);
-    date.setSeconds(0);
-    return date;
-}
-
 export function getAge(birthday: string) {
     let d = new Date(birthday + ' 00:00:00');
     let _year = d.getFullYear();
@@ -187,7 +488,12 @@ export function getAge(birthday: string) {
     return age
 }
 
-export function formatTime(d: Date, type: number) {
+/**
+ * 将Date格式的数据转为string格式
+ * @param {Date} d 时间
+ * @param {TIME_FORMAT} type 类型
+ */
+export function formatTime(d: Date, type: TIME_FORMAT) {
     let year = d.getFullYear();
     let month = d.getMonth() + 1;
     let day = d.getDate();
@@ -202,21 +508,6 @@ export function formatTime(d: Date, type: number) {
     }
 }
 
-/**
- * @description 获取指定时间后的某个时间点，如给定 date 后的晚八点整
- * @export
- * @param {Date} date 给定时间
- * @param {number} h 给定小时
- * @param {number} [m=0] 给定分钟
- * @param {number} [s=0] 给定秒
- * @returns {Date}
- */
-export function getNextTime(date: Date, h: number, m = 0, s = 0, ms = 0): Date {
-    const milliseconds = date.getTime();
-    const timeToday = new Date(milliseconds).setHours(h, m, s, ms);
-    return timeToday >= milliseconds ? new Date(timeToday) : new Date(timeToday + PER_DAY * PER_SECOND);
-}
-
 /**
  * 获得某个时间是星期几
  * @param needHandle 是否处理周日
@@ -241,37 +532,3 @@ export function setWeek(d?: number) {
     week = d;
     if(d == 7) week = 0;
 }
-
-/**
- * 
- * @param preDate 
- * @param curDate 
- */
-export function getDayGap(preDate: Date, curDate: Date) {
-    let cur = getZeroDate(curDate, REFRESH_HOUR);
-    let pre = getZeroDate(preDate, REFRESH_HOUR);
-
-    return Math.floor((cur.getTime() - pre.getTime()) / PER_DAY / PER_SECOND)
-}
-
-/**
- * 获取某一天的 n * day 天之后
- * @param preDate 
- * @param curDate 
- * @param day 
- */
-export function getNextDayByGap(preDate: Date, curDate: Date, day: number) {
-    let gap = getDayGap(preDate, curDate);
-    let n = Math.floor(gap / day);
-    let time = getAfterDateByDay(preDate, n * day);
-    return new Date(time * PER_SECOND);
-}
-
-/**
- * 获取某个时间的 day 天之后
- * @param day 
- */
-export function getAfterDateByDay(preDate: Date, day: number) {     
-    let time = getZeroDate(preDate, REFRESH_HOUR).getTime() + day * PER_DAY * PER_SECOND;
-    return Math.floor(time/PER_SECOND);     
-}
\ No newline at end of file
diff --git a/shared/pubUtils/util.ts b/shared/pubUtils/util.ts
index 0fad0147a..c0e6a23e0 100644
--- a/shared/pubUtils/util.ts
+++ b/shared/pubUtils/util.ts
@@ -4,10 +4,10 @@ import { HeroModel, HeroType } from '../db/Hero';
 
 import fs = require('fs');
 import path = require('path');
-import { HERO_CE_RATIO, ABI_STAGE, GACHA_TO_FLOOR } from '../consts';
+import { HERO_CE_RATIO, ABI_STAGE, GACHA_TO_FLOOR, TIME_OUTPUT_TYPE, REFRESH_TIME } from '../consts';
 
 import { findIndex } from 'underscore';
-import { getWeekDate } from './timeUtil';
+import { getTimeFunM } from './timeUtil';
 import { Floor } from '../domain/activityField/gachaField';
 const randomName = require("chinese-random-name");
 const moment = require('moment');
@@ -130,7 +130,7 @@ export function deltaDays(preTime: Date, proTime: Date): number {
  * @param hour 几点刷新
  * @param deltaDay 间隔几天刷新，默认每天刷新(deltaDay = 1)
  */
-export function shouldRefresh(preTime: Date, now: Date, hour: number, deltaDay = 1): boolean {
+export function shouldRefresh(preTime: Date, now: Date, hour: number = REFRESH_TIME, deltaDay = 1): boolean {
     if (!preTime) return true;
     let curTime = new Date(now.getTime());
     let refreshTime = new Date(now.getTime());
@@ -151,40 +151,17 @@ export function shouldRefresh(preTime: Date, now: Date, hour: number, deltaDay =
  * @param hour 几点刷新
  * @param deltaDay 间隔几天刷新，默认每天刷新(deltaDay = 1)
  */
-export function shouldRefreshWeek(preTime: Date, now: Date, day: number, hour: number, deltaWeek = 1): boolean {
+export function shouldRefreshWeek(preTime: Date, now: Date, day: number = 1, hour: number = REFRESH_TIME, deltaWeek = 1): boolean {
     if (!preTime) return true;
     let curTime = new Date(now.getTime());
-    let refreshTime = getWeekDate(now, day, hour);
-    let refeshTime = refreshTime.getTime();
+    let refreshTime = <number>getTimeFunM(now).getTimeWithWeek(day, hour);
 
-    if (refeshTime - preTime.getTime() > (deltaWeek >= 1 ? deltaWeek - 1 : 0) * 7 * 24 * 60 * 60 * 1000 && curTime.getTime() >= refeshTime) {
+    if (refreshTime - preTime.getTime() > (deltaWeek >= 1 ? deltaWeek - 1 : 0) * 7 * 24 * 60 * 60 * 1000 && curTime.getTime() >= refreshTime) {
         return true;
     }
     return false;
 }
 
-
-/**
- * 获取 x天后的y点
- * @param curTime 现在时间
- * @param hour 几点刷新
- */
-export function getRefTime(now = new Date(), checkHour: number, day = 0) {
-    let curTime = new Date(now.getTime());
-    if (checkHour < 0) {
-        checkHour = 24 + checkHour;
-        if (curTime.getHours() >= checkHour) {
-            curTime.setDate(curTime.getDate() + 1);
-        }
-    } else {
-        if (curTime.getHours() < checkHour) {
-            curTime.setDate(curTime.getDate() - 1);
-        }
-    }
-    let today = curTime.setHours(checkHour, 0, 0, 0);;
-    return new Date(today + day * 24 * 60 * 60 * 1000);
-}
-
 /**
  * 从一个数组中随机返回不重复的 cnt 个元素数组
  * @param source 原数组