🐞 fix(订单): 各种类型的订单在支付之前校验次数

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

@@ -68,6 +68,9 @@ export async function makeDailyRMBGiftsReward(roleId: string, roleName: string,
     let playerData = new DailyRMBGiftsData(activityData, createTime, serverTime);
     let bigGiftProductID = playerData.productID;
     if (bigGiftProductID == productID) {//一次性购买7天礼包
+        let hasBoughtTomorrow = await ActivityDailyRMBGiftsModel.checkHasBought(serverId, activityData.activityId, roleId, moment(playerData.beginTime).toDate(), playerData.todayIndex + 1);
+        if(hasBoughtTomorrow) return STATUS.ORDER_CANNOT_BUY;
+
         let playerRecord: ActivityDailyRMBGiftsModelType = await ActivityDailyRMBGiftsModel.findRecord(serverId, activityId, roleId, moment(playerData.beginTime).toDate(), playerData.todayIndex);
         playerData.setPlayerRecords(playerRecord?[playerRecord]: []);
         if (playerData.shouldbuyNextDay()) {//今天已经购买过其他奖励
@@ -85,11 +88,12 @@ export async function makeDailyRMBGiftsReward(roleId: string, roleName: string,
         }
     } else {
         let item = playerData.findProduct(productID);
-        if (!item) {
+        if (!item) return STATUS.ACTIVITY_NO_PRODUCT;  
-            return {
+        let hasReceived = await ActivityDailyRMBGiftsModel.checkHasReceive(serverId, activityData.activityId, roleId, moment(playerData.beginTime).toDate(), playerData.todayIndex, item.id);
-                code: STATUS.ACTIVITY_NO_PRODUCT,
+        if(hasReceived) {
-            }
+            return STATUS.ORDER_CANNOT_BUY
         }
+
         let rewardParamArr: Array<RewardParam> = stringToRewardParam(item.reward);
         let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.DAILY_RMB_GIFT)
         await ActivityDailyRMBGiftsModel.receiveRecord(serverId, activityId, roleId, moment(playerData.beginTime).toDate(), playerData.todayIndex, [item.id]);
@@ -100,3 +104,30 @@ export async function makeDailyRMBGiftsReward(roleId: string, roleName: string,
         }
     }
 }
+
+
+/**
+   * 检查每日特惠是否可以购买
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   * @param {string} productID 商品ID
+   *
+   */
+export async function checkDailyRMBGifts(roleId: string, serverId: number, activityData: ActivityModelType, productID: string) {
+    if(!activityData) return false
+    let createTime = await getRoleCreateTime(roleId);
+    let serverTime = await getServerCreateTime(serverId);
+    let playerData = new DailyRMBGiftsData(activityData, createTime, serverTime);
+    let bigGiftProductID = playerData.productID;
+    if (bigGiftProductID == productID) {//一次性购买7天礼包
+        let hasBoughtTomorrow = await ActivityDailyRMBGiftsModel.checkHasBought(serverId, activityData.activityId, roleId, moment(playerData.beginTime).toDate(), playerData.todayIndex + 1);
+        return !hasBoughtTomorrow;
+    } else {
+        let item = playerData.findProduct(productID);
+        if (!item) return false
+        let hasReceived = await ActivityDailyRMBGiftsModel.checkHasReceive(serverId, activityData.activityId, roleId, moment(playerData.beginTime).toDate(), playerData.todayIndex, item.id);
+        return !hasReceived;
+    }
+}

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

@@ -143,9 +143,23 @@ export async function makeGrowthFund(roleId: string, roleName: string, sid: stri
     let playerData = new GrowthFundData(activityData, createTime, serverTime);
     let pageData = playerData.findPageByProductID(productID);
     let pageIndex = pageData.pageIndex;
+    let checkResult = await ActivityBuyRecordsModel.checkRecord(activityId, roleId, activityData.type, pageIndex);
+    if(checkResult) return STATUS.ORDER_CANNOT_BUY;
+
     await ActivityBuyRecordsModel.addRecord(activityId, roleId, activityData.type, pageIndex, true);
     return {
         code: 0,
         data: Object.assign({}, { item: { pageIndex }, activityId: activityId })
     }
+}
+
+export async function checkGrowthFund(roleId: string, serverId: number, activityData: ActivityModelType, productID: string) {
+    if(!activityData) return false;
+    let createTime = await getRoleCreateTime(roleId);
+    let serverTime = await getServerCreateTime(serverId);
+    let playerData = new GrowthFundData(activityData, createTime, serverTime);
+    let pageData = playerData.findPageByProductID(productID);
+    let pageIndex = pageData.pageIndex;
+    let checkResult = await ActivityBuyRecordsModel.checkRecord(activityData.activityId, roleId, activityData.type, pageIndex);
+    return !checkResult;
 }

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

@@ -125,9 +125,9 @@ export async function makeLimitPackageReward(roleId: string, roleName: string, s
     if (!item) {
         return STATUS.ACTIVITY_NO_PRODUCT;
     }
-    // if (item.countMax > 0 && item.buyCount >= item.countMax) {
+    if (item.countMax > 0 && item.buyCount >= item.countMax) {
-    //     return STATUS.ACTIVITY_MAX_COUNT;
+        return STATUS.ACTIVITY_MAX_COUNT;
-    // }
+    }
 
     let rewardArray = stringToRewardParam(item.reward)
     let result = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.BUY_LIMIT_PACKAGE);

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

@@ -79,7 +79,11 @@ export async function makeMonthlyFund(roleId: string, roleName: string, sid: str
     let createTime = await getRoleCreateTime(roleId);
     let serverTime = await getServerCreateTime(serverId);
     let playerData = new MonthlyFundData(activityData, createTime, serverTime);
+    let playerRecords = await ActivityMonthlyFundModel.findData(serverId, activityData.activityId, playerData.roundIndex, roleId);
+    playerData.setPlayerRecords(playerRecords);
     let page = playerData.findByProductID(productID);
+    if(page.hasBought) return STATUS.ORDER_CANNOT_BUY;
+
     await ActivityMonthlyFundModel.buy(serverId, activityId, roleId, playerData.roundIndex, page.pageIndex, productID);
 
     let rewardParamArr = stringToRewardParam(page.onceReward);

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

@@ -121,12 +121,15 @@ export async function makeMonthlyTicketReward(roleId: string, roleName: string,
         return STATUS.ACTIVITY_TYPE_ERROR;
     }
 
+    if(!await checkMonthlyTicket(roleId, serverId, activityData)) return STATUS.ORDER_CANNOT_BUY;
+
     let createTime = await getRoleCreateTime(roleId);
     let serverTime = await getServerCreateTime(serverId);
     let playerData = new MonthlyTicketData(activityData, createTime, serverTime);
 
     let endTime = playerData.isForever? moment(playerData.endTime).toDate(): moment(new Date()).startOf('d').add(playerData.days, 'day').add(REFRESH_TIME, 'h').toDate();
     console.log('endTime', playerData.isForever, moment(new Date()).startOf('d'), endTime, playerData.days)
+    
     await ActivityMonthlyTicketModel.buyMonthlyTicket(serverId, roleId, activityId, activityData.type, endTime, playerData.isForever)
     if(activityData.type == ACTIVITY_TYPE.MONTHLY_TICKET_2) {
         let role = await RoleModel.buyForeverTicket(roleId);
@@ -141,7 +144,13 @@ export async function makeMonthlyTicketReward(roleId: string, roleName: string,
     }
 }
 
-// 月卡权限
+// 是否可以购买月卡
+export async function checkMonthlyTicket(roleId: string, serverId: number, activityData: ActivityModelType) {
+    if(!activityData) return false;
+
+    let result = await ActivityMonthlyTicketModel.checkHasBought(serverId, roleId, activityData.activityId, activityData.type);
+    return !result;
+}
 
 // 军团捐献消耗
 export function getVipDonateConsume(originConsume: RewardInter, vipStartTime: number) {

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

@@ -168,6 +168,7 @@ export async function makePopUpShopReward(roleId: string, roleName: string, sid:
         return STATUS.APPLY_ORDER_ERROR;
     }
     let item = playerData.updateRecord(playerRecord, productID);
+    if(!item) return STATUS.NO_PRODUCT_ID
 
     let rewardParamArr: Array<RewardParam> = stringToRewardParam(item.reward);
     let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.POP_UP_BUY_GIFT)

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

@@ -153,3 +153,22 @@ export async function makeRefreshShopReward(roleId: string, roleName: string, si
         data: Object.assign(result, { item: item, activityId: activityId })
     }
 }
+
+export async function checkRefreshShop(roleId: string, serverId: number, activityData: ActivityModelType, productID: string, roundIndex: number) {
+    if (!activityData) return false;
+    if (activityData.type !== ACTIVITY_TYPE.REFRESH_SHOP) return false;
+    let createTime = await getRoleCreateTime(roleId);
+    let serverTime = await getServerCreateTime(serverId);
+    let playerData = new RefreshShopData(activityData, createTime, serverTime);
+
+    if(!roundIndex) {
+        roundIndex = playerData.roundIndex;
+    }
+    let playerRecord: ActivityRefreshShopModelType = await ActivityRefreshShopModel.findData(activityData.activityId, roleId, roundIndex);
+    playerData.setPlayerRecords(playerRecord);
+
+    let item = playerData.findItemByProductID(productID);
+    if (!item) return false;
+    if (item.countMax > 0 && item.buyCount >= item.countMax) return false;
+    return true;
+}

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

@@ -124,25 +124,19 @@ export async function makeSelfServerShop(roleId: string, roleName: string, sid:
 
     let activityData: ActivityModelType = await getActivityById(activityId);
     if (!activityData) {
-        return {
+        return STATUS.ACTIVITY_MISSING
-            code: STATUS.ACTIVITY_MISSING,
-        }
     }
     let createTime = await getRoleCreateTime(roleId);
     let serverTime = await getServerCreateTime(serverId);
     let playerData = new SelfServiceShopData(activityData, createTime, serverTime);
     let item: SelfServiceShopItem = playerData.getItemByProductID(productID);
     if (!item) {
-        return {
+        return STATUS.ACTIVITY_DATA_ERROR
-            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 {
+            return STATUS.ACTIVITY_MAX_COUNT
-                code: STATUS.ACTIVITY_MAX_COUNT,
-            }
         }
     }
     let result = await addSelfServiceShopGiftReward(roleId, roleName, sid, serverId, activityId, playerData.roundIndex, item.index, item);
@@ -152,3 +146,18 @@ export async function makeSelfServerShop(roleId: string, roleName: string, sid:
         data: Object.assign(result, { item })
     }
 }
+
+export async function checkSelfServiceShop(roleId: string, serverId: number, activityData: ActivityModelType, productID: string) {
+    if(!activityData) return false;
+
+    let createTime = await getRoleCreateTime(roleId);
+    let serverTime = await getServerCreateTime(serverId);
+    let playerData = new SelfServiceShopData(activityData, createTime, serverTime);
+    let item: SelfServiceShopItem = playerData.getItemByProductID(productID);
+    if (!item) return false
+    if (item.countMax > 0) {//限制购买次数
+        let playerRecords = await ActivitySelfServiceShopModel.findDataByIndex(serverId, activityData.activityId, roleId, playerData.roundIndex, item.index);
+        if (playerRecords.length >= item.countMax) return false;
+    }
+    return true;
+}

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

@@ -101,10 +101,10 @@ export async function makeSignInVIP(roleId: string, roleName: string, sid: strin
     if (activityData.type !== ACTIVITY_TYPE.SIGN_IN_VIP && activityData.type !== ACTIVITY_TYPE.COMMON_SIGN_IN) {
         return STATUS.ACTIVITY_TYPE_ERROR;
     }
-    let createTime = await getRoleCreateTime(roleId);
+    let playerData = await getPlayerSignInData(activityId, serverId, roleId);
-    let serverTime = await getServerCreateTime(serverId);
+    if (!playerData || playerData.isVip) {
-    let playerData = new SignInData(activityData, createTime, serverTime);
+        return STATUS.ORDER_CANNOT_BUY;
-
+    }
     await ActivitySignInModel.buyVIP(activityId, roleId, playerData.roundIndex);
 
     return {

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

@@ -49,6 +49,9 @@ export async function getTaskPassDataShow(activityId: number, serverId: number,
     let serverTime = await getServerCreateTime(serverId);
     let playerData = new TaskPassData(activityData, createTime, serverTime);
     let roundIndex = playerData.roundIndex;
+    let checkResult = await ActivityTaskPassModel.check(serverId, activityData.activityId, roleId, roundIndex, productID);
+    if(checkResult) return STATUS.ORDER_CANNOT_BUY;
+
     await ActivityTaskPassModel.buy(serverId, activityId, roleId, roundIndex, productID);
     return {
         code: 0,
@@ -56,6 +59,17 @@ export async function getTaskPassDataShow(activityId: number, serverId: number,
     }
 }
 
+export async function checkTaskPass(roleId: string, serverId: number, activityData: ActivityModelType, productID: string) {
+    if(!activityData) return false;
+    let createTime = await getRoleCreateTime(roleId);
+    let serverTime = await getServerCreateTime(serverId);
+    let playerData = new TaskPassData(activityData, createTime, serverTime);
+    let roundIndex = playerData.roundIndex;
+    
+    let checkResult = await ActivityTaskPassModel.check(serverId, activityData.activityId, roleId, roundIndex, productID);
+    return !checkResult;
+}
+
 /**
    * 任务活动完成后会获得点数
    *

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

@@ -10,6 +10,7 @@ import { getActivitiesByType, getActivityById, getActivityByServerId } from './a
 import { getRoleCreateTime, getServerCreateTime } from '../redisService';
 import { handleCost } from '../role/rewardService';
 import { ActivityTreasureHuntChallengeModel } from '../../db/ActivityTreasureHuntChallenge';
+import { ActivityModelType } from '../../db/Activity';
 
 export async function getPlayerTreasureHuntDataShow(activityId: number, serverId: number, roleId: string) {
     let playerData = await getPlayerTreasureHuntData(activityId, serverId, roleId);
@@ -121,6 +122,22 @@ export async function makeShop(roleId: string, roleName: string, sid: string, se
     }
 }
 
+export async function checkTreasureHuntShop(roleId: string, serverId: number, activityData: ActivityModelType, productID: string) {
+    if(!activityData) return false;
+    let createTime = await getRoleCreateTime(roleId);
+    let serverTime = await getServerCreateTime(serverId);
+    let playerData = new TreasureHuntData(activityData, createTime, serverTime);
+
+    let playerShopRecord = await ActivityTreasureHuntShopModel.findTreasureData(activityData.activityId, roleId, playerData.roundIndex, playerData.todayIndex);
+    playerData.shop.setPlayerShopRecords(playerShopRecord);
+
+    let item = playerData.shop.findProductID(productID)
+
+    if (!item) return false;
+    if (item.buyCount >= item.countMax) return false;
+    return true;
+}
+
 export async function treasureHuntChallengeConsume(serverId: number, roleId: string, sid: string) {
     let activities = await getActivitiesByType(serverId, ACTIVITY_TYPE.TREASURE_HUNT);
     for(let { activityId } of activities) {

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

@@ -34,6 +34,7 @@ export async function getWeeklyFundData(activityId: number, serverId: number, ro
    */
 export async function getWeeklyFundDataShow(activityId: number, serverId: number, roleId: string) {
     let playerData = await getWeeklyFundData(activityId, serverId, roleId);
+    console.log('##### weeklyFund', playerData)
     if(playerData && playerData.canShow && playerData.canShow()) {
         return playerData.getShowResult();
     }
@@ -75,6 +76,11 @@ export async function makeWeeklyFund(roleId: string, roleName: string, sid: stri
     let createTime = await getRoleCreateTime(roleId);
     let serverTime = await getServerCreateTime(serverId);
     let playerData = new WeeklyFundData(activityData, createTime, serverTime);
+    let playerRecord = await ActivityWeeklyFundModel.findData(serverId, activityData.activityId, roleId);
+    if(playerRecord) {
+        return STATUS.ORDER_CANNOT_BUY;
+    }
+
     await ActivityWeeklyFundModel.buy(serverId, activityId, roleId, productID);
 
     let rewardParamArr = stringToRewardParam(playerData.onceReward);

game-server/app/services/orderService.ts

@@ -3,16 +3,16 @@ import { ACTIVITY_TYPE, DEBUG_PRICE, MAIL_TYPE, ORDER_STATE, PAY_TYPE, PUSH_ROUT
 import { dicRMB } from '../pubUtils/dictionary/DicRMB';
 import { makeYuanbaoShopReward } from './activity/yuanbaoService';
 import { RoleModel } from '../db/Role';
-import { makeMonthlyTicketReward } from './activity/monthlyTicketService';
+import { checkMonthlyTicket, makeMonthlyTicketReward } from './activity/monthlyTicketService';
 import { checkSignInCanBuy, makeSignInVIP } from './activity/signInService';
-import { makeDailyRMBGiftsReward } from './activity/dailyRMBGiftsService';
+import { checkDailyRMBGifts, makeDailyRMBGiftsReward } from './activity/dailyRMBGiftsService';
 import { checkPopUpShopCanBuy, makePopUpShopReward } from './activity/popUpShopService';
 import { ActivityModel, ActivityModelType } from '../db/Activity';
-import { makeGrowthFund } from './activity/growthFundService';
+import { checkGrowthFund, makeGrowthFund } from './activity/growthFundService';
 import { checkLimitPackageCanBuy, makeLimitPackageReward } from './activity/limitPackageService';
-import { makeShop } from './activity/treasureHuntService';
+import { checkTreasureHuntShop, makeShop } from './activity/treasureHuntService';
-import { makeSelfServerShop } from './activity/selfServiceShopActivityService';
+import { checkSelfServiceShop, makeSelfServerShop } from './activity/selfServiceShopActivityService';
-import { makeRefreshShopReward } from './activity/refreshShopService';
+import { checkRefreshShop, makeRefreshShopReward } from './activity/refreshShopService';
 import { ActivityMonopolyModel, ActivityMonopolyModelType } from '../db/ActivityMonopoly';
 import { ActivityMonopolyLandModel, ActivityMonopolyLandModelType } from '../db/ActivityMonopolyLand';
 import { parseGoodStr, resResult } from '../pubUtils/util';
@@ -26,7 +26,7 @@ import { PayCallback37Data } from '../domain/sdk';
 import { reportTAEvent, reportTAUserSet } from './sdkService';
 import { savePayLog } from '../pubUtils/logUtil';
 import { recordFirstGift } from './activity/firstGiftService';
-import { makeTaskPass } from './activity/taskPassService';
+import { checkTaskPass, makeTaskPass } from './activity/taskPassService';
 import { addGuildPay } from './activity/guildPayService';
 import { sendMessageToUserWithSuc } from './pushService';
 import { checkParamPrice, needRebate } from '../pubUtils/sdkUtil';
@@ -69,6 +69,48 @@ export async function checkOrderCanBuy(roleId: string, serverId: number, activit
             {
                 return await checkMonthlyFund(roleId, serverId, activityData, productID);
             }
+        case ACTIVITY_TYPE.DAILY_RMB_GIFTS:
+            {
+                return await checkDailyRMBGifts(roleId, serverId, activityData, productID);
+            }
+        case ACTIVITY_TYPE.MONTHLY_TICKET_1:
+        case ACTIVITY_TYPE.MONTHLY_TICKET_2:
+            {
+                return await checkMonthlyTicket(roleId, serverId, activityData);
+            }
+        case ACTIVITY_TYPE.GROWTH_FUND_MAIN_VIP: //主线成长基金（高阶）
+        case ACTIVITY_TYPE.GROWTH_FUND_TOWER_VIP://镇念塔成长基金（高阶）
+        case ACTIVITY_TYPE.GROWTH_FUND_MAIN_ELITE_VIP://精英成长基金（高阶）
+            {
+                return await checkGrowthFund(roleId, serverId, activityData, productID);
+            }
+        case ACTIVITY_TYPE.SELF_SERVICE_SHOP:
+            {
+                return await checkSelfServiceShop(roleId, serverId, activityData, productID);
+            }
+        case ACTIVITY_TYPE.TASK_PASS:
+            {
+                return await checkTaskPass(roleId, serverId, activityData, productID);
+            }
+        case ACTIVITY_TYPE.REFRESH_SHOP://通用的刷新商店（分页，可刷新，限制购买次数，支持rmb与资源兑换）
+            {
+                if (paramStr) {//大富翁商店结算
+                    let paramObj = JSON.parse(paramStr);
+                    let activityId = paramObj.activityId;//大富翁活动id；   orderInfo.activityId是大富翁中的商店活动id
+                    if (activityId) {
+                        let playerMonopolyData: ActivityMonopolyModelType = await ActivityMonopolyModel.findData(serverId, activityId, roleId);
+                        let playerLandData: ActivityMonopolyLandModelType = await ActivityMonopolyLandModel.findDataByPosition(serverId, activityId, roleId, playerMonopolyData.curPosition);
+                        let roundIndex = playerLandData.stopCount;
+                        return await checkRefreshShop(roleId, serverId, activityData, productID, roundIndex);
+                    }
+                }
+                //正常商店结算
+                return await checkRefreshShop(roleId, serverId, activityData, productID, 0);
+            }
+        case ACTIVITY_TYPE.TREASURE_HUNT://寻宝奇兵活动-每日物资商店
+            {
+                return await checkTreasureHuntShop(roleId, serverId, activityData, productID);
+            }
     }
     return true
 }

game-server/app/services/shopService.ts

@@ -203,11 +203,17 @@ export async function checkShopItemCanBuy(activityId: number, shopItemId: number
     if (activityData.type !== ACTIVITY_TYPE.SHOP) {
         return STATUS.ACTIVITY_TYPE_ERROR;
     }
-    let createTime = await getRoleCreateTime(roleId);
+    let role = await RoleModel.findByRoleId(roleId, 'guildCode createTime vipStartTime');
+    let { createTime, guildCode, vipStartTime } = role;
     let serverTime = await getServerCreateTime(serverId);
     let shopData = new ShopData(activityData, createTime, serverTime);
     let dicItem = shopData.findByProductID(productID);
     if(!dicItem) return STATUS.DIC_DATA_NOT_FOUND;
+
+    let userShop = await UserShopModel.findByRoleAndItem(roleId, dicItem, seasonNum);
+    let result = await checkShopItemCanBuy(activityId, dicItem.id, roleId, serverId, guildCode, vipStartTime, 1, userShop?.count||0, dicItem);
+    if(result.code != STATUS.SUCCESS.code) return result;
+
     let reward = [{
         id: dicItem.goodId,
         count: 1

shared/db/ActivityBuyRecords.ts

@@ -40,6 +40,10 @@ export default class Activity_Buy_Records extends BaseModel {
     public static async deleteActivity(activityId: number, roleId: string, pageIndex: number, cellIndex: number) {
         await ActivityBuyRecordsModel.deleteMany({ roleId, activityId, pageIndex, cellIndex });
     }
+
+    public static async checkRecord(activityId: number, roleId: string, type: number, pageIndex: number) {
+        return await ActivityBuyRecordsModel.exists({ roleId, activityId, type, pageIndex });
+    }
 }
 
 export const ActivityBuyRecordsModel = getModelForClass(Activity_Buy_Records);

shared/db/ActivityDailyRMBGifts.ts

@@ -73,6 +73,16 @@ export default class Activity_Daily_RMB_Gifts extends BaseModel {
         return result;
     }
 
+
+    // 检查是否购买过
+    public static async checkHasBought(serverId: number, activityId: number, roleId: string, beginTime: Date, todayIndex: number) {
+        return await ActivityDailyRMBGiftsModel.exists({ serverId, roleId, activityId, beginTime, todayIndex });
+    }
+
+    public static async checkHasReceive(serverId: number, activityId: number, roleId: string, beginTime: Date, todayIndex: number, id: number) {
+        return await ActivityDailyRMBGiftsModel.exists({ serverId, roleId, activityId, beginTime, todayIndex, 'records.id': id });
+    }
+
     //删除活动领取记录
     public static async deleteActivity(serverId: number, activityId: number, roleId: string) {
         await ActivityDailyRMBGiftsModel.deleteMany({ serverId, roleId, activityId });

shared/db/ActivityMonthlyTicket.ts

@@ -41,6 +41,10 @@ export default class Activity_Monthly_Ticket extends BaseModel {
     public static async buyMonthlyTicket(serverId: number, roleId: string, activityId: number, activityType: number, endTime: Date, isForever: boolean) {
         await ActivityMonthlyTicketModel.findOneAndUpdate({ serverId, roleId, activityId, activityType }, { $set: { endTime, dayIndex: 0, isForever } }, { upsert: true, new: true }).lean();
     }
+
+    public static async checkHasBought(serverId: number, roleId: string, activityId: number, activityType: number,) {
+        return await ActivityMonthlyTicketModel.exists({ serverId, roleId, activityId, activityType, endTime: { $gt: new Date() } });
+    }
 }
 
 export const ActivityMonthlyTicketModel = getModelForClass(Activity_Monthly_Ticket);

shared/db/ActivityTaskPass.ts

@@ -62,6 +62,11 @@ export default class Activity_Task_Pass extends BaseModel {
         return result;
     }
 
+    // 是否买过
+    public static async check(serverId: number, activityId: number, roleId: string, roundIndex: number, productID: string) {
+        return await ActivityTaskPassModel.exists({ serverId, roleId, activityId, roundIndex, productIDs: productID });
+    }
+
     public static async receiveItems(serverId: number, activityId: number, roleId: string, roundIndex: number, receivedReward: ReceivedReward[]) {
         // console.log(receivedReward)
         let result: ActivityTaskPassModelType = await ActivityTaskPassModel.findOneAndUpdate({ serverId, roleId, activityId, roundIndex},