diff --git a/game-server/app/servers/activity/handler/limitPackageHandler.ts b/game-server/app/servers/activity/handler/limitPackageHandler.ts
new file mode 100644
index 000000000..5c00f181a
--- /dev/null
+++ b/game-server/app/servers/activity/handler/limitPackageHandler.ts
@@ -0,0 +1,83 @@
+import { Application, BackendSession } from 'pinus';
+import { resResult } from '../../../pubUtils/util';
+import { ACTIVITY_TYPE, FIRST_GIFT_STATE, STATUS } from '../../../consts';
+import { newPlayerLimitPackageActivity, getPlayerLimitPackageData } from '../../../services/limitPackageService';
+import { addReward, stringToRewardParam, useGiftPackage } from '../../../services/giftPackageService';
+import { ActivityShopModel } from '../../../db/ActivityShop';
+
+export default function (app: Application) {
+    return new limitPackageHandler(app);
+}
+
+export class limitPackageHandler {
+    constructor(private app: Application) {
+    }
+
+    /************************新手限定礼包****************************/
+
+    /**
+    * @description 获取新手限定活动数据
+    * @param {{ }} msg
+    * @param {BackendSession} session
+    * @memberof limitPackageHandler
+    */
+    async getNewPlayerLimitPackageActivity(msg: {}, session: BackendSession) {
+        const { } = msg;
+        const roleId = session.get('roleId');
+        const serverId = session.get('serverId');
+
+        let playerData = await newPlayerLimitPackageActivity(serverId, roleId);
+        if (!playerData) {
+            return resResult(STATUS.ACTIVITY_MISSING);
+        }
+        return resResult(STATUS.SUCCESS, { playerData });
+    }
+
+    /**
+        * @description 购买礼包
+        * @param {{ activityId: number, roundIndex: number, id: number}} msg
+        * @param {BackendSession} session
+        * @memberof limitPackageHandler
+        */
+    async buyGood(msg: { activityId: number, roundIndex: number, id: number }, session: BackendSession) {
+        const { activityId, roundIndex, id, } = msg;
+        const roleId = session.get('roleId');
+        const serverId = session.get('serverId');
+        const sid = session.get('sid');
+        const roleName = session.get('roleName');
+        const funcs: number[] = session.get('funcs');
+
+        let playerData = await getPlayerLimitPackageData(activityId, serverId, roleId);
+        if (!playerData) {
+            return resResult(STATUS.ACTIVITY_MISSING);
+        }
+
+        if (playerData.roundIndex != roundIndex) {
+            return resResult(STATUS.ACTIVITY_EXPIRE);
+        }
+
+        switch (playerData.type) {
+            case ACTIVITY_TYPE.NEW_PLAYER_LIMIT_PACKAGE:
+                {
+                    if (playerData.endTime < new Date) {
+                        return resResult(STATUS.ACTIVITY_NEW_PLAYER_LIMIT_PACKAGE_END);
+                    }
+                    break;
+                }
+            default:
+                break;
+        }
+
+        let item = playerData.findItem(id);
+        if (item.countMax > 0 && item.buyCount >= item.countMax) {
+            return resResult(STATUS.ACTIVITY_MAX_COUNT);
+        }
+
+        let rewardArray = stringToRewardParam(item.reward)
+        let result = await addReward(roleId, roleName, sid, serverId, funcs, rewardArray);
+
+        await ActivityShopModel.addRecord(activityId, roleId, roundIndex, id);
+        return resResult(STATUS.SUCCESS, Object.assign(result, {}));
+    }
+
+}
diff --git a/game-server/app/servers/activity/handler/signInHandler.ts b/game-server/app/servers/activity/handler/signInHandler.ts
index 41d03d866..0027a486e 100644
--- a/game-server/app/servers/activity/handler/signInHandler.ts
+++ b/game-server/app/servers/activity/handler/signInHandler.ts
@@ -38,8 +38,8 @@ export class SignInHandler {
             return resResult(STATUS.ACTIVITY_MISSING);
         }
 
-        let acvitityId = activityData.acvitityId;//活动ID
-        let playerData = await getPlayerSignInData(acvitityId, serverId, roleId)
+        let activityId = activityData.activityId;//活动ID
+        let playerData = await getPlayerSignInData(activityId, serverId, roleId)
 
         if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
 
