活动：调整活动代码路径

2021-06-22 17:16:33 +08:00
parent 8fae4a22ab
commit 42748f4a62
58 changed files with 274 additions and 312 deletions
@@ -0,0 +1,182 @@
+import { ACTIVITY_TYPE } from '../../consts';
+import { getPlayerFirstGiftData } from './firstGiftService';
+import { getPlayerSignInData, } from './signInService';
+import { getPlayerGrowthFundData, } from './growthFundService';
+import { getPlayerLimitPackageData, } from './limitPackageService';
+import { getPlayerDailyGiftsData } from './dailyGiftsService';
+import { getPlayerYuanbaoShopData, } from './yuanbaoService';
+import { getPlayerMonthlyTicketData, } from './monthlyTicketService';
+import { getPlayerRechargeMoneyData, } from './rechargeMoneyService';
+import { getPlayerThirtyDaysData, playerThirtyDaysActivityDays, } from './thirtyDaysService';
+import { getPlayerVipRechargeMoneyData, } from './vipRechargeMoneyService';
+import { getPlayerActivityData, } from './selfServiceShopActivityService';
+import { ActivitySelfServiceGoodsModel } from '../../db/ActivitySelfServiceGoods';
+import { RoleModel } from '../../db/Role';
+import moment = require('moment');
+import { getPlayerTreasureHuntData, getTreasureHuntData } from './treasureHuntService';
+import { getPlayerPopUpShopData } from './popUpShopService';
+import { getPlayerSevenDaysData } from './sevenDaysService';
+import { getPlayerDailyMealData } from './dailyMealService';
+import { getPlayerDailyCoinData } from './dailyCoinService';
+import { getPlayerDailyRMBGiftsData } from './dailyRMBGiftsService';
+import { getPlayerDailyGKData } from './dailyGKService';
+import { getPlayerRefreshShopData } from './refreshShopService';
+import { getPlayerRefreshTaskData } from './refreshTaskService';
+import { getMonopolyActivity, getPlayerMonopolyData } from './monopolyService';
+import { getPlayerNewHeroGiftsData } from './newHeroGiftsService';
+
+/**
+   * 获取活动数据
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   *
+   */
+export async function getActivity(serverId: number, roleId: string, activityId: number, activityType: number) {
+    let activityData = null;
+    switch (activityType) {
+        case ACTIVITY_TYPE.SIGN_IN://签到 4
+        case ACTIVITY_TYPE.SIGN_IN_VIP://高级签到 5
+        case ACTIVITY_TYPE.NEW_PLAYER_SIGN_IN://新手签到 25
+            {
+                activityData = await getPlayerSignInData(activityId, serverId, roleId);
+                break;
+            }
+        case ACTIVITY_TYPE.GROWTH_FUND_MAIN://成长基金 6
+        case ACTIVITY_TYPE.GROWTH_FUND_MAIN_VIP://高阶成长基金 7
+        case ACTIVITY_TYPE.GROWTH_FUND_TOWER://镇念塔成长基金 8
+        case ACTIVITY_TYPE.GROWTH_FUND_TOWER_VIP://高阶镇念塔成长基金 9
+        case ACTIVITY_TYPE.GROWTH_FUND_MAIN_ELITE://精英成长基金 10
+        case ACTIVITY_TYPE.GROWTH_FUND_MAIN_ELITE_VIP://高阶精英成长基金 11
+            {
+                activityData = await getPlayerGrowthFundData(activityId, serverId, roleId);
+                break;
+            }
+        case ACTIVITY_TYPE.THIRTY_DAYS://30天目标活动 12
+            {
+                let data = await getPlayerThirtyDaysData(activityId, serverId, roleId);
+                let todayIndex = await playerThirtyDaysActivityDays(roleId);
+                activityData = { playerData: data, todayIndex }
+                break;
+            }
+        case ACTIVITY_TYPE.SELF_SERVICE_SHOP://自选商店 糜家商队 13
+            {
+                let data = await getPlayerActivityData(activityId, serverId, roleId);
+                let playerGoods = await ActivitySelfServiceGoodsModel.findData(activityId, roleId, data.roundIndex, true);
+                activityData = { playerData: data, playerGoods: playerGoods ? playerGoods : [] }
+                break;
+            }
+        case ACTIVITY_TYPE.FIRST_GIFT://首冲礼包活动 14
+            {
+                activityData = await getPlayerFirstGiftData(activityId, serverId, roleId);
+                break;
+            }
+        case ACTIVITY_TYPE.NEW_PLAYER_LIMIT_PACKAGE://新手限定RMB购买礼包 15
+            {
+                let { createTime } = await RoleModel.findByRoleId(roleId);
+                let createDate = moment(createTime * 1000).toDate();
+                let endTime = moment(createDate).startOf('d').add(7, 'd').add(5, 'h').toDate();
+                if (new Date() <= endTime) {
+                    activityData = await getPlayerLimitPackageData(activityId, serverId, roleId);
+                }
+                break;
+            }
+        case ACTIVITY_TYPE.LIMIT_PACKAGE_SHOP_DAILY://每日限购礼包，RMB购买礼包 16
+        case ACTIVITY_TYPE.LIMIT_PACKAGE_SHOP_WEEKLY://每周限购礼包，RMB购买礼包 17
+            {
+                activityData = await getPlayerLimitPackageData(activityId, serverId, roleId);
+                break;
+            }
+        case ACTIVITY_TYPE.YUAN_BAO_SHOP://元宝商店 18
+            {
+                activityData = await getPlayerYuanbaoShopData(activityId, serverId, roleId);
+                break;
+            }
+        case ACTIVITY_TYPE.MONTHLY_TICKET_1://月卡1 19
+        case ACTIVITY_TYPE.MONTHLY_TICKET_2://月卡2 20
+            {
+                activityData = await getPlayerMonthlyTicketData(activityId, serverId, roleId);
+                break;
+            }
+        case ACTIVITY_TYPE.RECHARGE_MONEY://累计充值RMB活动 21
+            {
+                activityData = await getPlayerRechargeMoneyData(activityId, serverId, roleId);
+                break;
+            }
+        case ACTIVITY_TYPE.DAILY_RMB_GIFTS://每日特惠RMB购买，一次性购买7天礼包 22
+            {
+                activityData = await getPlayerDailyRMBGiftsData(activityId, serverId, roleId);
+                break;
+            }
+        case ACTIVITY_TYPE.TREASURE_HUNT://寻宝骑兵活动 23
+            {
+                let { huntActivityId, huntBeginTime, huntEndTime, huntRoundIndex } = await getTreasureHuntData(serverId);
+                activityData = await getPlayerTreasureHuntData(activityId, serverId, roleId, huntRoundIndex, huntBeginTime, huntEndTime);
+                break;
+            }
+        case ACTIVITY_TYPE.POP_UP_SHOP://弹出商店 24
+            {
+                activityData = await getPlayerPopUpShopData(activityId, serverId, roleId);
+                break;
+            }
+        case ACTIVITY_TYPE.VIP_RECHARGE_MONEY://vip累计充值活动 26
+            {
+                activityData = await getPlayerVipRechargeMoneyData(activityId, serverId, roleId);
+                break;
+            }
+        case ACTIVITY_TYPE.SEVEN_DAY://七天乐活动 27
+        case ACTIVITY_TYPE.FOURTEEN_DAY://十四天乐活动 28
+        case ACTIVITY_TYPE.COMMON_SEVEN_DAY://通用七天乐活动 29
+            {
+                activityData = await getPlayerSevenDaysData(activityId, serverId, roleId);
+                break;
+            }
+        case ACTIVITY_TYPE.DAILY_MEAL://每日领取免费午饭、晚饭活动 30
+            {
+                activityData = await getPlayerDailyMealData(activityId, serverId, roleId);
+                break;
+            }
+        case ACTIVITY_TYPE.DAILY_COIN://每日兑换铜币活动 31
+            {
+                activityData = await getPlayerDailyCoinData(activityId, serverId, roleId);
+                break;
+            }
+        case ACTIVITY_TYPE.DAILY_GK://每日关卡（每日开启一关） 32
+            {
+                activityData = await getPlayerDailyGKData(activityId, serverId, roleId);
+                break;
+            }
+        case ACTIVITY_TYPE.REFRESH_SHOP://通用的刷新商店（分页，可刷新，限制购买次数，支持rmb与资源兑换） 33
+            {
+                activityData = await getPlayerRefreshShopData(activityId, serverId, roleId);
+                break;
+            }
+        case ACTIVITY_TYPE.REFRESH_TASK://通用的刷新任务（分页，可刷新，限制领取次数） 34
+            {
+                activityData = await getPlayerRefreshTaskData(activityId, serverId, roleId);
+                break;
+            }
+        case ACTIVITY_TYPE.MONOPOLY://大富翁游戏 35
+            {
+                activityData = await getPlayerMonopolyData(activityId, serverId, roleId);
+                break;
+            }
+        case ACTIVITY_TYPE.COMMON_SIGN_IN://通用签到 36
+            {
+                activityData = await getPlayerSignInData(activityId, serverId, roleId);
+                break;
+            }
+        case ACTIVITY_TYPE.NEW_HERO_GIFTS://新将好礼(很多红包，用积分兑换一遍结束) 37
+            {
+                activityData = await getPlayerNewHeroGiftsData(activityId, serverId, roleId);
+                break;
+            }
+        default: {
+            console.log('未知活动类型.........', activityType)
+            break;
+        }
+    }
+    return activityData;
+}
+
@@ -0,0 +1,48 @@
+import { ACTIVITY_TYPE } from '../../consts';
+import { ActivityModel, ActivityModelType } from '../../db/Activity';
+import { ActivityDailyChallengesModel, ActivityDailyChallengesModelType } from '../../db/ActivityDailyChallenges';
+import { ServerlistModel } from '../../db/Serverlist';
+import { DailyChallengesData, DailyItem } from '../../domain/activityField/dailyChallengesField';
+
+
+/**
+   * 获取活动数据
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   *
+   */
+export async function dailyChallengesActivity(serverId: number, roleId: string) {
+    let { activityGroupId } = await ServerlistModel.findByServerId(serverId);
+    let activityDataArray: ActivityModelType[] = await ActivityModel.findOpenActivityByType(activityGroupId, ACTIVITY_TYPE.TASK_DAILY_CHALLENGES, new Date());
+    if (activityDataArray.length === 0) {
+        return null;
+    }
+    let activityData: ActivityModelType = activityDataArray[0];
+    let playerRecords: ActivityDailyChallengesModelType[] = await ActivityDailyChallengesModel.findData(serverId, activityData.activityId, roleId);
+    let playerData = new DailyChallengesData(activityData);
+    playerData.setPlayerRecords(playerRecords);
+    return playerData;
+}
+
+
+/**
+   * 玩家玩家活动数据
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   *
+   */
+export async function getPlayerDailyChallengesData(activityId: number, serverId: number, roleId: string) {
+    let activityData: ActivityModelType = await ActivityModel.findActivity(activityId);
+    let playerRecords: ActivityDailyChallengesModelType[] = await ActivityDailyChallengesModel.findData(serverId, activityId, roleId);
+
+    let playerData = new DailyChallengesData(activityData);
+    playerData.setPlayerRecords(playerRecords);
+
+    return playerData;
+}
+
+
@@ -0,0 +1,60 @@
+import { ACTIVITY_TYPE, DAILY_MEAL_TYPE } from '../../consts';
+import { ActivityModel, ActivityModelType } from '../../db/Activity';
+import { ActivityDailyCoinModel, ActivityDailyCoinModelType } from '../../db/ActivityDailyCoin';
+import { ActivityGroupModel } from '../../db/ActivityGroup';
+import { ServerlistModel } from '../../db/Serverlist';
+import { DailyCoinData } from '../../domain/activityField/dailyCoinField';
+
+
+/**
+   * 获取活动数据
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   *
+   */
+export async function dailyCoinActivity(serverId: number, roleId: string) {
+    let { activityGroupId } = await ServerlistModel.findByServerId(serverId);
+    let activityDataArray: ActivityModelType[] = await ActivityModel.findOpenActivityByType(activityGroupId, ACTIVITY_TYPE.DAILY_COIN, new Date());
+    if (activityDataArray.length === 0) {
+        return null;
+    }
+    let activityData: ActivityModelType = activityDataArray[0];
+    let playerData = new DailyCoinData(activityData);
+
+    let playerRecord: ActivityDailyCoinModelType = await ActivityDailyCoinModel.findData(serverId, activityData.activityId, roleId, playerData.beginTime);
+    playerData.setPlayerRecords(playerRecord);
+    return playerData;
+}
+
+
+/**
+   * 玩家玩家活动数据
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   *
+   */
+export async function getPlayerDailyCoinData(activityId: number, serverId: number, roleId: string) {
+    let activityData: ActivityModelType = await ActivityModel.findActivity(activityId);
+    let playerData = new DailyCoinData(activityData);
+
+    let playerRecord: ActivityDailyCoinModelType = await ActivityDailyCoinModel.findData(serverId, activityData.activityId, roleId, playerData.beginTime);
+    playerData.setPlayerRecords(playerRecord);
+    return playerData;
+}
+
+export function mergeData(data: any[]) {
+    let newDate = [];
+    for (let item of data) {
+        let index = newDate.findIndex(obj => { return obj.id === item.id });
+        if (index != -1) {
+            newDate[index].count += item.count;
+        } else {
+            newDate = newDate.concat(item);
+        }
+    }
+    return newDate;
+}
@@ -0,0 +1,72 @@
+import { ACTIVITY_TYPE } from '../../consts';
+import { ActivityModel, ActivityModelType } from '../../db/Activity';
+import { ActivityDailyGKModel, ActivityDailyGKModelType } from '../../db/ActivityDailyGK';
+import { ServerlistModel } from '../../db/Serverlist';
+import { DailyGKData, DailyGKItem } from '../../domain/activityField/dailyGKField';
+
+
+/**
+   * 获取活动数据
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   *
+   */
+export async function dailyGKActivity(serverId: number, roleId: string) {
+    let { activityGroupId } = await ServerlistModel.findByServerId(serverId);
+    let activityDataArray: ActivityModelType[] = await ActivityModel.findOpenActivityByType(activityGroupId, ACTIVITY_TYPE.DAILY_GK, new Date());
+    if (activityDataArray.length === 0) {
+        return null;
+    }
+    let activityData: ActivityModelType = activityDataArray[0];
+    let playerRecord: ActivityDailyGKModelType = await ActivityDailyGKModel.findData(serverId, activityData.activityId, roleId);
+    let playerData = new DailyGKData(activityData);
+    playerData.setPlayerRecords(playerRecord);
+    return playerData;
+}
+
+
+/**
+   * 玩家玩家活动数据
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   *
+   */
+export async function getPlayerDailyGKData(activityId: number, serverId: number, roleId: string) {
+    let activityData: ActivityModelType = await ActivityModel.findActivity(activityId);
+    let playerRecord: ActivityDailyGKModelType = await ActivityDailyGKModel.findData(serverId, activityId, roleId);
+
+    let playerData = new DailyGKData(activityData);
+    playerData.setPlayerRecords(playerRecord);
+
+    return playerData;
+}
+
+/**
+   * 挑战每日关卡成功
+   *
+   * @param {number} activityId 活动id
+   * @param {number} gk 关卡id
+   *
+   */
+export async function challengeDailyGK(serverId: number, roleId: string, activityId: number, gk: number) {
+    let activityData: ActivityModelType = await ActivityModel.findActivity(activityId);
+
+    let playerData = new DailyGKData(activityData);
+    let item = playerData.findItemByGK(gk);
+    if (item) {
+        let dayIndex = item.dayIndex;
+        await ActivityDailyGKModel.addRecord(serverId, activityId, roleId, dayIndex);
+    } else {
+        console.log('没有找到对应关卡活动数据', activityId, gk)
+    }
+
+    return playerData;
+}
+
+
+
+
@@ -0,0 +1,49 @@
+import { ACTIVITY_TYPE } from '../../consts';
+import { ActivityModel, ActivityModelType } from '../../db/Activity';
+import { ActivityDailyGiftsModel, ActivityDailyGiftsModelType } from '../../db/ActivityDailyGifts';
+import { ServerlistModel } from '../../db/Serverlist';
+import { DailyGiftsData } from '../../domain/activityField/dailyGiftsField';
+
+
+
+/**
+   * 获取活动数据
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   *
+   */
+export async function dailyGiftsActivity(serverId: number, roleId: string) {
+    let { activityGroupId } = await ServerlistModel.findByServerId(serverId);
+    let activityDataArray: ActivityModelType[] = await ActivityModel.findOpenActivityByType(activityGroupId, ACTIVITY_TYPE.DAILY_DISCOUNT_GIFT, new Date());
+    if (activityDataArray.length === 0) {
+        return null;
+    }
+    let activityData: ActivityModelType = activityDataArray[0];
+    let playerRecords: ActivityDailyGiftsModelType[] = await ActivityDailyGiftsModel.findData(serverId, activityData.activityId, roleId);
+    let playerData = new DailyGiftsData(activityData);
+    playerData.setPlayerRecords(playerRecords);
+    return playerData;
+}
+
+
+/**
+   * 玩家玩家活动数据
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   *
+   */
+export async function getPlayerDailyGiftsData(activityId: number, serverId: number, roleId: string) {
+    let activityData: ActivityModelType = await ActivityModel.findActivity(activityId);
+    let playerRecords: ActivityDailyGiftsModelType[] = await ActivityDailyGiftsModel.findData(serverId, activityId, roleId);
+
+    let playerData = new DailyGiftsData(activityData);
+    playerData.setPlayerRecords(playerRecords);
+
+    return playerData;
+}
+
+
@@ -0,0 +1,50 @@
+import { ACTIVITY_TYPE, DAILY_MEAL_TYPE } from '../../consts';
+import { ActivityModel, ActivityModelType } from '../../db/Activity';
+import { ActivityDailyMealModel, ActivityDailyMealModelType } from '../../db/ActivityDailyMeal';
+import { ServerlistModel } from '../../db/Serverlist';
+import { DailyMealData } from '../../domain/activityField/dailyMealField';
+
+
+/**
+   * 获取活动数据
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   *
+   */
+export async function dailyMealActivity(serverId: number, roleId: string) {
+    let { activityGroupId } = await ServerlistModel.findByServerId(serverId);
+    let activityDataArray: ActivityModelType[] = await ActivityModel.findOpenActivityByType(activityGroupId, ACTIVITY_TYPE.DAILY_MEAL, new Date());
+    if (activityDataArray.length === 0) {
+        return null;
+    }
+    let activityData: ActivityModelType = activityDataArray[0];
+    let playerData = new DailyMealData(activityData);
+
+    let playerLunchRecords: ActivityDailyMealModelType[] = await ActivityDailyMealModel.findData(serverId, activityData.activityId, roleId, DAILY_MEAL_TYPE.LUNCH, playerData.beginTime, playerData.endTime);
+    let playerDinnerRecords: ActivityDailyMealModelType[] = await ActivityDailyMealModel.findData(serverId, activityData.activityId, roleId, DAILY_MEAL_TYPE.DINNER, playerData.beginTime, playerData.endTime);
+    playerData.setPlayerRecords(playerLunchRecords.concat(playerDinnerRecords));
+    return playerData;
+}
+
+
+/**
+   * 玩家玩家活动数据
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   *
+   */
+export async function getPlayerDailyMealData(activityId: number, serverId: number, roleId: string) {
+    let activityData: ActivityModelType = await ActivityModel.findActivity(activityId);
+    let playerData = new DailyMealData(activityData);
+
+    let playerLunchRecords: ActivityDailyMealModelType[] = await ActivityDailyMealModel.findData(serverId, activityData.activityId, roleId, DAILY_MEAL_TYPE.LUNCH, playerData.beginTime, playerData.endTime);
+    let playerDinnerRecords: ActivityDailyMealModelType[] = await ActivityDailyMealModel.findData(serverId, activityData.activityId, roleId, DAILY_MEAL_TYPE.DINNER, playerData.beginTime, playerData.endTime);
+    playerData.setPlayerRecords(playerLunchRecords.concat(playerDinnerRecords));
+    return playerData;
+}
+
+
@@ -0,0 +1,109 @@
+import { ACTIVITY_TYPE, STATUS } from '../../consts';
+import { ActivityModel, ActivityModelType } from '../../db/Activity';
+import { ActivityDailyRMBGiftsModel, ActivityDailyRMBGiftsModelType } from '../../db/ActivityDailyRMBGifts';
+import { DailyRMBGiftsData } from '../../domain/activityField/dailyRMBGiftsField';
+import moment = require('moment');
+import { RewardParam } from '../../domain/activityField/rewardField';
+import { addReward, stringToRewardParam } from './giftPackageService';
+import { ServerlistModel } from '../../db/Serverlist';
+
+/**
+   * 获取活动数据
+   *
+   * @param {number} serverId 区Id
+   * @param {number} type 活动类型 ACTIVITY_TYPE
+   * @param {string} roleId 角色Id
+   *
+   */
+
+export async function dailyRMBGiftsActivity(serverId: number, roleId: string) {
+    let { activityGroupId } = await ServerlistModel.findByServerId(serverId);
+    let activityArray: ActivityModelType[] = await ActivityModel.findOpenActivityByType(activityGroupId, ACTIVITY_TYPE.DAILY_RMB_GIFTS, new Date())
+
+    if (activityArray.length == 0) {
+        return null;
+    }
+    let activityData = activityArray[0];
+    let playerData = await getPlayerDailyRMBGiftsData(activityData.activityId, serverId, roleId);
+    return playerData
+}
+
+/**
+   * 玩家活动数据
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   *
+   */
+export async function getPlayerDailyRMBGiftsData(activityId: number, serverId: number, roleId: string) {
+    let activityData: ActivityModelType = await ActivityModel.findActivity(activityId);
+
+    let playerData = new DailyRMBGiftsData(activityData);
+    // let productID = playerData.productID;
+    // let playerOrders: UserOrderModelType[] = await UserOrderModel.findPlayerOrder(productID, roleId, activityId, 1);
+    // let buyTime = moment(new Date()).startOf('d').toDate()
+    // let endTime = null;
+    // if (playerOrders.length > 0) {
+    //     buyTime = playerOrders[0].createdAt;//购买时候的日期
+    //     endTime = moment(buyTime).add(7, 'd').endOf('d').toDate()
+    // }
+    let playerRecord: ActivityDailyRMBGiftsModelType = await ActivityDailyRMBGiftsModel.findRecord(serverId, activityId, roleId, moment(playerData.beginTime).toDate());
+    let unReceiveRecord: ActivityDailyRMBGiftsModelType[] = await ActivityDailyRMBGiftsModel.findBuyRecord(serverId, activityId, roleId, moment(playerData.beginTime).toDate());
+
+    playerData.setPlayerRecords(playerRecord, unReceiveRecord.length);
+    return playerData;
+}
+
+/**
+   * 结算购买礼包的奖励
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   * @param {string} productID 商品ID
+   *
+   */
+export async function makeDailyRMBGiftsReward(roleId: string, roleName: string, sid: string, serverId: number, funcs: number[],
+    activityId: number, productID: string) {
+    let activityData: ActivityModelType = await ActivityModel.findActivity(activityId);
+    if (activityData.type !== ACTIVITY_TYPE.DAILY_RMB_GIFTS) {
+        return {
+            code: STATUS.ACTIVITY_TYPE_ERROR,
+        }
+    }
+    let playerData = new DailyRMBGiftsData(activityData);
+    let bigGiftProductID = playerData.productID;
+    if (bigGiftProductID == productID) {//一次性购买7天礼包
+        let playerRecord: ActivityDailyRMBGiftsModelType = await ActivityDailyRMBGiftsModel.findRecord(serverId, activityId, roleId, moment(playerData.beginTime).toDate());
+        if (playerRecord && playerRecord.records && playerRecord.records.length > 0) {//今天已经购买过其他奖励
+            playerData.beginTime += 24 * 60 * 60 * 1000;
+        }
+
+        for (let i = 0; i < playerData.day; i++) {
+            let beginTime = playerData.beginTime + 24 * 60 * 60 * 1000 * i;
+            // let beginTime = moment(new Date()).startOf('d').add(i, 'day').add(REFRESH_TIME, 'h').toDate();
+            await ActivityDailyRMBGiftsModel.buyRecord(serverId, activityId, roleId, moment(beginTime).toDate(), true);
+        }
+        let endTime = moment(playerData.endTime).add(playerData.day, 'd').toDate()
+        return {
+            code: 0,
+            data: Object.assign({}, { item: { endTime, receiveCount: 0 } })
+        }
+    } else {
+        let item = playerData.findProduct(productID);
+        if (!item) {
+            return {
+                code: STATUS.ACTIVITY_NO_PRODUCT,
+            }
+        }
+        let rewardParamArr: Array<RewardParam> = stringToRewardParam(item.reward);
+        let result = await addReward(roleId, roleName, sid, serverId, funcs, rewardParamArr)
+        await ActivityDailyRMBGiftsModel.receiveRecord(serverId, activityId, roleId, moment(playerData.beginTime).toDate(), [item.id]);
+        item.isReceive = true;
+        return {
+            code: 0,
+            data: Object.assign(result, { item })
+        }
+    }
+}
@@ -0,0 +1,49 @@
+import { ACTIVITY_TYPE, TASK_TYPE } from '../../consts';
+import { ActivityModel, ActivityModelType } from '../../db/Activity';
+import { ActivityFirstGiftModel, ActivityFirstGiftModelType } from '../../db/ActivityFirstGift';
+import { ServerlistModel } from '../../db/Serverlist';
+import { FirstGiftData } from '../../domain/activityField/firstGiftField';
+
+/**
+   * 获取活动数据
+   *
+   * @param {number} serverId 区Id
+   * @param {number} type 活动类型 ACTIVITY_TYPE
+   * @param {string} roleId 角色Id
+   *
+   */
+
+export async function firstGiftActivity(serverId: number, roleId: string) {
+    let { activityGroupId } = await ServerlistModel.findByServerId(serverId);
+    let activityArray: ActivityModelType[] = await ActivityModel.findActivityByType(activityGroupId, ACTIVITY_TYPE.FIRST_GIFT, 1)
+
+    if (activityArray.length == 0) {
+        return null;
+    }
+    let activityData = activityArray[0];
+    let playerRecord: ActivityFirstGiftModelType = await ActivityFirstGiftModel.findData(activityData.activityId, roleId);
+    if (!playerRecord || playerRecord.isOver) {
+        return null;
+    }
+
+    let playerData = new FirstGiftData(activityData);
+    playerData.setPlayerRecords(playerRecord);
+    return playerData;
+}
+
+/**
+   * 玩家活动数据
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   *
+   */
+export async function getPlayerFirstGiftData(activityId: number, serverId: number, roleId: string) {
+    let activityData: ActivityModelType = await ActivityModel.findActivity(activityId);
+    let playerRecord: ActivityFirstGiftModelType = await ActivityFirstGiftModel.findData(activityId, roleId);
+
+    let playerData = new FirstGiftData(activityData);
+    playerData.setPlayerRecords(playerRecord);
+    return playerData;
+}
@@ -0,0 +1,312 @@
+import { GachaData, Floor, GachaResult, Hope, GachaListReturn } from "../../domain/activityField/gachaField";;
+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_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, GACHA_ID } from "../../consts";
+import { getTimeFunD, getZeroPointD } from "../../pubUtils/timeUtil";
+import { gameData, getDicGachaFloor } from "../../pubUtils/data";
+
+/**
+ * 获取招募列表
+ * @param roleId 
+ */
+export async function getGachaList(roleId: string) {
+    let userGachaList = await UserGachaModel.findAllByRole(roleId);
+    let list: GachaListReturn[] = [];
+    for (let [id, dicGacha] of gameData.gacha) {
+        if (id == GACHA_ID.TIMELIMIT) continue; // 不包括限时
+
+        let userGacha = userGachaList.find(cur => cur.gachaId == id);
+        if (userGacha)
+            userGacha = await refreshGacha(dicGacha, userGacha);
+        let param = new GachaListReturn(dicGacha, userGacha);
+        list.push(param);
+    }
+    return list;
+}
+
+/**
+ * 获取活动页签里的限时卡池
+ * 
+ * @param roleId 玩家id
+ * @param aid 活动id
+ */
+export async function getLimitGacha(serverId: number, roleId: string, activityId: number) {
+
+    let activityData = await ActivityModel.findActivity(activityId);
+    if (!activityData) return false;
+
+    let gachaData = new GachaData(activityData);
+    let userGacha = await UserGachaModel.findByRole(roleId, gachaData.gachaId, activityId);
+    userGacha = await refreshGacha(gameData.gacha.get(gachaData.gachaId), userGacha);
+    gachaData.setUserGacha(userGacha);
+    return gachaData
+}
+
+/**
+ * 刷新免费次数
+ * @param dicGacha 
+ * @param userGacha 
+ */
+export async function refreshGacha(dicGacha: DicGacha, userGacha: UserGachaType) {
+    let { day, count } = dicGacha.free;
+
+    if (count <= 0) {
+        return userGacha;
+    }
+
+    let { roleId, gachaId, refFreeTime, refHopeTime, hope } = userGacha;
+    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_TIME)) {
+        hope = hope.map(cur => { return { ...cur, hasGet: false } });
+        let ref = getZeroPointD();
+        userGacha = await UserGachaModel.refreshHopeCount(roleId, gachaId, 0, hope, ref);
+    }
+    return userGacha
+}
+
+
+export async function getVisitedHeroList(roleId: string) {
+
+    let { visitedHero, refVisitedTime } = await UserGachaModel.findByRole(roleId, GACHA_ID.NORMAL, 0);
+    if (shouldRefresh(refVisitedTime, new Date())) {
+        visitedHero = [];
+    }
+
+    return visitedHero;
+}
+
+/**
+ * @description 获得保底结果
+ * @param gachaId 招募表id
+ * @param base 按普通概率获得的东西 内容参考gachaContent
+ * @param floor 玩家保底数据
+ */
+export function getFloorResult(gachaId: number, base: number, floor: Floor[]) {
+    let dicGachaContent = gameData.gachaContent.get(base); // 普通随机得出的结果是哪一类；
+    if (!dicGachaContent) {
+        console.error('dic_zyz_gachaContent error');
+        return false; // DIC_NOT_FOUND 直接报错
+    }
+
+    let touchedFloor = 0, touchedHeroQuality: number; // 触发的保底的id
+    let dicFloorType = GACHA_TO_FLOOR.get(gachaId);
+    for (let id of dicFloorType) {
+        let { type, param } = dicGachaContent;
+        let heroQuality = getHeroQuality(id);
+        if (heroQuality == false) continue;
+
+        let isTarget = type == GACHA_CONTENT_TYPE.HERO && param[0] == heroQuality;
+        if (!isTarget) { // 触发保底
+            let percent = countFloorPercent(id, floor);
+            let rand = Math.random();
+            if (rand < percent) { // 可以替换为保底
+                if (touchedFloor > 0 && touchedFloor < id) { // 如果已经触发过保底了
+                    // 更新被覆盖掉的那个保底数量
+                    updateUserFloor(floor, touchedFloor, false);
+                }
+                touchedFloor = id;
+                touchedHeroQuality = heroQuality;
+            } else {
+                updateUserFloor(floor, id, false);
+            }
+        } else {
+            updateUserFloor(floor, id, true);
+        }
+    }
+
+    if (touchedFloor > 0) {
+        updateUserFloor(floor, touchedFloor, true);
+        return gameData.gachaContentHero.get(touchedHeroQuality);
+    } else {
+        return base;
+    }
+}
+
+/**
+ * @description 更新玩家保底数据
+ * @param floor 玩家保底数据
+ * @param id 更新的保底类型
+ * @param needReset 是否重置保底
+ */
+function updateUserFloor(floor: Floor[], id: number, needReset: boolean) {
+    let curFloor = floor.find(cur => cur.id == id);
+    if (!curFloor) {
+        curFloor = { id, count: 0 };
+        floor.push(curFloor);
+    }
+    if (needReset) {
+        curFloor.count = 0;
+    } else {
+        curFloor.count++;
+    }
+}
+
+/**
+ * 计算保底概率
+ * @param id 保底类型
+ * @param floor 玩家保底数据
+ */
+function countFloorPercent(id: number, floor: Floor[]) {
+    let curFloor = floor.find(cur => cur.id == id);
+    let count = curFloor ? curFloor.count : 0;
+    // 保底概率，暂时使用线性公式，由策划使用后选择
+    let floorCount = getDicGachaFloor(id);
+    return count / floorCount;
+}
+
+/**
+ * 获取保底武将的品质
+ * @param id 保底类型id in GACHA_FLOOR_TYPE
+ */
+function getHeroQuality(id: number) {
+    if (id == GACHA_FLOOR_TYPE.PURPLE) {
+        return HERO_QUALITY_TYPE.PURPLE;
+    } else if (id == GACHA_FLOOR_TYPE.GOLD) {
+        return HERO_QUALITY_TYPE.GOLD;
+    } else if (id == GACHA_FLOOR_TYPE.ASSIGN) {
+        return 0
+    } else {
+        return false;
+    }
+}
+
+/**
+ * 根据contentId获得抽卡结果（包括心愿单）
+ * @param contentId dic_zyz_gachaContent的id
+ * @param lv 玩家等级
+ * @param hope 玩家心愿单
+ */
+export function getResultFromContentId(contentId: number, lv: number, hope: Hope[]) {
+    let dic = gameData.gachaContent.get(contentId);
+    let { type, param, count } = dic;
+    if (type == GACHA_CONTENT_TYPE.HERO) {
+        let pool: number[] = getPoolByHope(hope, param[0]);
+
+        let hero = getRandEelm(pool);
+        let result = new GachaResult(contentId);
+        result.setHero(hero[0]);
+        return result
+    } else {
+        let pool: number[] = [];
+        if (type == GACHA_CONTENT_TYPE.HERO_PIECE) {
+            pool = getAllItemByQuality(IT_TYPE.HERO_PIECE, param[0], lv);
+        } else if (type == GACHA_CONTENT_TYPE.BLUEPRT) {
+            pool = getAllItemByQuality(IT_TYPE.BLUEPRT, param[0], lv);
+        } else if (type == GACHA_CONTENT_TYPE.JEWEL) {
+            pool = getAllJewelByLv(param[0]);
+        } else if (type == GACHA_CONTENT_TYPE.TERAPH_MATERIAL) {
+            pool = param;
+        } else if (type == GACHA_CONTENT_TYPE.SUIT_PAPER) {
+            pool = getSuitPaper(lv);
+        }
+        let item = getRandEelm(pool);
+        let result = new GachaResult(contentId);
+        result.setItem(item[0], count);
+        return result;
+    }
+}
+
+/**
+ * 心愿
+ * @param hope 玩家数据里的心愿单
+ * @param qualtiy 武将品质
+ */
+function getPoolByHope(hope: Hope[], qualtiy: number) {
+    if (qualtiy == HERO_QUALITY_TYPE.GOLD) {
+        let hopeMap = new Map<number, Hope>();
+        let hasGetHope: number[] = [];
+        for (let h of hope) {
+            if (h.hid > 0) {
+                hopeMap.set(h.id, h);
+                if (h.hasGet) hasGetHope.push(h.id);
+            }
+        }
+
+        let list = gameData.gachaHope.map(cur => {
+            return { ...cur, hasGet: hopeMap.get(cur.id)?.hasGet || false };
+        })
+        let { dic: { id, hasGet } } = getRandEelmWithWeight(list);
+        if (id == 0 || hasGet) {
+            return getAllHeroByQuality(qualtiy).filter(cur => !hasGetHope.includes(cur));
+        } else {
+            if (hopeMap.has(id)) {
+                let curHope = hopeMap.get(id);
+                curHope.hasGet = true;
+                return [curHope.hid];
+            } else {
+                return getAllHeroByQuality(qualtiy).filter(cur => !hasGetHope.includes(cur));
+            }
+        }
+    } else {
+        return getAllHeroByQuality(qualtiy);
+    }
+}
+
+/**
+ * 根据品质获得武将池
+ * @param quality 品质
+ */
+export function getAllHeroByQuality(quality: number) {
+    if (quality == 0) return [GACHA_OCCUPY_HID];
+
+    let allHero: number[] = [];
+    let allQuality: number[] = [];
+    for (let { actorId } of gameData.recruit) {
+        let dicHero = gameData.hero.get(actorId);
+        if (dicHero.quality == quality) {
+            allHero.push(actorId);
+        }
+        if (allQuality.indexOf(dicHero.quality) == -1) allQuality.push(dicHero.quality);
+    }
+    allQuality.sort((a, b) => a - b);
+    if (allQuality.length == 0) return [];
+    if (allHero.length == 0) {
+        allHero = getAllHeroByQuality(allQuality[0]);
+    }
+    return allHero;
+}
+
+function getAllItemByQuality(itid: number, quality: number, lv: number) {
+    let allPiece: number[] = [];
+    for (let [id, dicGoods] of gameData.goods) {
+        if (dicGoods.itid == itid) {
+            if ((quality == 0 || dicGoods.quality == quality) || dicGoods.lvLimited <= lv) {
+                allPiece.push(id);
+            }
+        }
+    }
+    return allPiece;
+}
+
+function getAllJewelByLv(lv: number) {
+    let itids: number[] = [];
+    for (let [id, { type }] of ITID) {
+        if (type == CONSUME_TYPE.JEWEL) itids.push(id);
+    }
+    let items: number[] = [];
+    for (let [id, dicGoods] of gameData.goods) {
+        if (itids.includes(dicGoods.itid)) {
+            if (lv == 0 || dicGoods.lvLimited == lv) {
+                items.push(id);
+            }
+        }
+    }
+    return items;
+}
+
+function getSuitPaper(lv: number) {
+    let items: number[] = [];
+    for (let [id, dicGoods] of gameData.goods) {
+        if (dicGoods.itid == IT_TYPE.PAPER) {
+            if (dicGoods.lvLimited <= lv) {
+                items.push(id);
+            }
+        }
+    }
+    return items;
+}
@@ -0,0 +1,190 @@
+import { GIFT_PACKAGE_TYPE, ACTIVITY_RESOURCES_TYPE } from '../../consts';
+import { gameData } from '../../pubUtils/data';
+import { addItems, createHeroes } from './../rewardService';
+import { RewardParam } from '../../domain/activityField/rewardField';
+import { CreateHeroParam } from '../../domain/roleField/hero';
+import { DicGiftPackage } from '../../pubUtils/dictionary/DicGiftPackage';
+import { ItemInter, RewardInter } from '../../pubUtils/interface';
+import { decodeArrayListStr } from '../../pubUtils/util';
+
+
+
+/**
+ * 兑换礼包
+ * @param giftID 礼包id
+ * @param roleId 角色id
+ * @param roleName 角色名称
+ * @param giftCount 一共消耗多少个礼包
+ * @param sid 
+ */
+export async function useGiftPackage(roleId: string, roleName: string, sid: string, serverId: number, funcs: number[], giftID: number, selected: Array<number> = [], giftCount: number) {
+    console.log("bbbbbbbb", giftID, selected)
+    let result = { goods: [], addHeros: [] }
+    let giftPackageData = gameData.giftPackage.get(giftID);
+    if (!giftPackageData) {
+        return result
+    }
+    console.log('dddddddddddddd', giftID, JSON.stringify(giftPackageData))
+    let giftType = giftPackageData.type;//礼包类型
+    let reward = giftPackageData.reward;//奖励内容,数组
+    switch (giftType) {
+        case GIFT_PACKAGE_TYPE.ALL://全部
+            {
+                let allReward = [];
+                if (giftCount > 1) {
+                    for (let obj of reward) {
+                        allReward.push({ type: obj.type, id: obj.id, count: obj.count * giftCount })
+                    }
+                } else {
+                    allReward = reward;
+                }
+
+                result = await addReward(roleId, roleName, sid, serverId, funcs, allReward);
+                break;
+            }
+        case GIFT_PACKAGE_TYPE.SELECTED_X://手选
+            {
+                let count = giftPackageData.count;//选择个数
+                if (selected.length != count) {
+                    break;
+                }
+                let selectedReward = getSelectedReward(giftPackageData, selected)
+                let allReward = [];
+                if (giftCount > 1) {
+                    for (let obj of selectedReward) {
+                        allReward.push({ type: obj.type, id: obj.id, count: obj.count * giftCount })
+                    }
+                } else {
+                    allReward = selectedReward;
+                }
+                result = await addReward(roleId, roleName, sid, serverId, funcs, allReward);
+                break;
+            }
+        case GIFT_PACKAGE_TYPE.RANDOM_X://随机
+            {
+                let count = giftPackageData.count;//随机个数
+                let allReward = [];
+                for (let i = 0; i < giftCount; i++) {
+                    let selectedArray = randomSelectedData(giftPackageData.reward.length, count);
+                    let selectedReward = getSelectedReward(giftPackageData, selectedArray)
+                    allReward = allReward.concat(selectedReward);
+                }
+                result = await addReward(roleId, roleName, sid, serverId, funcs, allReward);
+                break;
+            }
+        default:
+            break;
+    }
+
+    return result;
+}
+
+//结算奖励的内容
+export async function addReward(roleId: string, roleName: string, sid: string, serverId: number, funcs: number[], reward: Array<RewardParam>) {
+    let giftReward = rewardItemData(reward);
+    let goodArray = giftReward.goods;
+    let heroArray = giftReward.heroes;
+
+    //兑换物品
+    let goods = await addItems(roleId, roleName, sid, goodArray)
+    let addHeros = [];
+    if (heroArray.length > 0) {
+        let heroResult = await createHeroes(roleId, roleName, sid, serverId, funcs, heroArray);
+        goods = goods.concat(heroResult.goods)
+        addHeros = addHeros.concat(heroResult.heroes);
+    }
+    return { goods, addHeros }
+}
+
+//表中的奖励数据(包括礼包)转换成具体对应奖励物品的实例
+function rewardItemData(reward: Array<RewardParam>) {
+    let goods: Array<RewardInter> = [];
+    let heroes: Array<CreateHeroParam> = [];
+    for (let obj of reward) {
+        switch (obj.type) {
+            case ACTIVITY_RESOURCES_TYPE.HERO:
+                heroes.push({ hid: obj.id, count: obj.count })
+                break;
+            case ACTIVITY_RESOURCES_TYPE.GOODS:
+                goods.push({ id: obj.id, count: obj.count })
+                break;
+            case ACTIVITY_RESOURCES_TYPE.GIFTPACKAGE://配置成礼包会立刻兑换，配置成物品会把礼包放入背包中
+                let goodData = gameData.goods.get(obj.id);//礼包物品
+                let giftPackageData = gameData.giftPackage.get(1)//gameData.giftPackage.get(goodData.gift);//礼包数据
+                let giftReward = rewardItemData(giftPackageData.reward)
+                goods = goods.concat(giftReward.goods)
+                heroes = heroes.concat(giftReward.heroes)
+                break;
+            default:
+                break;
+        }
+    }
+    return { goods, heroes }
+}
+
+export function getSelectedReward(giftData: DicGiftPackage, selected: Array<number>): Array<RewardParam> {
+    console.log('bbbbbbbbbbbbbbbbbbb', JSON.stringify(selected), JSON.stringify(giftData))
+
+    let selectedReward: Array<RewardParam> = [];
+    for (let i = 0; i < selected.length; i++) {
+        let index = selected[i];
+        if (giftData.reward.length > index) {
+            selectedReward.push(giftData.reward[index]);
+        }
+    }
+    return selectedReward;
+}
+
+function randomSelectedData(total: number, count: number) {
+    var selected: number[] = [];    //temp存放生成的随机数组
+    var arr = Array.from({ length: total }, (v, k) => k);
+    for (let i = 0; i < count; i++) {
+        var num = Math.floor(Math.random() * arr.length); //生成随机数num
+        selected.push(arr[num]);    //获取arr[num]并放入temp
+        arr.splice(num, 1);
+    }
+    return selected;
+}
+
+//数据格式转换'类型&id&数量|类型&id&数量|' ->> Array<RewardParam> 活动奖励
+export function stringToRewardParam(rewardStr: string): Array<RewardParam> {
+    let result = new Array<{ type: number, id: number, count: number }>();
+    if (!rewardStr) return result;
+    let decodeArr = decodeArrayListStr(rewardStr);
+    for (let [type, id, count] of decodeArr) {
+        if (isNaN(parseInt(type)) || isNaN(parseInt(id)) || isNaN(parseInt(count))) {
+            throw new Error('data table format wrong');
+        }
+        result.push({ type: parseInt(type), id: parseInt(id), count: parseInt(count) });
+    }
+    return result
+}
+
+//数据格式转换'类型&id&数量|类型&id&数量|' ->> Array<ItemInter> 资源消耗
+export function stringToConsumeParam(rewardStr: string): Array<ItemInter> {
+    let result = new Array<{ type: number, id: number, count: number }>();
+    if (!rewardStr) return result;
+    let decodeArr = decodeArrayListStr(rewardStr);
+    for (let [type, id, count] of decodeArr) {
+        if (isNaN(parseInt(type)) || isNaN(parseInt(id)) || isNaN(parseInt(count))) {
+            throw new Error('data table format wrong');
+        }
+        result.push({ type: parseInt(type), id: parseInt(id), count: parseInt(count) });
+    }
+    return result
+}
+
+//数据格式转换'id&数量|id&数量|' ->> Array<RewardInter> 老资源格式
+export function stringToRewardInter(rewardStr: string): Array<RewardInter> {
+    let result = new Array<{ id: number, count: number }>();
+    if (!rewardStr) return result;
+    let decodeArr = decodeArrayListStr(rewardStr);
+    for (let [type, id, count] of decodeArr) {
+        if (isNaN(parseInt(id)) || isNaN(parseInt(count))) {
+            throw new Error('data table format wrong');
+        }
+        result.push({ id: parseInt(id), count: parseInt(count) });
+    }
+    return result
+}
+
@@ -0,0 +1,143 @@
+import { ACTIVITY_TYPE, STATUS, TASK_TYPE } from '../../consts';
+import { ActivityModel, ActivityModelType } from '../../db/Activity';
+import { ActivityGrowthFundModel, ActivityGrowthFundModelType } from '../../db/ActivityGrowthFund';
+import { ActivityBuyRecordsModel, ActivityBuyRecordsModelType } from '../../db/ActivityBuyRecords';
+import { RoleModel } from '../../db/Role';
+import { GrowthFundData, GrowthFundItem } from '../../domain/activityField/growthFundField';
+import { ServerlistModel } from '../../db/Serverlist';
+
+/**
+   * 获取活动数据
+   *
+   * @param {number} serverId 区Id
+   * @param {number} type 活动类型 ACTIVITY_TYPE
+   * @param {string} roleId 角色Id
+   *
+   */
+/*ACTIVITY_TYPE类型
+  GROWTH_FUND_MAIN = 6, // 主线成长基金
+  GROWTH_FUND_MAIN_VIP = 7, // 主线成长基金（高阶）
+  GROWTH_FUND_TOWER = 8, // 镇念塔成长基金
+  GROWTH_FUND_TOWER_VIP = 9, // 镇念塔成长基金（高阶）
+  GROWTH_FUND_MAIN_ELITE = 10, // 精英成长基金
+  GROWTH_FUND_MAIN_ELITE_VIP = 11, // 精英成长基金（高阶）
+*/
+export async function growthFundActivity(type: number, serverId: number, roleId: string) {
+    let { activityGroupId } = await ServerlistModel.findByServerId(serverId);
+    let activityArray: ActivityModelType[] = await ActivityModel.findOpenActivityByType(activityGroupId, type, new Date())
+    if (activityArray.length == 0) {
+        return null;
+    }
+    let activityData = activityArray[0]
+    let playerData = await getPlayerGrowthFundData(activityData.activityId, serverId, roleId);
+    if (playerData.isComplete()) {
+        return null;
+    }
+    return playerData;
+}
+
+/**
+   * 玩家活动数据
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   *
+   */
+export async function getPlayerGrowthFundData(activityId: number, serverId: number, roleId: string) {
+    let activityData: ActivityModelType = await ActivityModel.findActivity(activityId);
+    let playerRecords: ActivityGrowthFundModelType[] = await ActivityGrowthFundModel.findData(activityId, roleId);
+
+    let playerData = new GrowthFundData(activityData);
+    playerData.setPlayerRecords(playerRecords);
+    if (playerData.isVipActivity()) {//vip高阶需要购买
+        let buyRecords = await ActivityBuyRecordsModel.findRecordsByActivityId(activityData.activityId, roleId);
+        playerData.initBuyRecords(buyRecords);
+    }
+
+    let activityType = activityData.type;
+    switch (activityType) {
+        case ACTIVITY_TYPE.GROWTH_FUND_MAIN://主线
+        case ACTIVITY_TYPE.GROWTH_FUND_MAIN_VIP://主线vip
+            {
+                let role = await RoleModel.findByRoleId(roleId);
+                let { warStar = new Array<{ id: number, warType: number, star: number }>() } = role;
+                let warIDs = warStar.map(cur => cur.id);
+                for (let page of playerData.list) {
+                    for (let item of page.items) {
+                        if (item.taskType == TASK_TYPE.BATTLE_MAIN) {
+                            let index = warIDs.findIndex(id => { return id === item.taskParamArray[1] })
+                            if (index != -1) {
+                                item.isComplete = true;
+                            }
+                        }
+                    }
+                }
+                break;
+            }
+        case ACTIVITY_TYPE.GROWTH_FUND_TOWER://镇念塔
+        case ACTIVITY_TYPE.GROWTH_FUND_TOWER_VIP:////镇念塔vip 
+            {
+                let { towerLv } = await RoleModel.findByRoleId(roleId);
+                for (let page of playerData.list) {
+                    for (let item of page.items) {
+                        if (item.taskType == TASK_TYPE.BATTLE_TOWER_LV) {
+                            if (towerLv >= item.condition) {
+                                item.isComplete = true;
+                            }
+                        }
+                    }
+                }
+                break;
+            }
+        case ACTIVITY_TYPE.GROWTH_FUND_MAIN_ELITE: //精英
+        case ACTIVITY_TYPE.GROWTH_FUND_MAIN_ELITE_VIP: //精英VIP
+            {
+                let { mainEliteWarId } = await RoleModel.findByRoleId(roleId);
+                for (let page of playerData.list) {
+                    for (let item of page.items) {
+                        if (item.taskType == TASK_TYPE.BATTLE_MAIN_ELITE) {
+                            if (mainEliteWarId >= item.taskParamArray[1]) {
+                                item.isComplete = true;
+                            }
+                        }
+                    }
+                }
+                break;
+            }
+        default:
+            break;
+    }
+    return playerData;
+}
+
+
+
+
+/**
+   * 购买高阶版
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   * @param {string} productID 商品ID
+   *
+   */
+export async function makeGrowthFund(roleId: string, roleName: string, sid: string, serverId: number, funcs: number[],
+    activityId: number, productID: string) {
+    let activityData: ActivityModelType = await ActivityModel.findActivity(activityId);
+    if (!activityData) {
+        return STATUS.ACTIVITY_MISSING;
+    }
+    if (activityData.type !== ACTIVITY_TYPE.GROWTH_FUND_MAIN_VIP && activityData.type !== ACTIVITY_TYPE.GROWTH_FUND_TOWER_VIP && activityData.type !== ACTIVITY_TYPE.GROWTH_FUND_MAIN_ELITE_VIP) {
+        return STATUS.ACTIVITY_TYPE_ERROR;
+    }
+    let playerData = new GrowthFundData(activityData);
+    let pageData = playerData.findPageByProductID(productID);
+    let pageIndex = pageData.pageIndex;
+    await ActivityBuyRecordsModel.addRecord(activityId, roleId, activityData.type, pageIndex, true);
+    return {
+        code: 0,
+        data: Object.assign({}, { item: { pageIndex }, activityId: activityId })
+    }
+}
@@ -0,0 +1,55 @@
+import { ACTIVITY_TYPE } from '../../consts';
+import { ActivityModel, ActivityModelType } from '../../db/Activity';
+import { ActivityGrowthModel, ActivityGrowthModelType } from '../../db/ActivityGrowth';
+import { ActivityGrowthPointModel, ActivityGrowthPointModelType } from '../../db/ActivityGrowthPoint';
+import { HeroModel } from '../../db/Hero';
+import { ServerlistModel } from '../../db/Serverlist';
+import { GrowthData, GrowthItem } from '../../domain/activityField/growthField';
+
+/**
+   * 获取活动数据
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   *
+   */
+export async function growthActivity(serverId: number, roleId: string) {
+    let { activityGroupId } = await ServerlistModel.findByServerId(serverId);
+    let activityDataArray: ActivityModelType[] = await ActivityModel.findOpenActivityByType(activityGroupId, ACTIVITY_TYPE.TASK_GROWTH, new Date());
+    if (activityDataArray.length === 0) {
+        return null;
+    }
+    let activityData: ActivityModelType = activityDataArray[0];
+    let playerRecords: ActivityGrowthModelType[] = await ActivityGrowthModel.findData(serverId, activityData.activityId, roleId);
+    let playerPointRecord: ActivityGrowthPointModelType = await ActivityGrowthPointModel.findData(serverId, activityData.activityId, roleId);
+
+    let userHeroes = await HeroModel.findByRole(roleId);
+    let playerData = new GrowthData(activityData);
+    await playerData.setPlayerRecords(playerRecords, roleId, userHeroes);
+    playerData.setPlayerPointRecord(playerPointRecord);
+    return playerData;
+}
+
+/**
+   * 玩家活动数据
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   *
+   */
+export async function getPlayerGrowthData(activityId: number, serverId: number, roleId: string) {
+    let activityData: ActivityModelType = await ActivityModel.findActivity(activityId);
+    let playerRecords: ActivityGrowthModelType[] = await ActivityGrowthModel.findData(serverId, activityId, roleId);
+    let playerPointRecord: ActivityGrowthPointModelType = await ActivityGrowthPointModel.findData(serverId, activityId, roleId);
+
+    let userHeroes = await HeroModel.findByRole(roleId);
+
+    let playerData = new GrowthData(activityData);
+    await playerData.setPlayerRecords(playerRecords, roleId, userHeroes);
+    playerData.setPlayerPointRecord(playerPointRecord);
+    return playerData;
+}
+
+
@@ -0,0 +1,136 @@
+import moment = require('moment');
+import { ACTIVITY_TYPE, STATUS, TASK_TYPE } from '../../consts';
+import { ActivityModel, ActivityModelType } from '../../db/Activity';
+import { ActivityShopModel, ActivityShopModelType } from '../../db/ActivityShop';
+import { RoleModel } from '../../db/Role';
+import { ServerlistModel } from '../../db/Serverlist';
+import { LimitShopData, ShopItem } from '../../domain/activityField/limitShopField';
+import { deltaDays } from '../../pubUtils/util';
+import { addReward, stringToRewardParam } from './giftPackageService';
+
+/**
+   * 获取新手玩家限购礼包活动数据  新手限定作为开服七天乐的延伸礼包。只存在于开服前七天，七天时间过去，玩家无法购买
+   *
+   * @param {number} serverId 区Id
+   * @param {number} type 活动类型 ACTIVITY_TYPE
+   * @param {string} roleId 角色Id
+   *
+   */
+
+export async function newPlayerLimitPackageActivity(serverId: number, roleId: string) {
+    let { activityGroupId } = await ServerlistModel.findByServerId(serverId);
+    let activityArray: ActivityModelType[] = await ActivityModel.findOpenActivityByType(activityGroupId, ACTIVITY_TYPE.NEW_PLAYER_LIMIT_PACKAGE, new Date)
+    if (activityArray.length == 0) {
+        return null;
+    }
+    let activityData = activityArray[0];
+    let playerData = new LimitShopData(activityData);
+
+    let playerRecord: ActivityShopModelType = await ActivityShopModel.findData(activityData.activityId, roleId, playerData.roundIndex);
+    playerData.setPlayerRecords(playerRecord);
+    return playerData;
+}
+
+/**
+   * 每日、每周限购礼包活动数据
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   *
+   */
+export async function getPlayerLimitPackageData(activityId: number, serverId: number, roleId: string) {
+    let activityData: ActivityModelType = await ActivityModel.findActivity(activityId);
+    let playerData = new LimitShopData(activityData);
+
+    let playerRecord: ActivityShopModelType = await ActivityShopModel.findData(activityId, roleId, playerData.roundIndex);
+    playerData.setPlayerRecords(playerRecord);
+    return playerData;
+}
+
+
+/**
+   * 获取每日/每周限购礼包数据
+   *
+   * @param {number} serverId 区Id
+   * @param {number} type 活动类型 ACTIVITY_TYPE
+   * @param {string} roleId 角色Id
+   *
+   */
+
+export async function limitPackageActivity(serverId: number, roleId: string, type: number) {
+    let { activityGroupId } = await ServerlistModel.findByServerId(serverId);
+    let activityArray: ActivityModelType[] = await ActivityModel.findOpenActivityByType(activityGroupId, type, new Date)
+    activityArray = activityArray.sort((a, b) => {
+        return b.activityId - a.activityId
+    });
+    if (activityArray.length == 0) {
+        return null;
+    }
+    let activityData = activityArray[0];
+    let playerData = await getPlayerLimitPackageData(activityData.activityId, serverId, roleId);
+    return playerData
+}
+
+/**
+   * 玩家活动第几天
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   *
+   */
+export async function newPlayerActivityDays(roleId: string) {
+    let { createTime } = await RoleModel.findByRoleId(roleId);
+    let createDate = moment(createTime * 1000).toDate();
+    let todayIndex = deltaDays(moment(createDate).startOf('d').toDate(), new Date) + 1;
+    return todayIndex;
+}
+
+
+
+
+/**
+   * 结算购买的奖励
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   * @param {string} productID 商品ID
+   *
+   */
+export async function makeLimitPackageReward(roleId: string, roleName: string, sid: string, serverId: number, funcs: number[],
+    activityId: number, productID: string) {
+    let activityData: ActivityModelType = await ActivityModel.findActivity(activityId);
+    if (!activityData) {
+        return STATUS.ACTIVITY_MISSING;
+    }
+    if (activityData.type !== ACTIVITY_TYPE.NEW_PLAYER_LIMIT_PACKAGE &&
+        activityData.type !== ACTIVITY_TYPE.LIMIT_PACKAGE_SHOP_DAILY &&
+        activityData.type !== ACTIVITY_TYPE.LIMIT_PACKAGE_SHOP_WEEKLY) {
+        return STATUS.ACTIVITY_TYPE_ERROR;
+    }
+    let playerData = new LimitShopData(activityData);
+
+    let playerRecord: ActivityShopModelType = await ActivityShopModel.findData(activityData.activityId, roleId, playerData.roundIndex);
+    playerData.setPlayerRecords(playerRecord);
+
+    let item = playerData.findItemByProductID(productID);
+    if (!item) {
+        return STATUS.ACTIVITY_NO_PRODUCT;
+    }
+    if (item.countMax > 0 && item.buyCount >= item.countMax) {
+        return STATUS.ACTIVITY_MAX_COUNT;
+    }
+
+    let rewardArray = stringToRewardParam(item.reward)
+    let result = await addReward(roleId, roleName, sid, serverId, funcs, rewardArray);
+
+    await ActivityShopModel.addRecord(activityId, roleId, playerData.roundIndex, item.id);
+
+    item.buyCount += 1;
+    return {
+        code: 0,
+        data: Object.assign(result, { item: item, activityId: activityId })
+    }
+}
@@ -0,0 +1,64 @@
+import { ACTIVITY_TYPE } from '../../consts';
+import { ActivityModel, ActivityModelType } from '../../db/Activity';
+import { ActivityMonopolyModel, ActivityMonopolyModelType } from '../../db/ActivityMonopoly';
+import { ActivityMonopolyLandModel, ActivityMonopolyLandModelType } from '../../db/ActivityMonopolyLand';
+import { ServerlistModel } from '../../db/Serverlist';
+import { MonopolyData, LandItem } from '../../domain/activityField/monopolyField';
+
+
+/**
+   * 获取活动数据
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   *
+   */
+export async function getMonopolyActivity(serverId: number, roleId: string) {
+    let { activityGroupId } = await ServerlistModel.findByServerId(serverId);
+    let activityDataArray: ActivityModelType[] = await ActivityModel.findOpenActivityByType(activityGroupId, ACTIVITY_TYPE.MONOPOLY, new Date());
+    if (activityDataArray.length === 0) {
+        return null;
+    }
+    let activityData: ActivityModelType = activityDataArray[0];
+    let playerMonopolyData: ActivityMonopolyModelType = await ActivityMonopolyModel.findData(serverId, activityData.activityId, roleId);
+    let playerLandData: ActivityMonopolyLandModelType[] = await ActivityMonopolyLandModel.findData(serverId, activityData.activityId, roleId);
+    let playerData = new MonopolyData(activityData);
+    playerData.setPlayerRecords(playerMonopolyData, playerLandData);
+    return playerData;
+}
+
+
+/**
+   * 玩家玩家活动数据
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   *
+   */
+export async function getPlayerMonopolyData(activityId: number, serverId: number, roleId: string) {
+    let activityData: ActivityModelType = await ActivityModel.findActivity(activityId);
+    if (!activityData) {
+        return null;
+    }
+    let playerMonopolyData: ActivityMonopolyModelType = await ActivityMonopolyModel.findData(serverId, activityData.activityId, roleId);
+    let playerLandData: ActivityMonopolyLandModelType[] = await ActivityMonopolyLandModel.findData(serverId, activityData.activityId, roleId);
+    let playerData = new MonopolyData(activityData);
+    playerData.setPlayerRecords(playerMonopolyData, playerLandData);
+    return playerData;
+}
+
+/**
+   * 玩家玩家活动数据
+   *
+   * @param {number} position 当前位置
+   * @param {number} addStep 移动步数
+   * @param {number} max 最大位置
+   *
+   */
+export function nextPosition(position: number, addStep: number, max: number) {
+    let temp = (position + addStep) % max;
+    return (temp == 0) ? max : temp;
+}
+
@@ -0,0 +1,134 @@
+import { ACTIVITY_TYPE, MAIL_TYPE, STATUS, TASK_TYPE } from '../../consts';
+import { ActivityModel, ActivityModelType } from '../../db/Activity';
+import { ActivityMonthlyTicketModel, ActivityMonthlyTicketModelType } from '../../db/ActivityMonthlyTicket';
+import { RewardParam } from '../../domain/activityField/rewardField';
+import { MonthlyTicketData } from '../../domain/activityField/monthlyTicketField';
+import { addReward, stringToRewardInter, stringToRewardParam } from './giftPackageService';
+import moment = require('moment');
+import { ServerlistModel } from '../../db/Serverlist';
+import { getMailContent } from './../mailService';
+import { MailModel, MailType } from '../../db/Mail';
+import { pushMail } from '../../pubUtils/interface';
+import { pinus } from 'pinus';
+import { resResult } from '../../pubUtils/util';
+
+/**
+   * 获取活动数据
+   *
+   * @param {number} serverId 区Id
+   * @param {number} type 活动类型 ACTIVITY_TYPE
+   * @param {string} roleId 角色Id
+   *
+   */
+
+export async function monthlyTicketActivity(serverId: number, roleId: string, type: number) {
+    let { activityGroupId } = await ServerlistModel.findByServerId(serverId);
+    let activityArray: ActivityModelType[] = await ActivityModel.findOpenActivityByType(activityGroupId, type, new Date())
+    activityArray = activityArray.sort((a, b) => {
+        return b.activityId - a.activityId
+    });
+    if (activityArray.length == 0) {
+        return null;
+    }
+    let activityData = activityArray[0];
+    let playerRecord: ActivityMonthlyTicketModelType = await ActivityMonthlyTicketModel.findMonthlyTicket(serverId, roleId, activityData.activityId);
+    let playerData = new MonthlyTicketData(activityData);
+    playerData.setPlayerRecords(playerRecord);
+
+    if ((playerData.price > 0 && playerData.isOpen) || playerData.price === 0) {
+        if (playerData.todayIndex - 1 > playerData.dayIndex) {//过期还没领取
+            //下发邮件奖励
+            let mails = new Array<MailType>();
+            let pushMessage = new Array<pushMail>();
+            for (let i = playerData.dayIndex + 1; i < playerData.todayIndex; i++) {
+                let goods = stringToRewardInter(playerData.baseReward)
+                await getMailContent(roleId, MAIL_TYPE.MONTHLY_REWARD, [], goods, mails, pushMessage);
+            }
+
+            await MailModel.addMails(mails);
+            pushMessage.forEach(({ route, data, uids }) => {
+                pinus.app.channelService.pushMessageByUids(route, resResult(STATUS.SUCCESS, { mails: data }), uids);
+            });
+            await ActivityMonthlyTicketModel.setDayIndex(serverId, roleId, playerData.activityId, playerData.todayIndex - 1);
+            playerData.dayIndex = playerData.todayIndex - 1;
+        }
+    }
+    return playerData;
+}
+
+/**
+   * 玩家活动数据
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   *
+   */
+export async function getPlayerMonthlyTicketData(activityId: number, serverId: number, roleId: string) {
+    let activityData: ActivityModelType = await ActivityModel.findActivity(activityId);
+    let playerRecord: ActivityMonthlyTicketModelType = await ActivityMonthlyTicketModel.findMonthlyTicket(serverId, roleId, activityId);
+    let playerData = new MonthlyTicketData(activityData);
+    playerData.setPlayerRecords(playerRecord);
+    return playerData;
+}
+
+/**
+   * 玩家月卡当天的奖励
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   *
+   */
+export async function getPlayerMonthlyTicketDayReward(roleId: string, roleName: string, sid: string, serverId: number, funcs: number[],
+    activityId: number,) {
+    let activityData: ActivityModelType = await ActivityModel.findActivity(activityId);
+    let playerData = new MonthlyTicketData(activityData);
+
+    let playerRecord: ActivityMonthlyTicketModelType = await ActivityMonthlyTicketModel.findMonthlyTicket(serverId, roleId, activityId);
+    if (playerData.price > 0 && !playerRecord) {//没有购买过
+        return null;
+    }
+
+    playerData.setPlayerRecords(playerRecord);
+    if ((playerData.price > 0 && playerData.isOpen) || playerData.price == 0) {
+        if (playerData.todayIndex > playerData.dayIndex) {//今天还没领取
+            await ActivityMonthlyTicketModel.setDayIndex(serverId, roleId, activityId, playerData.todayIndex);
+            let rewardParamArr: Array<RewardParam> = stringToRewardParam(playerData.baseReward);
+            let result = await addReward(roleId, roleName, sid, serverId, funcs, rewardParamArr)
+            return result
+        }
+    }
+    return null
+}
+
+/**
+   * 结算首次购买月卡的奖励
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   * @param {string} productID 商品ID
+   *
+   */
+export async function makeMonthlyTicketReward(roleId: string, roleName: string, sid: string, serverId: number, funcs: number[],
+    activityId: number, productID: string) {
+    let activityData: ActivityModelType = await ActivityModel.findActivity(activityId);
+    if (activityData.type !== ACTIVITY_TYPE.MONTHLY_TICKET_1 && activityData.type !== ACTIVITY_TYPE.MONTHLY_TICKET_2) {
+        return STATUS.ACTIVITY_TYPE_ERROR;
+    }
+
+    let playerData = new MonthlyTicketData(activityData);
+
+    let endTime = moment(new Date()).startOf('d').add(playerData.days, 'day').toDate();
+    console.log('endTime', moment(new Date()).startOf('d'), endTime, playerData.days)
+    await ActivityMonthlyTicketModel.buyMonthlyTicket(serverId, roleId, activityId, activityData.type, endTime)
+
+    let firstReward = playerData.firstReward;
+    let rewardParamArr: Array<RewardParam> = stringToRewardParam(firstReward);
+    let result = await addReward(roleId, roleName, sid, serverId, funcs, rewardParamArr)
+    return {
+        code: 0,
+        data: Object.assign(result, { item: { isOpen: true, todayIndex: 1 }, activityId: activityData.activityId })
+    }
+}
@@ -0,0 +1,55 @@
+import { ACTIVITY_TYPE } from '../../consts';
+import { ActivityModel, ActivityModelType } from '../../db/Activity';
+import { ActivityNewHeroGiftModel, ActivityNewHeroGiftModelType } from '../../db/ActivityNewHeroGift';
+import { NewHeroGiftData } from '../../domain/activityField/newHeroGiftField';
+import { ServerlistModel } from '../../db/Serverlist';
+
+/**
+   * 获取活动数据
+   *
+   * @param {number} serverId 区Id
+   * @param {number} type 活动类型 ACTIVITY_TYPE
+   * @param {string} roleId 角色Id
+   *
+   */
+
+export async function getNewHeroGiftsActivity(serverId: number, roleId: string) {
+    let { activityGroupId } = await ServerlistModel.findByServerId(serverId);
+    let activityArray: ActivityModelType[] = await ActivityModel.findOpenActivityByType(activityGroupId, ACTIVITY_TYPE.DAILY_RMB_GIFTS, new Date())
+
+    if (activityArray.length == 0) {
+        return null;
+    }
+    let activityData = activityArray[0];
+    let playerData = await getPlayerNewHeroGiftsData(activityData.activityId, serverId, roleId);
+    return playerData
+}
+
+/**
+   * 玩家活动数据
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   *
+   */
+export async function getPlayerNewHeroGiftsData(activityId: number, serverId: number, roleId: string) {
+    let activityData: ActivityModelType = await ActivityModel.findActivity(activityId);
+
+    let playerData = new NewHeroGiftData(activityData);
+    let playerRecord: ActivityNewHeroGiftModelType = await ActivityNewHeroGiftModel.findData(serverId, activityId, roleId);
+    playerData.setPlayerRecords(playerRecord);
+    return playerData;
+}
+
+/**
+   * 任务活动完成后会获得点数
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   *
+   */
+export async function newHeroGiftPoint(serverId: number, activityId: number, roleId: string, addPoint: number) {
+    await ActivityNewHeroGiftModel.addPoint(serverId, activityId, roleId, addPoint);
+}
@@ -0,0 +1,115 @@
+import { ACTIVITY_TYPE, STATUS, TASK_TYPE } from '../../consts';
+import { ActivityModel, ActivityModelType } from '../../db/Activity';
+import { PopUpShopData, } from '../../domain/activityField/popUpShopField';
+import { RewardParam } from '../../domain/activityField/rewardField';
+import { addReward, stringToRewardParam } from './giftPackageService';
+import { ActivityPopUpShopModel, ActivityPopUpShopModelType } from '../../db/ActivityPopUpShop';
+import { ServerlistModel } from '../../db/Serverlist';
+import moment = require('moment');
+
+/**
+   * 获取活动数据
+   *
+   * @param {number} serverId 区Id
+   * @param {number} type 活动类型 ACTIVITY_TYPE
+   * @param {string} roleId 角色Id
+   *
+   */
+
+export async function popUpShopActivity(serverId: number, roleId: string) {
+    let { activityGroupId } = await ServerlistModel.findByServerId(serverId);
+    let activityArray: ActivityModelType[] = await ActivityModel.findOpenActivityByType(activityGroupId, ACTIVITY_TYPE.POP_UP_SHOP, new Date())
+
+    if (activityArray.length == 0) {
+        return null;
+    }
+    let activityData = activityArray[0];
+    let playerData = await getPlayerPopUpShopData(activityData.activityId, serverId, roleId);
+    return playerData
+}
+
+/**
+   * 玩家活动数据
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   *
+   */
+export async function getPlayerPopUpShopData(activityId: number, serverId: number, roleId: string) {
+    let activityData: ActivityModelType = await ActivityModel.findActivity(activityId);
+    let playerRecords: ActivityPopUpShopModelType[] = await ActivityPopUpShopModel.findAllOpenData(serverId, activityId, roleId);
+
+    let allPlayerShop = [];
+    let allTaskData = JSON.parse(activityData.data);
+    for (let record of playerRecords) {
+        if (record.isPush) {//没有购买
+            let index = allTaskData.findIndex(obj => { return obj && obj.id === record.id && obj.taskType === record.type })
+            if (index != -1) {
+                let playerData = new PopUpShopData(allTaskData[index], activityData.activityId);
+                playerData.setPlayerRecords(record)
+                if (playerData.buyCount < allTaskData[index].count) {
+                    allPlayerShop.push(playerData)
+                }
+            }
+        }
+    }
+    return allPlayerShop;
+}
+
+/**
+   * 结算购买礼包的奖励
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   * @param {string} productID 商品ID
+   *
+   */
+export async function makePopUpShopReward(roleId: string, roleName: string, sid: string, serverId: number, funcs: number[],
+    activityId: number, productID: string, paramStr: string) {
+    if (!paramStr) {
+        return STATUS.ORDER_PARAM_ERROR;
+    }
+    let paramObj = JSON.parse(paramStr);
+    let beginTime = moment(paramObj.beginTimeStamp).toDate();
+
+    let activityData: ActivityModelType = await ActivityModel.findActivity(activityId);
+    if (!activityData) {
+        return STATUS.ACTIVITY_MISSING;
+    }
+    if (activityData.type !== ACTIVITY_TYPE.POP_UP_SHOP) {
+        return STATUS.ACTIVITY_TYPE_ERROR;
+    }
+    let allTaskData: any[] = JSON.parse(activityData.data);
+    let taskIndex = allTaskData.findIndex(obj => { return obj && obj.productID == productID });
+    if (taskIndex == -1) {
+        return STATUS.ACTIVITY_NO_PRODUCT;
+    }
+    let playerData = new PopUpShopData(allTaskData[taskIndex], activityId);
+    let playerRecord: ActivityPopUpShopModelType = await ActivityPopUpShopModel.findDataByBeginTime(serverId, activityId, roleId, playerData.id, playerData.taskType, beginTime);
+    if (!playerRecord) {
+        return STATUS.APPLY_ORDER_ERROR;
+    }
+    let curDate = new Date();
+    if (curDate < playerRecord.beginTime || curDate > playerRecord.endTime) {
+        return STATUS.ACTIVITY_POP_UP_SHOP_CLOSED;
+    }
+    if (playerRecord.totalCount < playerData.condition) {
+        return STATUS.ACTIVITY_TASK_UNCOMPLETED;
+    }
+    if (playerRecord.buyCount >= playerData.count) {
+        return STATUS.ACTIVITY_REWARDED;
+    }
+    playerRecord = await ActivityPopUpShopModel.addRecord(serverId, activityId, roleId, playerData.id, playerData.taskType, 1, beginTime);
+    playerData.setPlayerRecords(playerRecord);
+
+    let rewardParamArr: Array<RewardParam> = stringToRewardParam(playerData.reward);
+    let result = await addReward(roleId, roleName, sid, serverId, funcs, rewardParamArr)
+
+
+    return {
+        code: 0,
+        data: Object.assign(result, { item: playerData, activityId: activityData.activityId })
+    }
+}
@@ -0,0 +1,68 @@
+import { ACTIVITY_TYPE, TASK_TYPE } from '../../consts';
+import { ActivityModel, ActivityModelType } from '../../db/Activity';
+import { ActivityRechargeMoneyModel, ActivityRechargeMoneyModelType } from '../../db/ActivityRechargeMoney';
+import { RechargeMoneyData, RechargeMoneyItem } from '../../domain/activityField/rechargeMoneyField';
+import moment = require('moment');
+import { ServerlistModel } from '../../db/Serverlist';
+
+/**
+   * 获取活动数据
+   *
+   * @param {number} serverId 区Id
+   * @param {number} type 活动类型 ACTIVITY_TYPE
+   * @param {string} roleId 角色Id
+   *
+   */
+
+export async function rechargeMoneyActivity(serverId: number, roleId: string) {
+    let { activityGroupId } = await ServerlistModel.findByServerId(serverId);
+    let activityArray: ActivityModelType[] = await ActivityModel.findOpenActivityByType(activityGroupId, ACTIVITY_TYPE.RECHARGE_MONEY, new Date())
+
+    let activityData = activityArray[0];
+    let playerRecord: ActivityRechargeMoneyModelType[] = await ActivityRechargeMoneyModel.findData(serverId, roleId);
+    let playerData = new RechargeMoneyData(activityData);
+    playerData.setPlayerRecords(playerRecord);
+    delete playerData.recordArray;
+    return playerData;
+
+    // let playerDataArray = [];
+    // for (let activityData of activityArray) {
+    //     let playerData = await getPlayerRechargeMoneyData(activityData.activityId, serverId, roleId);
+    //     playerDataArray.push(playerData)
+    // }
+    // return playerDataArray
+}
+
+/**
+   * 玩家活动数据
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   *
+   */
+export async function getPlayerRechargeMoneyData(activityId: number, serverId: number, roleId: string) {
+    let activityData: ActivityModelType = await ActivityModel.findActivity(activityId);
+    let playerRecord: ActivityRechargeMoneyModelType[] = await ActivityRechargeMoneyModel.findData(serverId, roleId);
+
+    let playerData = new RechargeMoneyData(activityData);
+    playerData.setPlayerRecords(playerRecord);
+    return playerData;
+}
+
+
+
+/**
+   * 统计充值金额
+   *
+   * @param {number} serverId 区Id
+   * @param {string} roleId 角色Id
+   * @param {string} RMB 金额
+   *
+   */
+export async function addRechargeMoney(roleId: string, serverId: number, RMB: number) {
+    let beginTime = moment(new Date()).startOf('d').toDate();
+    let endTime = moment(new Date()).endOf('d').toDate();
+    await ActivityRechargeMoneyModel.addRMB(serverId, roleId, RMB, beginTime, endTime);
+}
+
@@ -0,0 +1,131 @@
+import moment = require('moment');
+import { ACTIVITY_TYPE, STATUS, TASK_TYPE } from '../../consts';
+import { ActivityModel, ActivityModelType } from '../../db/Activity';
+import { ActivityRefreshShopModel, ActivityRefreshShopModelType } from '../../db/ActivityRefreshShop';
+import { RoleModel } from '../../db/Role';
+import { ServerlistModel } from '../../db/Serverlist';
+import { RefreshShopData, RefreshShopItem } from '../../domain/activityField/refreshShopField';
+import { deltaDays } from '../../pubUtils/util';
+import { addReward, stringToRewardParam } from './giftPackageService';
+
+/**
+   * 
+   *
+   * @param {number} serverId 区Id
+   * @param {number} type 活动类型 ACTIVITY_TYPE
+   * @param {string} roleId 角色Id
+   *
+   */
+
+export async function getRefreshShopActivity(serverId: number, roleId: string) {
+    let { activityGroupId } = await ServerlistModel.findByServerId(serverId);
+    let activityArray: ActivityModelType[] = await ActivityModel.findOpenActivityByType(activityGroupId, ACTIVITY_TYPE.REFRESH_SHOP, new Date)
+    if (activityArray.length == 0) {
+        return null;
+    }
+    let activityData = activityArray[0];
+    let playerData = new RefreshShopData(activityData);
+
+    let playerRecord: ActivityRefreshShopModelType = await ActivityRefreshShopModel.findData(activityData.activityId, roleId, playerData.roundIndex);
+    playerData.setPlayerRecords(playerRecord);
+    return playerData;
+}
+
+/**
+   * 玩家商店数据
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   *
+   */
+export async function getPlayerRefreshShopData(activityId: number, serverId: number, roleId: string) {
+    let activityData: ActivityModelType = await ActivityModel.findActivity(activityId);
+    let playerData = new RefreshShopData(activityData);
+
+    let playerRecord: ActivityRefreshShopModelType = await ActivityRefreshShopModel.findData(activityId, roleId, playerData.roundIndex);
+    playerData.setPlayerRecords(playerRecord);
+    return playerData;
+}
+
+/**
+   * 玩家商店数据(指定回合数，大富翁商店每回合刷新)
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   *
+   */
+export async function getPlayerRefreshShopDataByRoundIndex(activityId: number, serverId: number, roleId: string, roundIndex: number) {
+    let activityData: ActivityModelType = await ActivityModel.findActivity(activityId);
+    let playerData = new RefreshShopData(activityData);
+    playerData.roundIndex = roundIndex;
+    let playerRecord: ActivityRefreshShopModelType = await ActivityRefreshShopModel.findData(activityId, roleId, playerData.roundIndex);
+    playerData.setPlayerRecords(playerRecord);
+    return playerData;
+}
+
+/**
+   * 玩家活动第几天
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   *
+   */
+export async function newPlayerActivityDays(roleId: string) {
+    let { createTime } = await RoleModel.findByRoleId(roleId);
+    let createDate = moment(createTime * 1000).toDate();
+    let todayIndex = deltaDays(moment(createDate).startOf('d').toDate(), new Date) + 1;
+    return todayIndex;
+}
+
+
+
+
+/**
+   * 结算购买的奖励
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   * @param {string} productID 商品ID
+   * @param {number} roundIndex 大富翁重置回合数
+   *
+   */
+export async function makeRefreshShopReward(roleId: string, roleName: string, sid: string, serverId: number, funcs: number[],
+    activityId: number, productID: string, roundIndex: number) {
+    let activityData: ActivityModelType = await ActivityModel.findActivity(activityId);
+    if (!activityData) {
+        return STATUS.ACTIVITY_MISSING;
+    }
+    if (activityData.type !== ACTIVITY_TYPE.REFRESH_SHOP) {
+        return STATUS.ACTIVITY_TYPE_ERROR;
+    }
+    let playerData = new RefreshShopData(activityData);
+    if (roundIndex) {
+        playerData.roundIndex = roundIndex;
+    }
+
+    let playerRecord: ActivityRefreshShopModelType = await ActivityRefreshShopModel.findData(activityData.activityId, roleId, playerData.roundIndex);
+    playerData.setPlayerRecords(playerRecord);
+
+    let item = playerData.findItemByProductID(productID);
+    if (!item) {
+        return STATUS.ACTIVITY_NO_PRODUCT;
+    }
+    if (item.countMax > 0 && item.buyCount >= item.countMax) {
+        return STATUS.ACTIVITY_MAX_COUNT;
+    }
+
+    let rewardArray = stringToRewardParam(item.reward)
+    let result = await addReward(roleId, roleName, sid, serverId, funcs, rewardArray);
+
+    await ActivityRefreshShopModel.addRecord(activityId, roleId, playerData.roundIndex, item.pageIndex, item.id);
+
+    item.buyCount += 1;
+    return {
+        code: 0,
+        data: Object.assign(result, { item: item, activityId: activityId })
+    }
+}
@@ -0,0 +1,49 @@
+import { ACTIVITY_TYPE } from '../../consts';
+import { ActivityModel, ActivityModelType } from '../../db/Activity';
+import { ActivityRefreshTaskModel, ActivityRefreshTaskModelType } from '../../db/ActivityRefreshTask';
+import { ActivityRefreshTaskPointModel, ActivityRefreshTaskPointModelType } from '../../db/ActivityRefreshTaskPoint';
+import { ServerlistModel } from '../../db/Serverlist';
+import { RefreshTaskData, RefreshTaskItem } from '../../domain/activityField/refreshTaskField';
+
+
+/**
+   * 获取活动数据
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   *
+   */
+export async function getRefreshTaskActivity(serverId: number, roleId: string) {
+    let { activityGroupId } = await ServerlistModel.findByServerId(serverId);
+    let activityDataArray: ActivityModelType[] = await ActivityModel.findOpenActivityByType(activityGroupId, ACTIVITY_TYPE.REFRESH_TASK, new Date());
+    if (activityDataArray.length === 0) {
+        return null;
+    }
+    let activityData: ActivityModelType = activityDataArray[0];
+    let playerData = new RefreshTaskData(activityData);
+    let playerRecords: ActivityRefreshTaskModelType[] = await ActivityRefreshTaskModel.findData(serverId, activityData.activityId, roleId, playerData.roundIndex);
+    let pointRecordData: ActivityRefreshTaskPointModelType = await ActivityRefreshTaskPointModel.findData(serverId, activityData.activityId, roleId);
+    playerData.setPlayerRecords(playerRecords, pointRecordData);
+    return playerData;
+}
+
+
+/**
+   * 玩家玩家活动数据
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   *
+   */
+export async function getPlayerRefreshTaskData(activityId: number, serverId: number, roleId: string) {
+    let activityData: ActivityModelType = await ActivityModel.findActivity(activityId);
+    let playerData = new RefreshTaskData(activityData);
+    let playerRecords: ActivityRefreshTaskModelType[] = await ActivityRefreshTaskModel.findData(serverId, activityId, roleId, playerData.roundIndex);
+    let pointRecordData: ActivityRefreshTaskPointModelType = await ActivityRefreshTaskPointModel.findData(serverId, activityId, roleId);
+    playerData.setPlayerRecords(playerRecords, pointRecordData);
+    return playerData;
+}
+
+
@@ -0,0 +1,148 @@
+import { ACTIVITY_TYPE, REFRESH_TIME, STATUS } from '../../consts';
+import { ActivityModel, ActivityModelType } from '../../db/Activity';
+import { ActivitySelfServiceGoodsModel, ActivitySelfServiceGoodsModelType } from '../../db/ActivitySelfServiceGoods';
+import { ActivitySelfServiceShopModel, ActivitySelfServiceShopModelType } from '../../db/ActivitySelfServiceShop';
+import { ActivitySelfServiceModel } from '../../db/ActivitySelfService';
+import { ServerlistModel } from '../../db/Serverlist';
+import { RewardParam } from '../../domain/activityField/rewardField';
+import { SelfServiceShopData, SelfServiceShopItem } from '../../domain/activityField/selfServiceShopField';
+import { addReward, getSelectedReward, stringToRewardParam } from './giftPackageService';
+import moment = require('moment');
+
+/**
+   * 获取活动数据
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   *
+   */
+export async function getSelfServiceShopActivityData(serverId: number, roleId: string) {
+    let { activityGroupId } = await ServerlistModel.findByServerId(serverId);
+    let activityArray: ActivityModelType[] = await ActivityModel.findOpenActivityByType(activityGroupId, ACTIVITY_TYPE.SELF_SERVICE_SHOP, new Date())
+    activityArray = activityArray.sort((a, b) => {
+        return b.activityId - a.activityId
+    });
+    if (activityArray.length > 0) {
+        let activityData = activityArray[0];
+        let playerData = await getPlayerActivityData(activityData.activityId, serverId, roleId);
+        return playerData;
+    }
+    return null;
+}
+
+/**
+   * 玩家活动数据
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   *
+   */
+export async function getPlayerActivityData(activityId: number, serverId: number, roleId: string) {
+    let activityData: ActivityModelType = await ActivityModel.findActivity(activityId);
+    let playerData = new SelfServiceShopData(activityData);
+
+    let playerRecords: ActivitySelfServiceShopModelType[] = await ActivitySelfServiceShopModel.findDataByPriceType(serverId, activityId, roleId, playerData.roundIndex);
+
+    playerData.setPlayerRecords(playerRecords);
+    let playerSelfServerData = await ActivitySelfServiceModel.findData(serverId, activityId, roleId, playerData.roundIndex);
+    let buyCount = (playerSelfServerData && playerSelfServerData.unitBuyCount) ? playerSelfServerData.unitBuyCount : 0;
+    playerData.unitBuyCount = buyCount;
+    let challengeBeginTime = null;
+    let challengeEndTime = null;
+    let curDate = moment(new Date());
+    if (curDate.hour() < REFRESH_TIME) {
+        challengeBeginTime = moment(new Date()).startOf('d').add(-1, 'd').add(REFRESH_TIME, 'h').toDate();
+        challengeEndTime = moment(challengeBeginTime).add(1, 'd').toDate()
+    } else {
+        challengeBeginTime = moment(new Date()).startOf('d').add(REFRESH_TIME, 'h').toDate();
+        challengeEndTime = moment(challengeBeginTime).add(1, 'd').toDate()
+    }
+    let records = (playerSelfServerData && playerSelfServerData.challengeRecords) ? playerSelfServerData.challengeRecords : [];
+    for (let record of records) {
+        console.log(challengeBeginTime, challengeEndTime, record.time)
+        if (record.time >= challengeBeginTime && record.time <= challengeEndTime) {
+            playerData.challengeCount++;
+        }
+    }
+
+    return playerData;
+}
+
+/**
+   * 结算礼包
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   * @param {number} roundIndex 周期数
+   * @param {number} index 货架
+   * @param {number} price 价格
+   * @param {number} priceType 价格类型
+   *
+   */
+
+export async function addSelfServiceShopGiftReward(roleId: string, roleName: string, sid: string, serverId: number, funcs: number[], activityId: number, roundIndex: number, index: number, item: SelfServiceShopItem) {
+    let playerGoods: ActivitySelfServiceGoodsModelType[] = await ActivitySelfServiceGoodsModel.findDataByIndex(activityId, roleId, roundIndex, index);
+
+    let rewardArray: Array<RewardParam> = [];
+    for (let obj of playerGoods) {
+        let selectedIndex = obj.rewardIndex;
+        let cellIndex = obj.cellIndex;
+        let giftData = item.findCellIndex(cellIndex);
+        let rewards: Array<RewardParam> = stringToRewardParam(giftData.gift);
+        rewardArray = rewardArray.concat(rewards[selectedIndex])
+    }
+    let goodsStr = '';
+    for (let obj of rewardArray) {
+        goodsStr += `${obj.type}&${obj.id}&${obj.count}|`;
+    }
+    let result = await addReward(roleId, roleName, sid, serverId, funcs, rewardArray);
+    //购买记录
+    console.log('dddddddd', rewardArray.length, serverId, activityId, roleId, roundIndex, index, goodsStr, JSON.stringify(item))
+    await ActivitySelfServiceShopModel.addBuyRecord(serverId, activityId, roleId, roundIndex, index, goodsStr);
+    return result
+}
+
+
+/**
+   * 购买自选礼包
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   * @param {string} productID 商品ID
+   *
+   */
+export async function makeSelfServerShop(roleId: string, roleName: string, sid: string, serverId: number, funcs: number[],
+    activityId: number, productID: string) {
+
+    let activityData: ActivityModelType = await ActivityModel.findActivity(activityId);
+    if (!activityData) {
+        return {
+            code: STATUS.ACTIVITY_MISSING,
+        }
+    }
+    let playerData = new SelfServiceShopData(activityData);
+    let item: SelfServiceShopItem = playerData.getItemByProductID(productID);
+    if (!item) {
+        return {
+            code: STATUS.ACTIVITY_DATA_ERROR,
+        }
+    }
+    if (item.countMax > 0) {//限制购买次数
+        let playerRecords: ActivitySelfServiceShopModelType[] = await ActivitySelfServiceShopModel.findDataByIndex(serverId, activityId, roleId, playerData.roundIndex, item.index);
+        if (playerRecords.length >= item.countMax) {
+            return {
+                code: STATUS.ACTIVITY_MAX_COUNT,
+            }
+        }
+    }
+    let result = await addSelfServiceShopGiftReward(roleId, roleName, sid, serverId, funcs, activityId, playerData.roundIndex, item.index, item);
+    item.buyCount += 1;
+    return {
+        code: 0,
+        data: Object.assign(result, { item })
+    }
+}
@@ -0,0 +1,127 @@
+import { ActivityModel, ActivityModelType } from '../../db/Activity';
+import { ActivityGrowthModel, ActivityGrowthModelType } from '../../db/ActivityGrowth';
+import { ActivityGrowthPointModel, ActivityGrowthPointModelType } from '../../db/ActivityGrowthPoint';
+import { HeroModel } from '../../db/Hero';
+import { ServerlistModel } from '../../db/Serverlist';
+import { SevenDaysData } from '../../domain/activityField/sevenDaysField';
+import { ActivityDailyChallengesModel, ActivityDailyChallengesModelType } from '../../db/ActivityDailyChallenges';
+import { ActivityDailyGiftsModel, ActivityDailyGiftsModelType } from '../../db/ActivityDailyGifts';
+
+/**
+   * 获取活动数据
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   *
+   */
+export async function sevenDaysActivity(serverId: number, roleId: string, type: number) {
+    let { activityGroupId } = await ServerlistModel.findByServerId(serverId);
+    let activityDataArray: ActivityModelType[] = await ActivityModel.findOpenActivityByType(activityGroupId, type, new Date());
+    if (activityDataArray.length === 0) {
+        return null;
+    }
+    let activityData: ActivityModelType = activityDataArray[0];
+
+    let playerData = new SevenDaysData(activityData)
+    //成长数据
+    let playerGrowthRecords: ActivityGrowthModelType[] = await ActivityGrowthModel.findData(serverId, activityData.activityId, roleId);
+    let playerPointRecord: ActivityGrowthPointModelType = await ActivityGrowthPointModel.findData(serverId, activityData.activityId, roleId);
+    let userHeroes = await HeroModel.findByRole(roleId);
+    await playerData.growth.setPlayerRecords(playerGrowthRecords, roleId, userHeroes);
+    playerData.growth.setPlayerPointRecord(playerPointRecord);
+    //今日挑战
+    let playerDailyChallengeRecords: ActivityDailyChallengesModelType[] = await ActivityDailyChallengesModel.findData(serverId, activityData.activityId, roleId);
+    playerData.dailyChallenge.setPlayerRecords(playerDailyChallengeRecords);
+    //每日特惠礼包
+    let playerRecords: ActivityDailyGiftsModelType[] = await ActivityDailyGiftsModel.findData(serverId, activityData.activityId, roleId);
+    playerData.dailyGift.setPlayerRecords(playerRecords);
+
+    return playerData;
+}
+
+/**
+   * 玩家活动数据
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   *
+   */
+export async function getPlayerSevenDaysData(activityId: number, serverId: number, roleId: string) {
+    let activityData: ActivityModelType = await ActivityModel.findActivity(activityId);
+
+    let playerData = new SevenDaysData(activityData)
+    //成长数据
+    let playerGrowthRecords: ActivityGrowthModelType[] = await ActivityGrowthModel.findData(serverId, activityId, roleId);
+    let playerPointRecord: ActivityGrowthPointModelType = await ActivityGrowthPointModel.findData(serverId, activityId, roleId);
+    let userHeroes = await HeroModel.findByRole(roleId);
+    await playerData.growth.setPlayerRecords(playerGrowthRecords, roleId, userHeroes);
+    playerData.growth.setPlayerPointRecord(playerPointRecord);
+    //今日挑战
+    let playerDailyChallengeRecords: ActivityDailyChallengesModelType[] = await ActivityDailyChallengesModel.findData(serverId, activityId, roleId);
+    playerData.dailyChallenge.setPlayerRecords(playerDailyChallengeRecords);
+    //每日特惠礼包
+    let playerRecords: ActivityDailyGiftsModelType[] = await ActivityDailyGiftsModel.findData(serverId, activityId, roleId);
+    playerData.dailyGift.setPlayerRecords(playerRecords);
+    return playerData;
+}
+
+
+/**
+   * 玩家成长数据
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   *
+   */
+export async function getPlayerSevenDaysGrowthData(activityId: number, serverId: number, roleId: string) {
+    let activityData: ActivityModelType = await ActivityModel.findActivity(activityId);
+
+    let playerData = new SevenDaysData(activityData)
+    //成长数据
+    let playerGrowthRecords: ActivityGrowthModelType[] = await ActivityGrowthModel.findData(serverId, activityId, roleId);
+    let playerPointRecord: ActivityGrowthPointModelType = await ActivityGrowthPointModel.findData(serverId, activityId, roleId);
+    let userHeroes = await HeroModel.findByRole(roleId);
+    await playerData.growth.setPlayerRecords(playerGrowthRecords, roleId, userHeroes);
+    playerData.growth.setPlayerPointRecord(playerPointRecord);
+    return playerData;
+}
+
+
+/**
+   * 玩家今日挑战数据
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   *
+   */
+export async function getPlayerSevenDaysDailyChallengesData(activityId: number, serverId: number, roleId: string) {
+    let activityData: ActivityModelType = await ActivityModel.findActivity(activityId);
+
+    let playerData = new SevenDaysData(activityData)
+    //今日挑战
+    let playerDailyChallengeRecords: ActivityDailyChallengesModelType[] = await ActivityDailyChallengesModel.findData(serverId, activityId, roleId);
+    playerData.dailyChallenge.setPlayerRecords(playerDailyChallengeRecords);
+    return playerData;
+}
+
+/**
+   * 玩家每日特惠礼包数据
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   *
+   */
+export async function getPlayerSevenDaysDailyGiftsData(activityId: number, serverId: number, roleId: string) {
+    let activityData: ActivityModelType = await ActivityModel.findActivity(activityId);
+
+    let playerData = new SevenDaysData(activityData)
+    //每日特惠礼包
+    let playerRecords: ActivityDailyGiftsModelType[] = await ActivityDailyGiftsModel.findData(serverId, activityId, roleId);
+    playerData.dailyGift.setPlayerRecords(playerRecords);
+    return playerData;
+}
@@ -0,0 +1,182 @@
+import moment = require('moment');
+import { ACTIVITY_TYPE, REFRESH_TIME, SERVER_OPEN_TIME, SIGNIN_VIP_OPEN_LIMIT, STATUS } from '../../consts';
+import { ActivityModel, ActivityModelType } from '../../db/Activity';
+import { ActivitySignInModel, ActivitySignInModelType } from '../../db/ActivitySignIn';
+import { RoleModel } from '../../db/Role';
+import { ServerlistModel } from '../../db/Serverlist';
+import { SignInData } from '../../domain/activityField/signInField';
+
+/**
+   * 获取活动数据
+   *
+   * @param {number} type 普通、高级 ACTIVITY_TYPE
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   *
+   */
+export async function signInActivity(serverId: number, roleId: string) {
+    let { activityGroupId } = await ServerlistModel.findByServerId(serverId);
+    let activityArray: ActivityModelType[] = await ActivityModel.findOpenActivityByType(activityGroupId, ACTIVITY_TYPE.SIGN_IN, new Date());
+    if (activityArray.length == 0) {
+        return null;
+    }
+    let activityData = activityArray[0];
+    let playerData = new SignInData(activityData);
+    let curDate = moment(new Date()).valueOf();
+    if (curDate < playerData.beginTime || curDate > playerData.endTime) {//未开启
+        return null;
+    }
+    let playerRecords: ActivitySignInModelType = await ActivitySignInModel.findData(activityData.activityId, roleId, playerData.roundIndex);
+    playerData.setPlayerRecords(playerRecords);
+    return playerData;
+}
+
+/**
+   * 获取活动数据
+   *
+   * @param {number} type 普通、高级 ACTIVITY_TYPE
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   *
+   */
+export async function signInVIPActivity(serverId: number, roleId: string) {
+    let { activityGroupId } = await ServerlistModel.findByServerId(serverId);
+    let activityArray: ActivityModelType[] = await ActivityModel.findOpenActivityByType(activityGroupId, ACTIVITY_TYPE.SIGN_IN_VIP, new Date());
+    if (activityArray.length == 0) {
+        return null;
+    }
+    let activityData = activityArray[0];
+    let playerData = new SignInData(activityData);
+
+    let curDate = moment(new Date()).valueOf();
+    if (curDate < playerData.beginTime || curDate > playerData.endTime) {//未开启
+        return null;
+    }
+
+    let playerRecords: ActivitySignInModelType = await ActivitySignInModel.findData(activityData.activityId, roleId, playerData.roundIndex);
+    playerData.setPlayerRecords(playerRecords);
+    return playerData;
+}
+
+/**
+   * 获取活动数据
+   *
+   * @param {number} type  新手签到
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   *
+   */
+export async function newPlayerSignInActivity(serverId: number, roleId: string) {
+    let { activityGroupId } = await ServerlistModel.findByServerId(serverId);
+    let activityArray: ActivityModelType[] = await ActivityModel.findOpenActivityByType(activityGroupId, ACTIVITY_TYPE.NEW_PLAYER_SIGN_IN, new Date());
+
+    if (activityArray.length == 0) {
+        return null;
+    }
+    let activityData = activityArray[0];
+    let playerData = new SignInData(activityData);
+
+    let { createTime } = await RoleModel.findByRoleId(roleId);
+    let betinTime = null;
+    let endTime = null
+    let curDate = moment(createTime * 1000);
+    if (curDate.hour() < REFRESH_TIME) {
+        betinTime = moment(createTime * 1000).startOf('d').add(-1, 'd').add(REFRESH_TIME, 'h').toDate();
+        endTime = moment(betinTime).add(playerData.days, 'd').toDate()
+    } else {
+        betinTime = moment(createTime * 1000).startOf('d').add(REFRESH_TIME, 'h').toDate();
+        endTime = moment(betinTime).add(playerData.days, 'd').toDate()
+    }
+    if (curDate > endTime) {
+        return null;
+    }
+
+
+    playerData.setNewPlayerDate(betinTime, endTime);
+    let curDateStamp = moment(new Date()).valueOf();
+    if (curDateStamp < playerData.beginTime || curDateStamp > playerData.endTime) {//未开启
+        return null;
+    }
+    let playerRecords: ActivitySignInModelType = await ActivitySignInModel.findData(activityData.activityId, roleId, playerData.roundIndex);
+    playerData.setPlayerRecords(playerRecords);
+    return playerData;
+}
+
+/**
+   * 玩家活动数据
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   *
+   */
+export async function getPlayerSignInData(activityId: number, serverId: number, roleId: string) {
+    let activityData: ActivityModelType = await ActivityModel.findActivity(activityId);
+    if (activityData.type !== ACTIVITY_TYPE.SIGN_IN_VIP && activityData.type !== ACTIVITY_TYPE.SIGN_IN && activityData.type !== ACTIVITY_TYPE.NEW_PLAYER_SIGN_IN
+        && activityData.type !== ACTIVITY_TYPE.COMMON_SIGN_IN) {
+        return null;
+    }
+    let playerData = new SignInData(activityData);
+    let playerRecords: ActivitySignInModelType = await ActivitySignInModel.findData(activityId, roleId, playerData.roundIndex);
+
+    playerData.setPlayerRecords(playerRecords);
+    if (playerData.type === ACTIVITY_TYPE.NEW_PLAYER_SIGN_IN) {
+        let { createTime } = await RoleModel.findByRoleId(roleId);
+        let betinTime = null;
+        let endTime = null
+        let curDate = moment(createTime * 1000);
+        if (curDate.hour() < REFRESH_TIME) {
+            betinTime = moment(createTime * 1000).startOf('d').add(-1, 'd').add(REFRESH_TIME, 'h').toDate();
+            endTime = moment(betinTime).add(playerData.days, 'd').toDate()
+        } else {
+            betinTime = moment(createTime * 1000).startOf('d').add(REFRESH_TIME, 'h').toDate();
+            endTime = moment(betinTime).add(playerData.days, 'd').toDate()
+        }
+        playerData.setNewPlayerDate(betinTime, endTime)
+    }
+    return playerData;
+}
+
+
+/**
+   * 购买vip签到
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   * @param {string} productID 商品ID
+   *
+   */
+export async function makeSignInVIP(roleId: string, roleName: string, sid: string, serverId: number, funcs: number[],
+    activityId: number, productID: string) {
+    let activityData: ActivityModelType = await ActivityModel.findActivity(activityId);
+    if (activityData.type !== ACTIVITY_TYPE.SIGN_IN_VIP) {
+        return STATUS.ACTIVITY_TYPE_ERROR;
+    }
+    let playerData = new SignInData(activityData);
+
+    await ActivitySignInModel.buyVIP(activityId, roleId, playerData.roundIndex);
+
+    return {
+        code: 0,
+        data: Object.assign({}, { item: { isVip: true }, activityId: activityData.activityId })
+    }
+}
+
+//高级签到开启条件
+export async function canBuyVip(lv: number) {
+    //高级签到开启条件
+    let openTime = SERVER_OPEN_TIME;
+    if (moment(openTime).valueOf() + 24 * 60 * 60 * 1000 * 8 > moment(new Date()).valueOf()) {//开服时间8天后才能开启vip签到
+        return false;
+    }
+    // let { lv } = await RoleModel.findByRoleId(roleId);
+    if (lv < SIGNIN_VIP_OPEN_LIMIT) {//玩家等级大于等于15级才能开启vip签到
+        return false
+    }
+    return true;
+}
+
@@ -0,0 +1,91 @@
+import { ActivityModel, ActivityModelType } from '../../db/Activity';
+import { ActivityThirtyDaysModel, ActivityThirtyDaysModelType } from '../../db/ActivityThirtyDays';
+import { ThirtyDaysData } from '../../domain/activityField/thirtyDaysField';
+import { ActivityThirtyDaysPointRewardModel, ActivityThirtyDaysPointRewardModelType } from '../../db/ActivityThirtyDaysPointReward';
+import { RoleModel } from '../../db/Role';
+import moment = require('moment');
+import { deltaDays } from '../../pubUtils/util';
+import { ServerlistModel } from '../../db/Serverlist';
+
+/**
+   * 获取活动数据
+   *
+   * @param {number} serverId 区Id
+   * @param {number} type 活动类型 ACTIVITY_TYPE
+   * @param {string} roleId 角色Id
+   *
+   */
+
+export async function thirtyDaysActivity(type: number, serverId: number, roleId: string) {
+    let { activityGroupId } = await ServerlistModel.findByServerId(serverId);
+    let activityArray: ActivityModelType[] = await ActivityModel.findOpenActivityByType(activityGroupId, type, new Date())
+    if (activityArray.length == 0) {
+        return null;
+    }
+    let activityData = activityArray[0];
+    let playerData = await getPlayerThirtyDaysData(activityData.activityId, serverId, roleId);
+
+    return playerData
+}
+
+/**
+   * 玩家活动数据
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   *
+   */
+export async function getPlayerThirtyDaysData(activityId: number, serverId: number, roleId: string) {
+    let activityData: ActivityModelType = await ActivityModel.findActivity(activityId);
+    let playerRecords: ActivityThirtyDaysModelType[] = await ActivityThirtyDaysModel.findData(serverId, activityId, roleId);
+    let playerPointRecords: ActivityThirtyDaysPointRewardModelType[] = await ActivityThirtyDaysPointRewardModel.findData(activityId, roleId);
+
+
+    let playerData = new ThirtyDaysData(activityData);
+    playerData.setPlayerRecords(playerRecords);
+    playerData.setPlayerPointRecords(playerPointRecords);
+
+    // let playerHeroes = await HeroModel.findByRole(roleId);
+    // let colorStarHeroes = playerHeroes.filter(obj => { return obj && obj.colorStar > 0 })
+    // playerData.setColorStarCount(colorStarHeroes.length);
+
+    return playerData;
+}
+
+/**
+   * 活动任务添加统计次数
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   *
+   */
+export async function addPlayerThirtyDaysTask(activityId: number, serverId: number, roleId: string) {
+    let activityData: ActivityModelType = await ActivityModel.findActivity(activityId);
+    let playerRecords: ActivityThirtyDaysModelType[] = await ActivityThirtyDaysModel.findData(serverId, activityId, roleId);
+    let playerPointRecords: ActivityThirtyDaysPointRewardModelType[] = await ActivityThirtyDaysPointRewardModel.findData(activityId, roleId);
+
+    let playerData = new ThirtyDaysData(activityData);
+    playerData.setPlayerRecords(playerRecords);
+    playerData.setPlayerPointRecords(playerPointRecords);
+    return playerData;
+}
+
+/**
+   * 玩家活动第几天
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   *
+   */
+export async function playerThirtyDaysActivityDays(roleId: string) {
+    let { createTime } = await RoleModel.findByRoleId(roleId);
+    let createDate = moment(createTime * 1000).toDate();
+    let todayIndex = deltaDays(moment(createDate).startOf('d').toDate(), new Date) + 1;
+    return todayIndex;
+}
+{
+
+}
@@ -0,0 +1,338 @@
+import moment = require('moment');
+import { ACTIVITY_TYPE, SERVER_OPEN_TIME, STATUS } from '../../consts';
+import { ActivityModel, ActivityModelType } from '../../db/Activity';
+import { ActivityTreasureHuntShopModel, ActivityTreasureHuntShopModelType } from '../../db/ActivityTreasureHuntShop';
+import { ActivityTreasureHuntTaskModel, ActivityTreasureHuntTaskModelType } from '../../db/ActivityTreasureHuntTask';
+import { ActivityTreasureHuntTreasureShopModel, ActivityTreasureHuntTreasureShopModelType } from '../../db/ActivityTreasureHuntTreasureShop';
+import { ActivityTreasureHuntFirstPageModel, ActivityTreasureHuntFirstPageModelType } from '../../db/ActivityTreasureHuntFirstPage';
+import { ServerlistModel } from '../../db/Serverlist';
+import { ServerTempModel, ServerTempModelType } from '../../db/ServerTemp';
+import { TreasureHuntData } from '../../domain/activityField/treasureHuntField';
+import { deltaDays } from '../../pubUtils/util';
+import { addReward, stringToConsumeParam, stringToRewardParam } from './giftPackageService';
+import { RewardParam } from '../../domain/activityField/rewardField';
+
+/**
+   * 获取活动数据
+   *
+   * @param {number} serverId 区Id
+   * @param {number} type 活动类型 ACTIVITY_TYPE
+   * @param {string} roleId 角色Id
+   *
+   */
+
+export async function treasureHuntActivity(serverId: number, roleId: string) {
+    let { huntActivityId, huntBeginTime, huntEndTime, huntRoundIndex, activityData } = await getTreasureHuntData(serverId);
+    if (!activityData) {
+        return null;
+    }
+
+    let playerData = new TreasureHuntData(activityData);
+    playerData.beginTime = moment(huntBeginTime).valueOf();
+    playerData.endTime = moment(huntEndTime).valueOf();
+    playerData.todayIndex = deltaDays(moment(huntBeginTime).startOf('d').toDate(), new Date) + 1;;
+    playerData.roundIndex = huntRoundIndex;
+
+    let playerTreasureFirstPageecord: ActivityTreasureHuntFirstPageModelType = await ActivityTreasureHuntFirstPageModel.findData(serverId, activityData.activityId, roleId, huntRoundIndex);
+    playerData.firstPage.setPlayerFirstPageRecord(playerTreasureFirstPageecord);
+    let playerShopRecord: ActivityTreasureHuntShopModelType = await ActivityTreasureHuntShopModel.findTreasureData(activityData.activityId, roleId, huntRoundIndex, playerData.todayIndex);
+    playerData.shop.setPlayerShopRecords(playerShopRecord);
+    let playerTaskRecord: ActivityTreasureHuntTaskModelType[] = await ActivityTreasureHuntTaskModel.findDataByRoundIndex(serverId, activityData.activityId, roleId, huntRoundIndex);
+    playerData.tasks.setPlayerTaskRecords(playerTaskRecord);
+    let playerTreasureShopRecord: ActivityTreasureHuntTreasureShopModelType = await ActivityTreasureHuntTreasureShopModel.findData(activityData.activityId, roleId, huntRoundIndex);
+    playerData.treasureShop.setPlayerTreasureShopRecords(playerTreasureShopRecord);
+
+    return playerData;
+}
+
+
+/**
+   * 获取活动数据
+   *
+   * @param {number} serverId 区Id
+   * @param {number} type 活动类型 ACTIVITY_TYPE
+   * @param {string} roleId 角色Id
+   *
+   */
+
+export async function treasureHuntTaskActivity(serverId: number, roleId: string) {
+    let { huntActivityId, huntBeginTime, huntEndTime, huntRoundIndex, activityData } = await getTreasureHuntData(serverId);
+    if (!activityData) {
+        return null;
+    }
+
+    let playerData = new TreasureHuntData(activityData);
+    playerData.beginTime = moment(huntBeginTime).valueOf();
+    playerData.endTime = moment(huntEndTime).valueOf();
+    playerData.todayIndex = deltaDays(moment(huntBeginTime).startOf('d').toDate(), new Date) + 1;;
+    playerData.roundIndex = huntRoundIndex;
+
+    let playerTaskRecord: ActivityTreasureHuntTaskModelType[] = await ActivityTreasureHuntTaskModel.findDataByRoundIndex(serverId, activityData.activityId, roleId, huntRoundIndex);
+    playerData.tasks.setPlayerTaskRecords(playerTaskRecord);
+    return playerData;
+}
+
+/**
+   * 玩家活动数据
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   *
+   */
+export async function getPlayerTreasureHuntData(activityId: number, serverId: number, roleId: string, huntRoundIndex: number, huntBeginTime: Date, huntEndTime: Date) {
+    let activityData: ActivityModelType = await ActivityModel.findActivity(activityId);
+
+    let playerData = new TreasureHuntData(activityData);
+    playerData.beginTime = moment(huntBeginTime).valueOf();
+    playerData.endTime = moment(huntEndTime).valueOf();
+    playerData.todayIndex = deltaDays(moment(huntBeginTime).startOf('d').toDate(), new Date) + 1;;
+    playerData.roundIndex = huntRoundIndex;
+
+    let playerTreasureFirstPageecord: ActivityTreasureHuntFirstPageModelType = await ActivityTreasureHuntFirstPageModel.findData(serverId, activityId, roleId, huntRoundIndex);
+    playerData.firstPage.setPlayerFirstPageRecord(playerTreasureFirstPageecord);
+    let playerShopRecord: ActivityTreasureHuntShopModelType = await ActivityTreasureHuntShopModel.findTreasureData(activityId, roleId, huntRoundIndex, playerData.todayIndex);
+    playerData.shop.setPlayerShopRecords(playerShopRecord);
+    let playerTaskRecord: ActivityTreasureHuntTaskModelType[] = await ActivityTreasureHuntTaskModel.findDataByRoundIndex(serverId, activityId, roleId, huntRoundIndex);
+    playerData.tasks.setPlayerTaskRecords(playerTaskRecord);
+    let playerTreasureShopRecord: ActivityTreasureHuntTreasureShopModelType = await ActivityTreasureHuntTreasureShopModel.findData(activityId, roleId, huntRoundIndex);
+    playerData.treasureShop.setPlayerTreasureShopRecords(playerTreasureShopRecord);
+
+    return playerData;
+}
+
+export async function getPlayerTreasureHuntFirstPageData(activityId: number, serverId: number, roleId: string, huntRoundIndex: number, huntBeginTime: Date, huntEndTime: Date) {
+    let activityData: ActivityModelType = await ActivityModel.findActivity(activityId);
+
+    let playerData = new TreasureHuntData(activityData);
+    playerData.beginTime = moment(huntBeginTime).valueOf();
+    playerData.endTime = moment(huntEndTime).valueOf();
+    playerData.todayIndex = deltaDays(moment(huntBeginTime).startOf('d').toDate(), new Date) + 1;;
+    playerData.roundIndex = huntRoundIndex;
+
+    let playerTreasureFirstPageecord: ActivityTreasureHuntFirstPageModelType = await ActivityTreasureHuntFirstPageModel.findData(serverId, activityId, roleId, huntRoundIndex);
+    playerData.firstPage.setPlayerFirstPageRecord(playerTreasureFirstPageecord);
+    return playerData;
+}
+
+export async function getPlayerTreasureHuntShopData(activityId: number, serverId: number, roleId: string, huntRoundIndex: number, huntBeginTime: Date, huntEndTime: Date) {
+    let activityData: ActivityModelType = await ActivityModel.findActivity(activityId);
+
+    let playerData = new TreasureHuntData(activityData);
+    playerData.beginTime = moment(huntBeginTime).valueOf();
+    playerData.endTime = moment(huntEndTime).valueOf();
+    playerData.todayIndex = deltaDays(moment(huntBeginTime).startOf('d').toDate(), new Date) + 1;;
+    playerData.roundIndex = huntRoundIndex;
+
+    let playerShopRecord: ActivityTreasureHuntShopModelType = await ActivityTreasureHuntShopModel.findTreasureData(activityId, roleId, huntRoundIndex, playerData.todayIndex);
+    playerData.shop.setPlayerShopRecords(playerShopRecord);
+    return playerData;
+}
+
+export async function getPlayerTreasureHuntTaskData(activityId: number, serverId: number, roleId: string, huntRoundIndex: number, huntBeginTime: Date, huntEndTime: Date) {
+    let activityData: ActivityModelType = await ActivityModel.findActivity(activityId);
+
+    let playerData = new TreasureHuntData(activityData);
+    playerData.beginTime = moment(huntBeginTime).valueOf();
+    playerData.endTime = moment(huntEndTime).valueOf();
+    playerData.todayIndex = deltaDays(moment(huntBeginTime).startOf('d').toDate(), new Date) + 1;;
+    playerData.roundIndex = huntRoundIndex;
+
+    let playerTaskRecord: ActivityTreasureHuntTaskModelType[] = await ActivityTreasureHuntTaskModel.findDataByRoundIndex(serverId, activityId, roleId, huntRoundIndex);
+    playerData.tasks.setPlayerTaskRecords(playerTaskRecord);
+    return playerData;
+}
+
+export async function getPlayerTreasureHuntChallengeData(activityId: number, serverId: number, roleId: string, huntRoundIndex: number, huntBeginTime: Date, huntEndTime: Date) {
+    let activityData: ActivityModelType = await ActivityModel.findActivity(activityId);
+
+    let playerData = new TreasureHuntData(activityData);
+    playerData.beginTime = moment(huntBeginTime).valueOf();
+    playerData.endTime = moment(huntEndTime).valueOf();
+    playerData.todayIndex = deltaDays(moment(huntBeginTime).startOf('d').toDate(), new Date) + 1;;
+    playerData.roundIndex = huntRoundIndex;
+
+    return playerData;
+}
+
+export async function getPlayerTreasureHuntTreasureShopData(activityId: number, serverId: number, roleId: string, huntRoundIndex: number, huntBeginTime: Date, huntEndTime: Date) {
+    let activityData: ActivityModelType = await ActivityModel.findActivity(activityId);
+
+    let playerData = new TreasureHuntData(activityData);
+    playerData.beginTime = moment(huntBeginTime).valueOf();
+    playerData.endTime = moment(huntEndTime).valueOf();
+    playerData.todayIndex = deltaDays(moment(huntBeginTime).startOf('d').toDate(), new Date) + 1;;
+    playerData.roundIndex = huntRoundIndex;
+
+    let playerTreasureShopRecord: ActivityTreasureHuntTreasureShopModelType = await ActivityTreasureHuntTreasureShopModel.findData(activityId, roleId, huntRoundIndex);
+    playerData.treasureShop.setPlayerTreasureShopRecords(playerTreasureShopRecord);
+    return playerData;
+}
+
+//获取当前活动的周期等数据
+export async function getTreasureHuntData(serverId: number) {
+    let tempData: ServerTempModelType = await ServerTempModel.findData(serverId);
+    let now = moment(new Date()).toDate();
+    let activityData: ActivityModelType = null;                    //当前活动数据
+
+    if (!tempData) {//开始新周期
+        let { huntActivityId, huntBeginTime, huntEndTime, huntRoundIndex } = await getNewActivityData(serverId);
+        if (huntActivityId === 0) {
+            return { huntActivityId, huntBeginTime, huntEndTime, huntRoundIndex, activityData }
+        }
+        tempData = await ServerTempModel.updateTreasureHuntData(serverId, huntActivityId, huntBeginTime, huntEndTime, huntRoundIndex);
+        activityData = await ActivityModel.findActivity(huntActivityId);
+        return { huntActivityId, huntBeginTime, huntEndTime, huntRoundIndex, activityData }
+    }
+    if (now > tempData.huntEndTime) {//活动过期
+        let { huntActivityId, huntBeginTime, huntEndTime, huntRoundIndex } = await getNextActivityData(serverId, tempData.huntActivityId, tempData.huntEndTime, tempData.huntRoundIndex);
+        if (huntActivityId === 0) {
+            return { huntActivityId, huntBeginTime, huntEndTime, huntRoundIndex, activityData }
+        }
+        tempData = await ServerTempModel.updateTreasureHuntData(serverId, huntActivityId, huntBeginTime, huntEndTime, huntRoundIndex);
+        activityData = await ActivityModel.findActivity(huntActivityId);
+        return { huntActivityId, huntBeginTime, huntEndTime, huntRoundIndex, activityData }
+    }
+    if (!activityData) {
+        activityData = await ActivityModel.findActivity(tempData.huntActivityId);
+    }
+    return {
+        huntActivityId: tempData.huntActivityId,
+        huntBeginTime: tempData.huntBeginTime,
+        huntEndTime: tempData.huntEndTime,
+        huntRoundIndex: tempData.huntRoundIndex,
+        activityData
+    }
+}
+
+async function getNewActivityData(serverId: number) {
+    let { activityGroupId } = await ServerlistModel.findByServerId(serverId);
+    let huntActivityId: number = 0;				// 寻宝骑兵-活动Id
+    let huntEndTime: Date = null;					// 寻宝骑兵-结束时间
+    let huntRoundIndex: number = 0;				// 寻宝骑兵-周期数
+    let activityArray: ActivityModelType[] = await ActivityModel.findActivityByType(activityGroupId, ACTIVITY_TYPE.TREASURE_HUNT, 1)//activityId从小到大排序
+    let treasureHuntDataArray: TreasureHuntData[] = [];
+    for (let obj of activityArray) {
+        treasureHuntDataArray.push(new TreasureHuntData(obj));
+    }
+    let isOver = false;
+    let huntBeginTime = moment(SERVER_OPEN_TIME).startOf('d').add(1, 'd').toDate();
+    let curDate = moment(new Date()).toDate()
+    while (!isOver) {
+        huntRoundIndex++;
+        for (let data of treasureHuntDataArray) {
+            let endTime = moment(huntBeginTime).add(data.day, 'd').toDate();
+            if (huntBeginTime < curDate && curDate < endTime) {
+                huntEndTime = moment(endTime).add(-1, 'm').toDate()
+                huntActivityId = data.activityId;
+                isOver = true;
+            } else {
+                huntBeginTime = endTime;
+            }
+        }
+        if (huntRoundIndex >= 365) {//max
+            isOver = true;
+        }
+    }
+    return { huntActivityId, huntBeginTime, huntEndTime, huntRoundIndex }
+}
+
+async function getNextActivityData(serverId: number, oldHuntActivityId: number, oldHuntEndTime: Date, oldHuntRoundIndex: number) {
+    let { activityGroupId } = await ServerlistModel.findByServerId(serverId);
+    let huntActivityId: number = 0;				// 寻宝骑兵-活动Id
+    let huntEndTime: Date = null;					// 寻宝骑兵-结束时间
+    let huntRoundIndex: number = oldHuntRoundIndex;				// 寻宝骑兵-周期数
+    let activityArray: ActivityModelType[] = await ActivityModel.findActivityByType(activityGroupId, ACTIVITY_TYPE.TREASURE_HUNT, 1)//activityId从小到大排序
+    let treasureHuntDataArray: TreasureHuntData[] = [];
+    for (let obj of activityArray) {
+        treasureHuntDataArray.push(new TreasureHuntData(obj));
+    }
+    let isOver = false;
+    let huntBeginTime = moment(oldHuntEndTime).add(1, 'd').startOf('d').toDate();
+    let curDate = moment(new Date()).toDate()
+
+    let index = treasureHuntDataArray.findIndex(obj => { return obj && obj.activityId === oldHuntActivityId });
+    for (; index < treasureHuntDataArray.length; index++) {
+        let data = treasureHuntDataArray[index];
+        let endTime = moment(huntBeginTime).add(data.day, 'd').toDate();
+        if (huntBeginTime < curDate && curDate < endTime) {
+            huntEndTime = moment(endTime).add(-1, 'm').toDate()
+            huntActivityId = data.activityId;
+            isOver = true;
+        } else {
+            huntBeginTime = endTime;
+        }
+    }
+
+    while (!isOver) {
+        huntRoundIndex++;
+        for (let data of treasureHuntDataArray) {
+            let endTime = moment(huntBeginTime).add(data.day, 'd').toDate();
+            if (huntBeginTime < curDate && curDate < endTime) {
+                huntEndTime = moment(endTime).add(-1, 'm').toDate()
+                huntActivityId = data.activityId;
+                isOver = true;
+            } else {
+                huntBeginTime = endTime;
+            }
+        }
+        if (huntRoundIndex >= 365) {//max
+            isOver = true;
+        }
+    }
+    return { huntActivityId, huntBeginTime, huntEndTime, huntRoundIndex }
+}
+
+
+/**
+   * 购买每日物资
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   * @param {string} productID 商品ID
+   *
+   */
+export async function makeShop(roleId: string, roleName: string, sid: string, serverId: number, funcs: number[],
+    activityId: number, productID: string) {
+    // let activityData: ActivityModelType = await ActivityModel.findActivity(activityId);
+    let { huntActivityId, huntBeginTime, huntEndTime, huntRoundIndex, activityData } = await getTreasureHuntData(serverId);
+    if (!activityData) {
+        return {
+            code: STATUS.ACTIVITY_MISSING,
+        }
+    }
+
+    let playerData = await getPlayerTreasureHuntShopData(activityId, serverId, roleId, huntRoundIndex, huntBeginTime, huntEndTime,);
+    if (!playerData) {
+        return {
+            code: STATUS.ACTIVITY_MISSING,
+        }
+    }
+
+    let item = playerData.shop.findProductID(productID)
+
+    if (!item) {
+        return {
+            code: STATUS.ACTIVITY_MISSING,
+        }
+    }
+    if (item.buyCount >= item.countMax) {
+        return {
+            code: STATUS.ACTIVITY_MAX_COUNT,
+        }
+    }
+    let cellIndex = item.cellIndex;
+
+    //添加购买记录
+    await ActivityTreasureHuntShopModel.buyShopRecord(activityId, roleId, huntRoundIndex, playerData.todayIndex, cellIndex);
+
+    let rewardParamArr: Array<RewardParam> = stringToRewardParam(item.reward);
+    let result = await addReward(roleId, roleName, sid, serverId, funcs, rewardParamArr)
+
+    item.buyCount += 1;
+    return {
+        code: 0,
+        data: Object.assign(result, { item })
+    }
+}
@@ -0,0 +1,68 @@
+import { ACTIVITY_TYPE, TASK_TYPE } from '../../consts';
+import { ActivityModel, ActivityModelType } from '../../db/Activity';
+import { ActivityVipRechargeMoneyModel, ActivityVipRechargeMoneyModelType } from '../../db/ActivityVipRechargeMoney';
+import { VipRechargeMoneyData, VipRechargeMoneyItem } from '../../domain/activityField/vipRechargeMoneyField';
+import { ServerlistModel } from '../../db/Serverlist';
+
+/**
+   * 获取活动数据
+   *
+   * @param {number} serverId 区Id
+   * @param {number} type 活动类型 ACTIVITY_TYPE
+   * @param {string} roleId 角色Id
+   *
+   */
+
+export async function vipRechargeMoneyActivity(serverId: number, roleId: string) {
+    let { activityGroupId } = await ServerlistModel.findByServerId(serverId);
+    let activityArray: ActivityModelType[] = await ActivityModel.findOpenActivityByType(activityGroupId, ACTIVITY_TYPE.VIP_RECHARGE_MONEY, new Date())
+    if (activityArray.length == 0) {
+        return null;
+    }
+    let activityData = activityArray[0];
+    let playerRecord: ActivityVipRechargeMoneyModelType = await ActivityVipRechargeMoneyModel.findData(serverId, roleId, activityData.activityId);
+    let playerData = new VipRechargeMoneyData(activityData);
+    playerData.setPlayerRecords(playerRecord);
+    return playerData;
+}
+
+/**
+   * 玩家活动数据
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   *
+   */
+export async function getPlayerVipRechargeMoneyData(activityId: number, serverId: number, roleId: string) {
+    let activityData: ActivityModelType = await ActivityModel.findActivity(activityId);
+    if (!activityData) {
+        return null;
+    }
+    let playerRecord: ActivityVipRechargeMoneyModelType = await ActivityVipRechargeMoneyModel.findData(serverId, roleId, activityId);
+
+    let playerData = new VipRechargeMoneyData(activityData);
+    playerData.setPlayerRecords(playerRecord);
+    return playerData;
+}
+
+
+
+/**
+   * 统计充值金额
+   *
+   * @param {number} serverId 区Id
+   * @param {string} roleId 角色Id
+   * @param {string} RMB 金额
+   *
+   */
+export async function addVipRechargeMoney(roleId: string, serverId: number, RMB: number) {
+    let { activityGroupId } = await ServerlistModel.findByServerId(serverId);
+    let activityArray: ActivityModelType[] = await ActivityModel.findOpenActivityByType(activityGroupId, ACTIVITY_TYPE.VIP_RECHARGE_MONEY, new Date())
+    if (activityArray.length == 0) {
+        return null;
+    }
+    let activityData = activityArray[0];
+    await ActivityVipRechargeMoneyModel.addRMB(serverId, roleId, activityData.activityId, RMB);
+}
+
@@ -0,0 +1,92 @@
+import { ACTIVITY_TYPE, STATUS, TASK_TYPE } from '../../consts';
+import { ActivityModel, ActivityModelType } from '../../db/Activity';
+import { ServerlistModel } from '../../db/Serverlist';
+import { UserOrderModel, UserOrderModelType } from '../../db/UserOrder';
+import { RewardParam } from '../../domain/activityField/rewardField';
+import { YuanBaoShopData, YuanBaoShopItem } from '../../domain/activityField/yuanBaoShopField';
+import { addReward, stringToRewardParam } from './giftPackageService';
+
+/**
+   * 获取活动数据
+   *
+   * @param {number} serverId 区Id
+   * @param {number} type 活动类型 ACTIVITY_TYPE
+   * @param {string} roleId 角色Id
+   *
+   */
+
+export async function yuanbaoActivity(serverId: number, roleId: string) {
+    let { activityGroupId } = await ServerlistModel.findByServerId(serverId);
+    let activityArray: ActivityModelType[] = await ActivityModel.findActivityByType(activityGroupId, ACTIVITY_TYPE.YUAN_BAO_SHOP, -1)
+    if (activityArray.length == 0) {
+        return null;
+    }
+    let activityData = activityArray[0];
+    let playerRecord: UserOrderModelType[] = await UserOrderModel.findOrderByActivityID(activityData.activityId, roleId);
+    let playerData = new YuanBaoShopData(activityData);
+    playerData.setPlayerRecords(playerRecord);
+    return playerData;
+}
+
+/**
+   * 玩家活动数据
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   *
+   */
+export async function getPlayerYuanbaoShopData(activityId: number, serverId: number, roleId: string) {
+    let activityData: ActivityModelType = await ActivityModel.findActivity(activityId);
+    let playerRecord: UserOrderModelType[] = await UserOrderModel.findOrderByActivityID(activityId, roleId);
+
+    let playerData = new YuanBaoShopData(activityData);
+    playerData.setPlayerRecords(playerRecord);
+    return playerData;
+}
+
+
+/**
+   * 结算奖励
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   * @param {string} productID 商品ID
+   *
+   */
+export async function makeYuanbaoShopReward(roleId: string, roleName: string, sid: string, serverId: number, funcs: number[],
+    activityId: number, productID: string) {
+    let records = await UserOrderModel.findSuccessOrderByProductID(productID, roleId, activityId);
+    let activityData: ActivityModelType = await ActivityModel.findActivity(activityId);
+    if (activityData.type !== ACTIVITY_TYPE.YUAN_BAO_SHOP) {
+        return STATUS.ACTIVITY_TYPE_ERROR;
+    }
+    let playerData = new YuanBaoShopData(activityData);
+    let item = playerData.findItem(productID);
+
+    let rewardParamArr: Array<RewardParam> = [];
+    if (records.length == 1) {//首充
+        rewardParamArr = rewardParamArr.concat(stringToRewardParam(item.baseReward));
+        rewardParamArr = rewardParamArr.concat(stringToRewardParam(item.firstReward));
+    } else {
+        rewardParamArr = rewardParamArr.concat(stringToRewardParam(item.baseReward));
+        rewardParamArr = rewardParamArr.concat(stringToRewardParam(item.extraReward));
+    }
+    let arr: Array<RewardParam> = [];
+    for (let obj of rewardParamArr) {
+        let index = arr.findIndex(reward => { return reward.type == obj.type && reward.id == obj.id });
+        if (index != -1) {
+            arr[index].count += obj.count;
+        } else {
+            arr.push(obj);
+        }
+    }
+
+    let result = await addReward(roleId, roleName, sid, serverId, funcs, arr)
+    item.buyCount += 1;
+    return {
+        code: 0,
+        data: Object.assign(result, { item, activityId: activityData.activityId })
+    }
+}