@@ -72,7 +72,7 @@ export class SignInHandler {
         if (!activityData) {//未配置活动数据
             return resResult(STATUS.ACTIVITY_MISSING);
         }
-        if (activityData.acvitityId != activityId) {
+        if (activityData.activityId != activityId) {
             return resResult(STATUS.ACTIVITY_EXPIRE);
         }
 
diff --git a/game-server/app/servers/activity/handler/thirtyDaysHandler.ts b/game-server/app/servers/activity/handler/thirtyDaysHandler.ts
index 27811caf0..4c0ec3051 100644
--- a/game-server/app/servers/activity/handler/thirtyDaysHandler.ts
+++ b/game-server/app/servers/activity/handler/thirtyDaysHandler.ts
@@ -57,7 +57,7 @@ export class thirtyDaysHandler {
 
         let activityArray: ActivityModelType[] = await ActivityModel.findActivityByType(ACTIVITY_TYPE.THIRTY_DAYS, true)
         activityArray = activityArray.sort((a, b) => {
-            return a.acvitityId - b.acvitityId
+            return a.activityId - b.activityId
         });
 
         let activityDays = 0;
diff --git a/game-server/app/services/firstGiftService.ts b/game-server/app/services/firstGiftService.ts
index 5da581d2a..17ccfd259 100644
--- a/game-server/app/services/firstGiftService.ts
+++ b/game-server/app/services/firstGiftService.ts
@@ -15,13 +15,13 @@ import { FirstGiftData, FirstGiftItem } from '../domain/activityField/firstGiftF
 export async function firstGiftActivity(serverId: number, roleId: string) {
     let activityArray: ActivityModelType[] = await ActivityModel.findActivityByType(ACTIVITY_TYPE.FIRST_GIFT, true)
     activityArray = activityArray.sort((a, b) => {
-        return a.acvitityId - b.acvitityId
+        return a.activityId - b.activityId
     });
     if (activityArray.length == 0) {
         return null;
     }
     let activityData = activityArray[0];
-    let playerData = await getPlayerFirstGiftData(activityData.acvitityId, serverId, roleId);
+    let playerData = await getPlayerFirstGiftData(activityData.activityId, serverId, roleId);
     return playerData
 }
 
diff --git a/game-server/app/services/growthFundService.ts b/game-server/app/services/growthFundService.ts
index ca1168f0c..e2c43c2c0 100644
--- a/game-server/app/services/growthFundService.ts
+++ b/game-server/app/services/growthFundService.ts
@@ -24,11 +24,11 @@ import { GrowthFundData, GrowthFundItem } from '../domain/activityField/growthFu
 export async function growthFundActivity(type: number, serverId: number, roleId: string) {
     let activityArray: ActivityModelType[] = await ActivityModel.findActivityByType(type, true)
     activityArray = activityArray.sort((a, b) => {
-        return a.acvitityId - b.acvitityId
+        return a.activityId - b.activityId
     });
     for (let i = 0; i < activityArray.length; i++) {
         let activityData = activityArray[i];
-        let playerData = await getPlayerGrowthFundData(activityData.acvitityId, serverId, roleId);
+        let playerData = await getPlayerGrowthFundData(activityData.activityId, serverId, roleId);
         if (!playerData.isComplete()) {
             return playerData;
         }
@@ -51,7 +51,7 @@ export async function getPlayerGrowthFundData(activityId: number, serverId: numb
     let playerData = new GrowthFundData(activityData);
     playerData.setPlayerRecords(playerRecords);
     if (playerData.isVipActivity()) {//vip高阶需要购买
-        let buyRecords = await ActivityBuyRecordsModel.findRecordsByActivityId(activityData.acvitityId, roleId);
+        let buyRecords = await ActivityBuyRecordsModel.findRecordsByActivityId(activityData.activityId, roleId);
         playerData.initBuyRecords(buyRecords);
     }
 
diff --git a/game-server/app/services/limitPackageService.ts b/game-server/app/services/limitPackageService.ts
new file mode 100644
index 000000000..f4b4a7547
--- /dev/null
+++ b/game-server/app/services/limitPackageService.ts
@@ -0,0 +1,43 @@
+import { ACTIVITY_TYPE, TASK_TYPE } from '../consts';
+import { ActivityModel, ActivityModelType } from '../db/Activity';
+import { ActivityShopModel, ActivityShopModelType } from '../db/ActivityShop';
+import { LimitShopData, ShopItem } from '../domain/activityField/limitShopField';
+
+/**
+   * 获取新手玩家限购礼包活动数据
+   *
+   * @param {number} serverId 区Id
+   * @param {number} type 活动类型 ACTIVITY_TYPE
+   * @param {string} roleId 角色Id
+   *
+   */
+
+export async function newPlayerLimitPackageActivity(serverId: number, roleId: string) {
+    let activityArray: ActivityModelType[] = await ActivityModel.findOpenActivityByType(ACTIVITY_TYPE.NEW_PLAYER_LIMIT_PACKAGE, new Date)
+    activityArray = activityArray.sort((a, b) => {
+        return a.activityId - b.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 getPlayerLimitPackageData(activityId: number, serverId: number, roleId: string) {
+    let activityData: ActivityModelType = await ActivityModel.findActivity(activityId, true);
+    let playerData = new LimitShopData(activityData);
+
+    let playerRecord: ActivityShopModelType = await ActivityShopModel.findData(activityId, roleId, playerData.roundIndex);
+    playerData.setPlayerRecords(playerRecord);
+    return playerData;
+}
diff --git a/game-server/app/services/selfServiceShopActivityService.ts b/game-server/app/services/selfServiceShopActivityService.ts
index fd9c151f1..929851fac 100644
--- a/game-server/app/services/selfServiceShopActivityService.ts
+++ b/game-server/app/services/selfServiceShopActivityService.ts
@@ -18,11 +18,11 @@ import { addReward, getSelectedReward } from './giftPackageService';
 export async function getActivityData(serverId: number, roleId: string) {
     let activityArray: ActivityModelType[] = await ActivityModel.findOpenActivityByType(ACTIVITY_TYPE.SELF_SERVICE_SHOP, new Date())
     activityArray = activityArray.sort((a, b) => {
-        return b.acvitityId - a.acvitityId
+        return b.activityId - a.activityId
     });
     if (activityArray.length > 0) {
         let activityData = activityArray[0];
-        let playerData = await getPlayerActivityData(activityData.acvitityId, serverId, roleId);
+        let playerData = await getPlayerActivityData(activityData.activityId, serverId, roleId);
         return playerData;
     }
     return null;
diff --git a/game-server/app/services/thirtyDaysService.ts b/game-server/app/services/thirtyDaysService.ts
index 2de3a64af..28fcc8be4 100644
--- a/game-server/app/services/thirtyDaysService.ts
+++ b/game-server/app/services/thirtyDaysService.ts
@@ -20,12 +20,12 @@ import { deltaDays } from '../pubUtils/util';
 export async function thirtyDaysActivity(type: number, serverId: number, roleId: string) {
     let activityArray: ActivityModelType[] = await ActivityModel.findActivityByType(type, true)
     activityArray = activityArray.sort((a, b) => {
-        return a.acvitityId - b.acvitityId
+        return a.activityId - b.activityId
     });
     let allPlayerActivity = [];
     for (let i = 0; i < activityArray.length; i++) {
         let activityData = activityArray[i];
-        let playerData = await getPlayerThirtyDaysData(activityData.acvitityId, serverId, roleId);
+        let playerData = await getPlayerThirtyDaysData(activityData.activityId, serverId, roleId);
         allPlayerActivity.push(playerData)
     }
 
diff --git a/shared/consts/constModules/activityConst.ts b/shared/consts/constModules/activityConst.ts
index 489010881..d7b0c0c3a 100644
--- a/shared/consts/constModules/activityConst.ts
+++ b/shared/consts/constModules/activityConst.ts
@@ -19,6 +19,8 @@ export enum ACTIVITY_TYPE {
     THIRTY_DAYS = 12, // 30日目标活动
     SELF_SERVICE_SHOP = 13, // 自选商店
     FIRST_GIFT = 14, // 首充礼包
+    NEW_PLAYER_LIMIT_PACKAGE = 15, // 新手限定RMB购买礼包
+    LIMIT_PACKAGE_SHOP = 16, // 限购礼包，RMB购买礼包
 }
 
 /**
diff --git a/shared/consts/statusCode.ts b/shared/consts/statusCode.ts
index b76ad0ea9..54384487c 100644
--- a/shared/consts/statusCode.ts
+++ b/shared/consts/statusCode.ts
@@ -351,6 +351,7 @@ export const STATUS = {
     ACTIVITY_THIRTY_DAYS_END: { code: 50014, simStr: '30日活动结束' },
     ACTIVITY_FIRST_GIFT_NOT_OPEN: { code: 50015, simStr: '首充没开' },
     ACTIVITY_FIRST_GIFT_END: { code: 50016, simStr: '首充结束' },
+    ACTIVITY_NEW_PLAYER_LIMIT_PACKAGE_END: { code: 50017, simStr: '新手礼包结束' },
     // GM后台相关状态 60000 - 69999
     GM_ERR_PASSWORD: { code: 60001, simStr: '账号或密码错误' },
     GM_MISS_API: { code: 60002, simStr: '未找到该接口' },
diff --git a/shared/db/Activity.ts b/shared/db/Activity.ts
index aff962dc7..45bca043a 100644
--- a/shared/db/Activity.ts
+++ b/shared/db/Activity.ts
@@ -4,11 +4,11 @@ import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoos
 /**
   * 活动系统 
 */
-@index({ acvitityId: 1 })
+@index({ activityId: 1 })
 
 export default class Activity extends BaseModel {
     @prop({ required: true })
-    acvitityId: number;				// 活动Id
+    activityId: number;				// 活动Id
     @prop({ required: true })
     beginTime: Date;			    // 开启时间
     @prop({ required: true })
@@ -31,21 +31,21 @@ export default class Activity extends BaseModel {
     }
 
     //根据活动id查询活动数据
-    public static async findActivity(acvitityId: number, lean = true) {
-        let result: ActivityModelType = await ActivityModel.findOne({ acvitityId }).lean(lean);
+    public static async findActivity(activityId: number, lean = true) {
+        let result: ActivityModelType = await ActivityModel.findOne({ activityId }).lean(lean);
         return result;
     }
 
     //新增活动
-    public static async addActivity(acvitityId: number, beginTime: Date, endTime: Date, type: number, data: string, lean = true) {
-        let result: ActivityModelType = await ActivityModel.findOneAndUpdate({ acvitityId }, { beginTime, endTime, type, data },
+    public static async addActivity(activityId: number, beginTime: Date, endTime: Date, type: number, data: string, lean = true) {
+        let result: ActivityModelType = await ActivityModel.findOneAndUpdate({ activityId }, { beginTime, endTime, type, data },
             { upsert: true, new: true }).lean(lean);
         return result;
     }
 
     //删除活动
-    public static async deleteActivity(acvitityId: number) {
-        let result = await ActivityModel.deleteMany({ acvitityId });
+    public static async deleteActivity(activityId: number) {
+        let result = await ActivityModel.deleteMany({ activityId });
         return result;
     }
 }
diff --git a/shared/db/ActivityBuyRecords.ts b/shared/db/ActivityBuyRecords.ts
index b5b431169..41cb90d2f 100644
--- a/shared/db/ActivityBuyRecords.ts
+++ b/shared/db/ActivityBuyRecords.ts
@@ -8,7 +8,7 @@ import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoos
 
 export default class ActivityBuyRecords extends BaseModel {
     @prop({ required: true })
-    acvitityId: number;				// 活动Id
+    activityId: number;				// 活动Id
     @prop({ required: true })
     roleId: string;			        // 用户Id
     @prop({ required: true })
@@ -18,27 +18,27 @@ export default class ActivityBuyRecords extends BaseModel {
 
 
     //添加购买记录
-    public static async addRecord(acvitityId: number, roleId: string, type: number, pageIndex: number, lean = true) {
-        let result: ActivityBuyRecordsModelType = await ActivityBuyRecordsModel.findOneAndUpdate({ roleId, acvitityId, type, pageIndex },
+    public static async addRecord(activityId: number, roleId: string, type: number, pageIndex: number, lean = true) {
+        let result: ActivityBuyRecordsModelType = await ActivityBuyRecordsModel.findOneAndUpdate({ roleId, activityId, type, pageIndex },
             {}, { upsert: true, new: true }).lean(lean);
         return result;
     }
 
     //根据活动id查询数据
-    public static async findRecordsByActivityId(acvitityId: number, roleId: string, lean = true) {
-        let result: ActivityBuyRecordsModelType[] = await ActivityBuyRecordsModel.find({ roleId, acvitityId }).lean(lean);
+    public static async findRecordsByActivityId(activityId: number, roleId: string, lean = true) {
+        let result: ActivityBuyRecordsModelType[] = await ActivityBuyRecordsModel.find({ roleId, activityId }).lean(lean);
         return result;
     }
 
     //查询第几页的活动数据
-    public static async findDataBypageIndex(acvitityId: number, type: number, roleId: string, pageIndex: number, lean = true) {
-        let result: ActivityBuyRecordsModelType[] = await ActivityBuyRecordsModel.find({ roleId, type, acvitityId, pageIndex }).lean(lean);
+    public static async findDataBypageIndex(activityId: number, type: number, roleId: string, pageIndex: number, lean = true) {
+        let result: ActivityBuyRecordsModelType[] = await ActivityBuyRecordsModel.find({ roleId, type, activityId, pageIndex }).lean(lean);
         return result;
     }
 
     //删除活动购买记录
-    public static async deleteActivity(acvitityId: number, roleId: string, pageIndex: number, cellIndex: number) {
-        await ActivityBuyRecordsModel.deleteMany({ roleId, acvitityId, pageIndex, cellIndex });
+    public static async deleteActivity(activityId: number, roleId: string, pageIndex: number, cellIndex: number) {
+        await ActivityBuyRecordsModel.deleteMany({ roleId, activityId, pageIndex, cellIndex });
     }
 }
 
diff --git a/shared/db/ActivityDailyChallenges.ts b/shared/db/ActivityDailyChallenges.ts
index 412f10542..82df90253 100644
--- a/shared/db/ActivityDailyChallenges.ts
+++ b/shared/db/ActivityDailyChallenges.ts
@@ -8,7 +8,7 @@ import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoos
 
 export default class ActivityDailyChallenges extends BaseModel {
     @prop({ required: true })
-    acvitityId: number;				// 活动Id
+    activityId: number;				// 活动Id
     @prop({ required: true })
     roleId: string;			        // 用户Id
     @prop({ required: true })
@@ -23,55 +23,55 @@ export default class ActivityDailyChallenges extends BaseModel {
     receiveRewardCount: number;					// 领取奖励次数
 
     //任务领取记录
-    public static async addCellRecord(acvitityId: number, roleId: string, dayIndex: number, cellIndex: number, type: number, count: number, lean = true) {
-        let result: ActivityDailyChallengesModelType = await ActivityDailyChallengesModel.findOneAndUpdate({ roleId, acvitityId, dayIndex, cellIndex, type },
+    public static async addCellRecord(activityId: number, roleId: string, dayIndex: number, cellIndex: number, type: number, count: number, lean = true) {
+        let result: ActivityDailyChallengesModelType = await ActivityDailyChallengesModel.findOneAndUpdate({ roleId, activityId, dayIndex, cellIndex, type },
             { $inc: { receiveRewardCount: count } }, { upsert: true, new: true }).lean(lean);
         return result;
     }
 
     //根据活动统计完成任务次数
-    public static async setTaskCount(acvitityId: number, roleId: string, dayIndex: number, cellIndex: number, type: number, count: number, lean = true) {
-        let result: ActivityDailyChallengesModelType = await ActivityDailyChallengesModel.findOneAndUpdate({ roleId, acvitityId, dayIndex, cellIndex, type },
+    public static async setTaskCount(activityId: number, roleId: string, dayIndex: number, cellIndex: number, type: number, count: number, lean = true) {
+        let result: ActivityDailyChallengesModelType = await ActivityDailyChallengesModel.findOneAndUpdate({ roleId, activityId, dayIndex, cellIndex, type },
             { $set: { totalCount: count } }, { upsert: true, new: true }).lean(lean);
         return result;
     }
 
     //根据活动统计完成任务次数
-    public static async addTaskCount(acvitityId: number, roleId: string, dayIndex: number, cellIndex: number, type: number, addCount: number, lean = true) {
-        let result: ActivityDailyChallengesModelType = await ActivityDailyChallengesModel.findOneAndUpdate({ roleId, acvitityId, dayIndex, cellIndex, type },
+    public static async addTaskCount(activityId: number, roleId: string, dayIndex: number, cellIndex: number, type: number, addCount: number, lean = true) {
+        let result: ActivityDailyChallengesModelType = await ActivityDailyChallengesModel.findOneAndUpdate({ roleId, activityId, dayIndex, cellIndex, type },
             { $inc: { totalCount: addCount } }, { upsert: true, new: true }).lean(lean);
         return result;
     }
 
     //根据活动id查询活动数据
-    public static async findData(acvitityId: number, roleId: string, lean = true) {
-        let result: ActivityDailyChallengesModelType[] = await ActivityDailyChallengesModel.find({ roleId, acvitityId }).lean(lean);
+    public static async findData(activityId: number, roleId: string, lean = true) {
+        let result: ActivityDailyChallengesModelType[] = await ActivityDailyChallengesModel.find({ roleId, activityId }).lean(lean);
         return result;
     }
 
     //查询第几天的活动数据
-    public static async findDataByDayIndex(acvitityId: number, roleId: string, dayIndex: number, lean = true) {
-        let result: ActivityDailyChallengesModelType[] = await ActivityDailyChallengesModel.find({ roleId, acvitityId, dayIndex }).lean(lean);
+    public static async findDataByDayIndex(activityId: number, roleId: string, dayIndex: number, lean = true) {
+        let result: ActivityDailyChallengesModelType[] = await ActivityDailyChallengesModel.find({ roleId, activityId, dayIndex }).lean(lean);
         return result;
     }
 
     //查询第几天某个的活动数据
-    public static async findDataByCellIndex(acvitityId: number, roleId: string, dayIndex: number, cellIndex: number, lean = true) {
-        let result: ActivityDailyChallengesModelType[] = await ActivityDailyChallengesModel.find({ roleId, acvitityId, dayIndex, cellIndex }).lean(lean);
+    public static async findDataByCellIndex(activityId: number, roleId: string, dayIndex: number, cellIndex: number, lean = true) {
+        let result: ActivityDailyChallengesModelType[] = await ActivityDailyChallengesModel.find({ roleId, activityId, dayIndex, cellIndex }).lean(lean);
         return result;
     }
 
     //新增领取记录
-    public static async addData(acvitityId: number, roleId: string, dayIndex: number, cellIndex: number, count: number, lean = true) {
-        let result: ActivityDailyChallengesModelType = await ActivityDailyChallengesModel.findOneAndUpdate({ roleId, acvitityId, dayIndex, cellIndex },
+    public static async addData(activityId: number, roleId: string, dayIndex: number, cellIndex: number, count: number, lean = true) {
+        let result: ActivityDailyChallengesModelType = await ActivityDailyChallengesModel.findOneAndUpdate({ roleId, activityId, dayIndex, cellIndex },
             { $: { count: count } },
             { upsert: true, new: true }).lean(lean);
         return result;
     }
 
     //删除活动领取记录
-    public static async deleteActivity(acvitityId: number, roleId: string, dayIndex: number, cellIndex: number) {
-        await ActivityDailyChallengesModel.deleteMany({ roleId, acvitityId, dayIndex, cellIndex });
+    public static async deleteActivity(activityId: number, roleId: string, dayIndex: number, cellIndex: number) {
+        await ActivityDailyChallengesModel.deleteMany({ roleId, activityId, dayIndex, cellIndex });
     }
 }
 
diff --git a/shared/db/ActivityDailyGifts.ts b/shared/db/ActivityDailyGifts.ts
index 3f2a6fb94..7f3b38cc8 100644
--- a/shared/db/ActivityDailyGifts.ts
+++ b/shared/db/ActivityDailyGifts.ts
@@ -9,7 +9,7 @@ import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoos
 
 export default class ActivityDailyGifts extends BaseModel {
     @prop({ required: true })
-    acvitityId: number;				// 活动Id
+    activityId: number;				// 活动Id
     @prop({ required: true })
     roleId: string;			        // 用户Id
     @prop({ required: true })
@@ -20,33 +20,33 @@ export default class ActivityDailyGifts extends BaseModel {
     buyCount: number;		        // 购买次数
 
     //购买记录
-    public static async buyRecord(acvitityId: number, roleId: string, dayIndex: number, cellIndex: number, count: number, lean = true) {
-        let result: ActivityDailyGiftsModelType = await ActivityDailyGiftsModel.findOneAndUpdate({ roleId, acvitityId, dayIndex, cellIndex },
+    public static async buyRecord(activityId: number, roleId: string, dayIndex: number, cellIndex: number, count: number, lean = true) {
+        let result: ActivityDailyGiftsModelType = await ActivityDailyGiftsModel.findOneAndUpdate({ roleId, activityId, dayIndex, cellIndex },
             { $inc: { receiveRewardCount: count } }, { upsert: true, new: true }).lean(lean);
         return result;
     }
 
     //根据活动id查询活动数据
-    public static async findData(acvitityId: number, roleId: string, lean = true) {
-        let result: ActivityDailyGiftsModelType[] = await ActivityDailyGiftsModel.find({ roleId, acvitityId }).lean(lean);
+    public static async findData(activityId: number, roleId: string, lean = true) {
+        let result: ActivityDailyGiftsModelType[] = await ActivityDailyGiftsModel.find({ roleId, activityId }).lean(lean);
         return result;
     }
 
     //查询第几天的活动数据
-    public static async findDataByDayIndex(acvitityId: number, roleId: string, dayIndex: number, lean = true) {
-        let result: ActivityDailyGiftsModelType[] = await ActivityDailyGiftsModel.find({ roleId, acvitityId, dayIndex }).lean(lean);
+    public static async findDataByDayIndex(activityId: number, roleId: string, dayIndex: number, lean = true) {
+        let result: ActivityDailyGiftsModelType[] = await ActivityDailyGiftsModel.find({ roleId, activityId, dayIndex }).lean(lean);
         return result;
     }
 
     //查询第几天某个的活动数据
-    public static async findDataByCellIndex(acvitityId: number, roleId: string, dayIndex: number, cellIndex: number, lean = true) {
-        let result: ActivityDailyGiftsModelType[] = await ActivityDailyGiftsModel.find({ roleId, acvitityId, dayIndex, cellIndex }).lean(lean);
+    public static async findDataByCellIndex(activityId: number, roleId: string, dayIndex: number, cellIndex: number, lean = true) {
+        let result: ActivityDailyGiftsModelType[] = await ActivityDailyGiftsModel.find({ roleId, activityId, dayIndex, cellIndex }).lean(lean);
         return result;
     }
 
     //删除活动领取记录
-    public static async deleteActivity(acvitityId: number, roleId: string, dayIndex: number, cellIndex: number) {
-        await ActivityDailyGiftsModel.deleteMany({ roleId, acvitityId, dayIndex, cellIndex });
+    public static async deleteActivity(activityId: number, roleId: string, dayIndex: number, cellIndex: number) {
+        await ActivityDailyGiftsModel.deleteMany({ roleId, activityId, dayIndex, cellIndex });
     }
 }
 
diff --git a/shared/db/ActivityFirstGift.ts b/shared/db/ActivityFirstGift.ts
index 3558926ae..8e16977d6 100644
--- a/shared/db/ActivityFirstGift.ts
+++ b/shared/db/ActivityFirstGift.ts
@@ -8,7 +8,7 @@ import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoos
 
 export default class ActivityFirstGift extends BaseModel {
     @prop({ required: true })
-    acvitityId: number;				// 活动Id
+    activityId: number;				// 活动Id
     @prop({ required: true })
     roleId: string;			        // 用户Id
     @prop({ required: true })
@@ -16,27 +16,27 @@ export default class ActivityFirstGift extends BaseModel {
 
 
     //添加领取记录
-    public static async addRecord(acvitityId: number, roleId: string, index: number) {
-        let result: ActivityFirstGiftModelType = await ActivityFirstGiftModel.findOneAndUpdate({ roleId, acvitityId, },
+    public static async addRecord(activityId: number, roleId: string, index: number) {
+        let result: ActivityFirstGiftModelType = await ActivityFirstGiftModel.findOneAndUpdate({ roleId, activityId, },
             { $push: { days: index } }, { upsert: true, new: true }).lean(true);
         return result;
     }
 
     //可以领取首充礼包，充值时间记录
-    public static async begin(acvitityId: number, roleId: string) {
-        let result: ActivityFirstGiftModelType = await ActivityFirstGiftModel.findOneAndUpdate({ roleId, acvitityId },
+    public static async begin(activityId: number, roleId: string) {
+        let result: ActivityFirstGiftModelType = await ActivityFirstGiftModel.findOneAndUpdate({ roleId, activityId },
             {}, { upsert: true, new: true }).lean(true);
         return result;
     }
 
-    public static async findData(acvitityId: number, roleId: string) {
-        let result: ActivityFirstGiftModelType = await ActivityFirstGiftModel.findOne({ roleId, acvitityId }, {}).lean(true);
+    public static async findData(activityId: number, roleId: string) {
+        let result: ActivityFirstGiftModelType = await ActivityFirstGiftModel.findOne({ roleId, activityId }, {}).lean(true);
         return result;
     }
 
     //删除活动领取记录
-    public static async deleteActivity(acvitityId: number, roleId: string, roundIndex: number, index: number,) {
-        await ActivityFirstGiftModel.deleteMany({ roleId, acvitityId, index, roundIndex });
+    public static async deleteActivity(activityId: number, roleId: string, roundIndex: number, index: number,) {
+        await ActivityFirstGiftModel.deleteMany({ roleId, activityId, index, roundIndex });
     }
 }
 
diff --git a/shared/db/ActivityGrowth.ts b/shared/db/ActivityGrowth.ts
index 63f011988..d3d53b9d5 100644
--- a/shared/db/ActivityGrowth.ts
+++ b/shared/db/ActivityGrowth.ts
@@ -8,7 +8,7 @@ import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoos
 
 export default class ActivityGrowth extends BaseModel {
     @prop({ required: true })
-    acvitityId: number;				// 活动Id
+    activityId: number;				// 活动Id
     @prop({ required: true })
     roleId: string;			        // 用户Id
     @prop({ required: true })
@@ -27,62 +27,62 @@ export default class ActivityGrowth extends BaseModel {
     getPointReward: boolean;					// 是否兑换领取奖章奖励
 
     //任务领取记录
-    public static async addCellRecord(acvitityId: number, roleId: string, dayIndex: number, cellIndex: number, type: number, count: number, lean = true) {
-        let result: ActivityGrowthModelType = await ActivityGrowthModel.findOneAndUpdate({ roleId, acvitityId, dayIndex, cellIndex, type },
+    public static async addCellRecord(activityId: number, roleId: string, dayIndex: number, cellIndex: number, type: number, count: number, lean = true) {
+        let result: ActivityGrowthModelType = await ActivityGrowthModel.findOneAndUpdate({ roleId, activityId, dayIndex, cellIndex, type },
             { $inc: { receiveRewardCount: count } }, { upsert: true, new: true }).lean(lean);
         return result;
     }
 
     //当日奖章领取记录
-    public static async addDayRecord(acvitityId: number, roleId: string, dayIndex: number, cellIndex: number, lean = true) {
-        let result: ActivityGrowthModelType = await ActivityGrowthModel.findOneAndUpdate({ roleId, acvitityId, dayIndex, cellIndex },
+    public static async addDayRecord(activityId: number, roleId: string, dayIndex: number, cellIndex: number, lean = true) {
+        let result: ActivityGrowthModelType = await ActivityGrowthModel.findOneAndUpdate({ roleId, activityId, dayIndex, cellIndex },
             { $set: { getPointReward: true } }, { upsert: true, new: true }).lean(lean);
         return result;
     }
 
     //根据活动统计完成任务次数
-    public static async setTaskCount(acvitityId: number, roleId: string, dayIndex: number, cellIndex: number, type: number, count: number, lean = true) {
-        let result: ActivityGrowthModelType = await ActivityGrowthModel.findOneAndUpdate({ roleId, acvitityId, dayIndex, cellIndex, type },
+    public static async setTaskCount(activityId: number, roleId: string, dayIndex: number, cellIndex: number, type: number, count: number, lean = true) {
+        let result: ActivityGrowthModelType = await ActivityGrowthModel.findOneAndUpdate({ roleId, activityId, dayIndex, cellIndex, type },
             { $set: { totalCount: count } }, { upsert: true, new: true }).lean(lean);
         return result;
     }
 
     //根据活动统计完成任务次数
-    public static async addTaskCount(acvitityId: number, roleId: string, dayIndex: number, cellIndex: number, type: number, addCount: number, lean = true) {
-        let result: ActivityGrowthModelType = await ActivityGrowthModel.findOneAndUpdate({ roleId, acvitityId, dayIndex, cellIndex, type },
+    public static async addTaskCount(activityId: number, roleId: string, dayIndex: number, cellIndex: number, type: number, addCount: number, lean = true) {
+        let result: ActivityGrowthModelType = await ActivityGrowthModel.findOneAndUpdate({ roleId, activityId, dayIndex, cellIndex, type },
             { $inc: { totalCount: addCount } }, { upsert: true, new: true }).lean(lean);
         return result;
     }
 
     //根据活动id查询活动数据
-    public static async findData(acvitityId: number, roleId: string, lean = true) {
-        let result: ActivityGrowthModelType[] = await ActivityGrowthModel.find({ roleId, acvitityId }).lean(lean);
+    public static async findData(activityId: number, roleId: string, lean = true) {
+        let result: ActivityGrowthModelType[] = await ActivityGrowthModel.find({ roleId, activityId }).lean(lean);
         return result;
     }
 
     //查询第几天的活动数据
-    public static async findDataByDayIndex(acvitityId: number, roleId: string, dayIndex: number, lean = true) {
-        let result: ActivityGrowthModelType[] = await ActivityGrowthModel.find({ roleId, acvitityId, dayIndex }).lean(lean);
+    public static async findDataByDayIndex(activityId: number, roleId: string, dayIndex: number, lean = true) {
+        let result: ActivityGrowthModelType[] = await ActivityGrowthModel.find({ roleId, activityId, dayIndex }).lean(lean);
         return result;
     }
 
     //查询第几天某个的活动数据
-    public static async findDataByCellIndex(acvitityId: number, roleId: string, dayIndex: number, cellIndex: number, lean = true) {
-        let result: ActivityGrowthModelType[] = await ActivityGrowthModel.find({ roleId, acvitityId, dayIndex, cellIndex }).lean(lean);
+    public static async findDataByCellIndex(activityId: number, roleId: string, dayIndex: number, cellIndex: number, lean = true) {
+        let result: ActivityGrowthModelType[] = await ActivityGrowthModel.find({ roleId, activityId, dayIndex, cellIndex }).lean(lean);
         return result;
     }
 
     //新增领取记录
-    public static async addData(acvitityId: number, roleId: string, dayIndex: number, cellIndex: number, count: number, lean = true) {
-        let result: ActivityGrowthModelType = await ActivityGrowthModel.findOneAndUpdate({ roleId, acvitityId, dayIndex, cellIndex },
+    public static async addData(activityId: number, roleId: string, dayIndex: number, cellIndex: number, count: number, lean = true) {
+        let result: ActivityGrowthModelType = await ActivityGrowthModel.findOneAndUpdate({ roleId, activityId, dayIndex, cellIndex },
             { $: { count: count } },
             { upsert: true, new: true }).lean(lean);
         return result;
     }
 
     //删除活动领取记录
-    public static async deleteActivity(acvitityId: number, roleId: string, dayIndex: number, cellIndex: number) {
-        await ActivityGrowthModel.deleteMany({ roleId, acvitityId, dayIndex, cellIndex });
+    public static async deleteActivity(activityId: number, roleId: string, dayIndex: number, cellIndex: number) {
+        await ActivityGrowthModel.deleteMany({ roleId, activityId, dayIndex, cellIndex });
     }
 }
 
diff --git a/shared/db/ActivityGrowthFund.ts b/shared/db/ActivityGrowthFund.ts
index 95c602480..28fa9ea97 100644
--- a/shared/db/ActivityGrowthFund.ts
+++ b/shared/db/ActivityGrowthFund.ts
@@ -8,7 +8,7 @@ import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoos
 
 export default class ActivityGrowthFund extends BaseModel {
     @prop({ required: true })
-    acvitityId: number;				// 活动Id
+    activityId: number;				// 活动Id
     @prop({ required: true })
     roleId: string;			        // 用户Id
     @prop({ required: true })
@@ -20,33 +20,33 @@ export default class ActivityGrowthFund extends BaseModel {
 
 
     //添加领取记录
-    public static async addRecord(acvitityId: number, roleId: string, pageIndex: number, cellIndex: number, lean = true) {
-        let result: ActivityGrowthFundModelType = await ActivityGrowthFundModel.findOneAndUpdate({ roleId, acvitityId, pageIndex, cellIndex },
+    public static async addRecord(activityId: number, roleId: string, pageIndex: number, cellIndex: number, lean = true) {
+        let result: ActivityGrowthFundModelType = await ActivityGrowthFundModel.findOneAndUpdate({ roleId, activityId, pageIndex, cellIndex },
             { $set: { isReceive: true } }, { upsert: true, new: true }).lean(lean);
         return result;
     }
 
     //根据活动id查询活动数据
-    public static async findData(acvitityId: number, roleId: string, lean = true) {
-        let result: ActivityGrowthFundModelType[] = await ActivityGrowthFundModel.find({ roleId, acvitityId }).lean(lean);
+    public static async findData(activityId: number, roleId: string, lean = true) {
+        let result: ActivityGrowthFundModelType[] = await ActivityGrowthFundModel.find({ roleId, activityId }).lean(lean);
         return result;
     }
 
     //查询第几页的活动数据
-    public static async findDataBypageIndex(acvitityId: number, roleId: string, pageIndex: number, lean = true) {
-        let result: ActivityGrowthFundModelType[] = await ActivityGrowthFundModel.find({ roleId, acvitityId, pageIndex }).lean(lean);
+    public static async findDataBypageIndex(activityId: number, roleId: string, pageIndex: number, lean = true) {
+        let result: ActivityGrowthFundModelType[] = await ActivityGrowthFundModel.find({ roleId, activityId, pageIndex }).lean(lean);
         return result;
     }
 
     //查询第*页的某个的活动数据
-    public static async findDataByCellIndex(acvitityId: number, roleId: string, pageIndex: number, cellIndex: number, lean = true) {
-        let result: ActivityGrowthFundModelType[] = await ActivityGrowthFundModel.find({ roleId, acvitityId, pageIndex, cellIndex }).lean(lean);
+    public static async findDataByCellIndex(activityId: number, roleId: string, pageIndex: number, cellIndex: number, lean = true) {
+        let result: ActivityGrowthFundModelType[] = await ActivityGrowthFundModel.find({ roleId, activityId, pageIndex, cellIndex }).lean(lean);
         return result;
     }
 
     //删除活动领取记录
-    public static async deleteActivity(acvitityId: number, roleId: string, pageIndex: number, cellIndex: number) {
-        await ActivityGrowthFundModel.deleteMany({ roleId, acvitityId, pageIndex, cellIndex });
+    public static async deleteActivity(activityId: number, roleId: string, pageIndex: number, cellIndex: number) {
+        await ActivityGrowthFundModel.deleteMany({ roleId, activityId, pageIndex, cellIndex });
     }
 }
 
diff --git a/shared/db/ActivitySelfServiceGoods.ts b/shared/db/ActivitySelfServiceGoods.ts
index 33e3ffc46..a687d9bad 100644
--- a/shared/db/ActivitySelfServiceGoods.ts
+++ b/shared/db/ActivitySelfServiceGoods.ts
@@ -8,7 +8,7 @@ import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoos
 
 export default class ActivitySelfServiceGoods extends BaseModel {
     @prop({ required: true })
-    acvitityId: number;				// 活动Id
+    activityId: number;				// 活动Id
     @prop({ required: true })
     roundIndex: number;				// 活动第几周期 从1开始，根据活动开始时间计算    
     @prop({ required: true })
@@ -24,28 +24,28 @@ export default class ActivitySelfServiceGoods extends BaseModel {
 
 
     //添加选中的物品
-    public static async addGoods(acvitityId: number, roleId: string, roundIndex: number, index: number, cellIndex: number, gift: number, rewardIndex: number) {
-        let result: ActivitySelfServiceGoodsModelType = await ActivitySelfServiceGoodsModel.findOneAndUpdate({ roleId, acvitityId, roundIndex, index, cellIndex },
+    public static async addGoods(activityId: number, roleId: string, roundIndex: number, index: number, cellIndex: number, gift: number, rewardIndex: number) {
+        let result: ActivitySelfServiceGoodsModelType = await ActivitySelfServiceGoodsModel.findOneAndUpdate({ roleId, activityId, roundIndex, index, cellIndex },
             { $set: { gift, rewardIndex } }, { upsert: true, new: true }).lean(true);
         return result;
     }
 
-    public static async findData(acvitityId: number, roleId: string, roundIndex: number, lean = true) {
-        let result: ActivitySelfServiceGoodsModelType[] = await ActivitySelfServiceGoodsModel.find({ roleId, acvitityId, roundIndex }, {
+    public static async findData(activityId: number, roleId: string, roundIndex: number, lean = true) {
+        let result: ActivitySelfServiceGoodsModelType[] = await ActivitySelfServiceGoodsModel.find({ roleId, activityId, roundIndex }, {
             index: 1, cellIndex: 1, gift: 1, rewardIndex: 1, _id: -1
         }).lean(lean);
         return result;
     }
 
     //查询第几个货架数据
-    public static async findDataByIndex(acvitityId: number, roleId: string, roundIndex: number, index: number, lean = true) {
-        let result: ActivitySelfServiceGoodsModelType[] = await ActivitySelfServiceGoodsModel.find({ roleId, acvitityId, roundIndex, index }).lean(lean);
+    public static async findDataByIndex(activityId: number, roleId: string, roundIndex: number, index: number, lean = true) {
+        let result: ActivitySelfServiceGoodsModelType[] = await ActivitySelfServiceGoodsModel.find({ roleId, activityId, roundIndex, index }).lean(lean);
         return result;
     }
 
     //删除活动领取记录
-    public static async deleteActivity(acvitityId: number, roleId: string, roundIndex: number, index: number,) {
-        await ActivitySelfServiceGoodsModel.deleteMany({ roleId, acvitityId, index, roundIndex });
+    public static async deleteActivity(activityId: number, roleId: string, roundIndex: number, index: number,) {
+        await ActivitySelfServiceGoodsModel.deleteMany({ roleId, activityId, index, roundIndex });
     }
 }
 
diff --git a/shared/db/ActivitySelfServiceShop.ts b/shared/db/ActivitySelfServiceShop.ts
index 8764bd01c..7450ad044 100644
--- a/shared/db/ActivitySelfServiceShop.ts
+++ b/shared/db/ActivitySelfServiceShop.ts
@@ -9,7 +9,7 @@ import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoos
 
 export default class ActivitySelfServiceShop extends BaseModel {
     @prop({ required: true })
-    acvitityId: number;				// 活动Id
+    activityId: number;				// 活动Id
     @prop({ required: true })
     roundIndex: number;				// 活动第几周期 从1开始，根据活动开始时间计算    
     @prop({ required: true })
@@ -24,33 +24,33 @@ export default class ActivitySelfServiceShop extends BaseModel {
     goods: string;		            // 商品信息
 
     //添加购买记录
-    public static async addBuyRecord(acvitityId: number, roleId: string, roundIndex: number, index: number, price: number, priceType: number, goods: string) {
+    public static async addBuyRecord(activityId: number, roleId: string, roundIndex: number, index: number, price: number, priceType: number, goods: string) {
         await ActivitySelfServiceShopModel.insertMany([
-            { roleId, acvitityId, roundIndex, index, price, priceType, goods }
+            { roleId, activityId, roundIndex, index, price, priceType, goods }
         ])
     }
 
     //根据活动id查询活动数据
-    public static async findData(acvitityId: number, roleId: string, roundIndex: number, lean = true) {
-        let result: ActivitySelfServiceShopModelType[] = await ActivitySelfServiceShopModel.find({ roleId, acvitityId, roundIndex }).lean(lean);
+    public static async findData(activityId: number, roleId: string, roundIndex: number, lean = true) {
+        let result: ActivitySelfServiceShopModelType[] = await ActivitySelfServiceShopModel.find({ roleId, activityId, roundIndex }).lean(lean);
         return result;
     }
 
     //查询第几个货架数据
-    public static async findDataByIndex(acvitityId: number, roleId: string, roundIndex: number, index: number, lean = true) {
-        let result: ActivitySelfServiceShopModelType[] = await ActivitySelfServiceShopModel.find({ roleId, acvitityId, roundIndex, index }).lean(lean);
+    public static async findDataByIndex(activityId: number, roleId: string, roundIndex: number, index: number, lean = true) {
+        let result: ActivitySelfServiceShopModelType[] = await ActivitySelfServiceShopModel.find({ roleId, activityId, roundIndex, index }).lean(lean);
         return result;
     }
 
     //查询购买价格类型的数据
-    public static async findDataByPriceType(acvitityId: number, roleId: string, roundIndex: number, priceType: number, lean = true) {
-        let result: ActivitySelfServiceShopModelType[] = await ActivitySelfServiceShopModel.find({ roleId, acvitityId, priceType, roundIndex }).lean(lean);
+    public static async findDataByPriceType(activityId: number, roleId: string, roundIndex: number, priceType: number, lean = true) {
+        let result: ActivitySelfServiceShopModelType[] = await ActivitySelfServiceShopModel.find({ roleId, activityId, priceType, roundIndex }).lean(lean);
         return result;
     }
 
     //删除活动领取记录
-    public static async deleteActivity(acvitityId: number, roleId: string, roundIndex: number, index: number,) {
-        await ActivitySelfServiceShopModel.deleteMany({ roleId, acvitityId, index, roundIndex });
+    public static async deleteActivity(activityId: number, roleId: string, roundIndex: number, index: number,) {
+        await ActivitySelfServiceShopModel.deleteMany({ roleId, activityId, index, roundIndex });
     }
 }
 
diff --git a/shared/db/ActivityShop.ts b/shared/db/ActivityShop.ts
new file mode 100644
index 000000000..6ea84228f
--- /dev/null
+++ b/shared/db/ActivityShop.ts
@@ -0,0 +1,54 @@
+import BaseModel from './BaseModel';
+import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
+
+
+/**
+  * 购买记录
+*/
+
+export class BuyRecord {
+    @prop({ required: true })
+    id: number; //物品id标识
+    @prop({ required: true })
+    time: Date; //购买时间
+}
+
+
+/**
+  * 活动系统 - 新手限定、每日限购、每周限购
+*/
+@index({ roleId: 1 })
+
+export default class ActivityShop extends BaseModel {
+    @prop({ required: true })
+    activityId: number;				// 活动Id
+    @prop({ required: true })
+    roleId: string;			        // 用户Id
+    @prop({ required: true })
+    roundIndex: number;				// 第几个周期，从1开始
+    @prop({ required: true })
+    records: BuyRecord[];		    // 购买记录
+
+    //购买领取奖励的记录
+    public static async addRecord(activityId: number, roleId: string, roundIndex: number, id: number) {
+        let result: ActivityShopModelType = await ActivityShopModel.findOneAndUpdate({ roleId, activityId, roundIndex },
+            { $push: { records: { id, time: new Date() } } }, { upsert: true, new: true }).lean(true);
+        return result;
+    }
+
+    //根据活动id查询活动数据
+    public static async findData(activityId: number, roleId: string, roundIndex: number) {
+        let result: ActivityShopModelType = await ActivityShopModel.findOne({ roleId, activityId, roundIndex }).lean(true);
+        return result;
+    }
+
+    //删除活动领取记录
+    public static async deleteActivity(activityId: number, roleId: string, roundIndex: number) {
+        await ActivityShopModel.deleteMany({ roleId, activityId, roundIndex });
+    }
+}
+
+export const ActivityShopModel = getModelForClass(ActivityShop);
+
+export interface ActivityShopModelType extends Pick<DocumentType<ActivityShop>, keyof ActivityShop> { }
+export type ActivityShopModelTypeParam = Partial<ActivityShopModelType>; // 将所有字段变成可选项
\ No newline at end of file
diff --git a/shared/db/ActivitySignIn.ts b/shared/db/ActivitySignIn.ts
index 315dc8c8a..54504be88 100644
--- a/shared/db/ActivitySignIn.ts
+++ b/shared/db/ActivitySignIn.ts
@@ -8,7 +8,7 @@ import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoos
 
 export default class ActivitySignIn extends BaseModel {
     @prop({ required: true })
-    acvitityId: number;				// 活动Id
+    activityId: number;				// 活动Id
     @prop({ required: true })
     roleId: string;			        // 用户Id
     @prop({ required: true })
@@ -17,27 +17,27 @@ export default class ActivitySignIn extends BaseModel {
     isReceive: boolean;			    // 是否领取
 
     //签到记录
-    public static async addSignInRecord(acvitityId: number, roleId: string, dayIndex: number, lean = true) {
-        let result: ActivitySignInModelType = await ActivitySignInModel.findOneAndUpdate({ roleId, acvitityId, dayIndex },
+    public static async addSignInRecord(activityId: number, roleId: string, dayIndex: number, lean = true) {
+        let result: ActivitySignInModelType = await ActivitySignInModel.findOneAndUpdate({ roleId, activityId, dayIndex },
             { $set: { isReceive: true } }, { upsert: true, new: true }).lean(lean);
         return result;
     }
 
     //根据活动id查询活动数据
-    public static async findData(acvitityId: number, roleId: string, lean = true) {
-        let result: ActivitySignInModelType[] = await ActivitySignInModel.find({ roleId, acvitityId }).lean(lean);
+    public static async findData(activityId: number, roleId: string, lean = true) {
+        let result: ActivitySignInModelType[] = await ActivitySignInModel.find({ roleId, activityId }).lean(lean);
         return result;
     }
 
     //查询第几天的活动数据
-    public static async findDataByDayIndex(acvitityId: number, roleId: string, dayIndex: number, lean = true) {
-        let result: ActivitySignInModelType[] = await ActivitySignInModel.find({ roleId, acvitityId, dayIndex }).lean(lean);
+    public static async findDataByDayIndex(activityId: number, roleId: string, dayIndex: number, lean = true) {
+        let result: ActivitySignInModelType[] = await ActivitySignInModel.find({ roleId, activityId, dayIndex }).lean(lean);
         return result;
     }
 
     //删除签到记录
-    public static async deleteActivity(acvitityId: number, roleId: string, dayIndex: number) {
-        await ActivitySignInModel.deleteMany({ roleId, acvitityId, dayIndex });
+    public static async deleteActivity(activityId: number, roleId: string, dayIndex: number) {
+        await ActivitySignInModel.deleteMany({ roleId, activityId, dayIndex });
     }
 }
 
diff --git a/shared/db/ActivityThirtyDays.ts b/shared/db/ActivityThirtyDays.ts
index 59a595811..63c4ab426 100644
--- a/shared/db/ActivityThirtyDays.ts
+++ b/shared/db/ActivityThirtyDays.ts
@@ -8,7 +8,7 @@ import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoos
 
 export default class ActivityThirtyDays extends BaseModel {
     @prop({ required: true })
-    acvitityId: number;				// 活动Id
+    activityId: number;				// 活动Id
     @prop({ required: true })
     roleId: string;			        // 用户Id
     @prop({ required: true })
@@ -23,47 +23,47 @@ export default class ActivityThirtyDays extends BaseModel {
     isReceive: boolean;				// 是否领取过奖励
 
     //添加领取记录
-    public static async addRecord(acvitityId: number, roleId: string, pageIndex: number, cellIndex: number, lean = true) {
-        let result: ActivityThirtyDaysModelType = await ActivityThirtyDaysModel.findOneAndUpdate({ roleId, acvitityId, pageIndex, cellIndex },
+    public static async addRecord(activityId: number, roleId: string, pageIndex: number, cellIndex: number, lean = true) {
+        let result: ActivityThirtyDaysModelType = await ActivityThirtyDaysModel.findOneAndUpdate({ roleId, activityId, pageIndex, cellIndex },
             { $set: { isReceive: true } }, { upsert: true, new: true }).lean(lean);
         return result;
     }
 
     //根据活动统计完成任务次数
-    public static async addTaskCount(acvitityId: number, roleId: string, pageIndex: number, cellIndex: number, type: number, addCount: number, lean = true) {
-        let result: ActivityThirtyDaysModelType = await ActivityThirtyDaysModel.findOneAndUpdate({ roleId, acvitityId, pageIndex, cellIndex, type },
+    public static async addTaskCount(activityId: number, roleId: string, pageIndex: number, cellIndex: number, type: number, addCount: number, lean = true) {
+        let result: ActivityThirtyDaysModelType = await ActivityThirtyDaysModel.findOneAndUpdate({ roleId, activityId, pageIndex, cellIndex, type },
             { $inc: { totalCount: addCount } }, { upsert: true, new: true }).lean(lean);
         return result;
     }
 
     //根据活动统计完成任务次数
-    public static async setTaskCount(acvitityId: number, roleId: string, pageIndex: number, cellIndex: number, type: number, count: number, lean = true) {
-        let result: ActivityThirtyDaysModelType = await ActivityThirtyDaysModel.findOneAndUpdate({ roleId, acvitityId, pageIndex, cellIndex, type },
+    public static async setTaskCount(activityId: number, roleId: string, pageIndex: number, cellIndex: number, type: number, count: number, lean = true) {
+        let result: ActivityThirtyDaysModelType = await ActivityThirtyDaysModel.findOneAndUpdate({ roleId, activityId, pageIndex, cellIndex, type },
             { $set: { totalCount: count } }, { upsert: true, new: true }).lean(lean);
         return result;
     }
 
     //根据活动id查询活动数据
-    public static async findData(acvitityId: number, roleId: string, lean = true) {
-        let result: ActivityThirtyDaysModelType[] = await ActivityThirtyDaysModel.find({ roleId, acvitityId }).lean(lean);
+    public static async findData(activityId: number, roleId: string, lean = true) {
+        let result: ActivityThirtyDaysModelType[] = await ActivityThirtyDaysModel.find({ roleId, activityId }).lean(lean);
         return result;
     }
 
     //查询第几页的活动数据
-    public static async findDataBypageIndex(acvitityId: number, roleId: string, pageIndex: number, lean = true) {
-        let result: ActivityThirtyDaysModelType[] = await ActivityThirtyDaysModel.find({ roleId, acvitityId, pageIndex }).lean(lean);
+    public static async findDataBypageIndex(activityId: number, roleId: string, pageIndex: number, lean = true) {
+        let result: ActivityThirtyDaysModelType[] = await ActivityThirtyDaysModel.find({ roleId, activityId, pageIndex }).lean(lean);
         return result;
     }
 
     //查询第*页的某个的活动数据
-    public static async findDataByCellIndex(acvitityId: number, roleId: string, pageIndex: number, cellIndex: number, lean = true) {
-        let result: ActivityThirtyDaysModelType[] = await ActivityThirtyDaysModel.find({ roleId, acvitityId, pageIndex, cellIndex }).lean(lean);
+    public static async findDataByCellIndex(activityId: number, roleId: string, pageIndex: number, cellIndex: number, lean = true) {
+        let result: ActivityThirtyDaysModelType[] = await ActivityThirtyDaysModel.find({ roleId, activityId, pageIndex, cellIndex }).lean(lean);
         return result;
     }
 
     //删除活动领取记录
-    public static async deleteActivity(acvitityId: number, roleId: string, pageIndex: number, cellIndex: number) {
-        await ActivityThirtyDaysModel.deleteMany({ roleId, acvitityId, pageIndex, cellIndex });
+    public static async deleteActivity(activityId: number, roleId: string, pageIndex: number, cellIndex: number) {
+        await ActivityThirtyDaysModel.deleteMany({ roleId, activityId, pageIndex, cellIndex });
     }
 }
 
diff --git a/shared/db/ActivityThirtyDaysPointReward.ts b/shared/db/ActivityThirtyDaysPointReward.ts
index 261453cf4..a4c00da5e 100644
--- a/shared/db/ActivityThirtyDaysPointReward.ts
+++ b/shared/db/ActivityThirtyDaysPointReward.ts
@@ -8,7 +8,7 @@ import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoos
 
 export default class ActivityThirtyDaysPointReward extends BaseModel {
     @prop({ required: true })
-    acvitityId: number;				// 活动Id
+    activityId: number;				// 活动Id
     @prop({ required: true })
     roleId: string;			        // 用户Id
     @prop({ required: true })
@@ -19,11 +19,11 @@ export default class ActivityThirtyDaysPointReward extends BaseModel {
     isExpired: boolean;				// 是否过期奖励
 
     //添加过期记录
-    public static async setExpired(acvitityId: number, roleId: string, cells: Array<number>) {
+    public static async setExpired(activityId: number, roleId: string, cells: Array<number>) {
         let records = [];
         for (let cellIndex of cells) {
             let data = {
-                acvitityId,
+                activityId,
                 roleId,
                 cellIndex,
                 isReceive: false,
@@ -35,27 +35,27 @@ export default class ActivityThirtyDaysPointReward extends BaseModel {
     }
 
     //添加领取记录
-    public static async addRecord(acvitityId: number, roleId: string, cellIndex: number, lean = true) {
-        let result: ActivityThirtyDaysPointRewardModelType = await ActivityThirtyDaysPointRewardModel.findOneAndUpdate({ roleId, acvitityId, cellIndex },
+    public static async addRecord(activityId: number, roleId: string, cellIndex: number, lean = true) {
+        let result: ActivityThirtyDaysPointRewardModelType = await ActivityThirtyDaysPointRewardModel.findOneAndUpdate({ roleId, activityId, cellIndex },
             { $set: { isReceive: true } }, { upsert: true, new: true }).lean(lean);
         return result;
     }
 
     //根据活动id查询活动数据
-    public static async findData(acvitityId: number, roleId: string, lean = true) {
-        let result: ActivityThirtyDaysPointRewardModelType[] = await ActivityThirtyDaysPointRewardModel.find({ roleId, acvitityId }).lean(lean);
+    public static async findData(activityId: number, roleId: string, lean = true) {
+        let result: ActivityThirtyDaysPointRewardModelType[] = await ActivityThirtyDaysPointRewardModel.find({ roleId, activityId }).lean(lean);
         return result;
     }
 
     //第几个活动数据
-    public static async findDataByCellIndex(acvitityId: number, roleId: string, cellIndex: number, lean = true) {
-        let result: ActivityThirtyDaysPointRewardModelType[] = await ActivityThirtyDaysPointRewardModel.find({ roleId, acvitityId, cellIndex }).lean(lean);
+    public static async findDataByCellIndex(activityId: number, roleId: string, cellIndex: number, lean = true) {
+        let result: ActivityThirtyDaysPointRewardModelType[] = await ActivityThirtyDaysPointRewardModel.find({ roleId, activityId, cellIndex }).lean(lean);
         return result;
     }
 
     //删除活动领取记录
-    public static async deleteActivity(acvitityId: number, roleId: string, cellIndex: number) {
-        await ActivityThirtyDaysPointRewardModel.deleteMany({ roleId, acvitityId, cellIndex });
+    public static async deleteActivity(activityId: number, roleId: string, cellIndex: number) {
+        await ActivityThirtyDaysPointRewardModel.deleteMany({ roleId, activityId, cellIndex });
     }
 }
 
diff --git a/shared/domain/activityField/activityField.ts b/shared/domain/activityField/activityField.ts
index c2b6fa5cc..aa639e712 100644
--- a/shared/domain/activityField/activityField.ts
+++ b/shared/domain/activityField/activityField.ts
@@ -17,7 +17,7 @@ export abstract class ActivityBase {
     }
 
     constructor(activityData: ActivityModelType) {
-        this.activityId = activityData.acvitityId;
+        this.activityId = activityData.activityId;
         this.beginTime = activityData.beginTime;
         this.endTime = activityData.endTime;
         this.type = activityData.type;
diff --git a/shared/domain/activityField/limitShopField.ts b/shared/domain/activityField/limitShopField.ts
new file mode 100644
index 000000000..df373a584
--- /dev/null
+++ b/shared/domain/activityField/limitShopField.ts
@@ -0,0 +1,75 @@
+import { ACTIVITY_RESOURCES_TYPE } from '../../consts';
+import { ActivityModelType } from '../../db/Activity';
+import { ActivityShopModelType } from '../../db/ActivityShop';
+import { ActivityBase } from './activityField';
+
+// 每个商品的内容
+export class ShopItem {
+    id: number;             // 商品id
+    reward: string;         //任务奖励，格式:1&3&1(类型&id&数量) 类型定义:1.英雄，2.物品
+    countMax: number = 0;   //可购买的最大次数，0表示不限制
+    name: string;           //名字
+
+    buyCount: number = 0;   //购买过的次数
+
+    constructor(data: any) {
+        this.id = data.id;
+        this.reward = data.reward;
+        this.countMax = data.countMax;
+        this.name = data.name;
+    }
+}
+
+// 商店数据
+export class LimitShopData extends ActivityBase {
+    name: string = '';//活动名称
+    interval: number = 0;//周期间隔（秒）
+    list: Array<ShopItem> = [];//商品列表
+    refreshTime: Date;//下次刷新时间
+    roundIndex: number = 1;//周期数从1开始
+
+    public findItem(id: number) {
+        let index = this.list.findIndex(obj => { return obj && obj.id === id });
+        return (index != -1) ? this.list[index] : null
+    }
+
+    //全部领取完成
+    public isComplete() {
+        for (let item of this.list) {
+            if (item.countMax == 0 ||
+                (item.countMax > 0 && item.buyCount < item.countMax)) {
+                return false
+            }
+        }
+        return true;
+    }
+
+    //解析玩家购买记录
+    public setPlayerRecords(data: ActivityShopModelType) {
+        if (!data) {
+            return;
+        }
+        let records = data.records ? data.records : [];
+        for (let item of this.list) {
+            let buyRecords = records.filter(obj => { return obj && obj.id === item.id });
+            item.buyCount = buyRecords.length;
+        }
+    }
+
+
+    public initData(data: string) {
+        let dataObj = JSON.parse(data);
+        this.name = dataObj.name;
+        this.interval = dataObj.interval;
+
+        let arr = dataObj.data;
+        for (let obj of arr) {
+            this.list.push(new ShopItem(obj))
+        }
+    }
+
+    constructor(activityData: ActivityModelType) {
+        super(activityData)
+        this.initData(activityData.data)
+    }
+}
\ No newline at end of file
diff --git a/shared/pubUtils/taskUtil.ts b/shared/pubUtils/taskUtil.ts
index 9420d0dc2..f6ec0bc3f 100644
--- a/shared/pubUtils/taskUtil.ts
+++ b/shared/pubUtils/taskUtil.ts
@@ -534,7 +534,7 @@ export async function accomplishTask(roleId: string, taskType: TASK_TYPE, count:
         allActivity = await ActivityModel.findOpenActivityByType(ACTIVITY_TYPE.THIRTY_DAYS, new Date());
         for (let activity of allActivity) {
             let thirtyDaysActivity = new ThirtyDaysData(activity);
-            let playerRecords: ActivityThirtyDaysModelType[] = await ActivityThirtyDaysModel.findData(activity.acvitityId, roleId);
+            let playerRecords: ActivityThirtyDaysModelType[] = await ActivityThirtyDaysModel.findData(activity.activityId, roleId);
             thirtyDaysActivity.setPlayerRecords(playerRecords);
             let taskArray = thirtyDaysActivity.findUncompleteTaskByType(taskType);
             for (let task of taskArray) {