✨ feat(活动): 节日活动-火神祭祀

shared/db/ActivityForge.ts

@@ -0,0 +1,65 @@
+import BaseModel from './BaseModel';
+import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
+
+/**
+  * 火神祭祀
+*/
+
+class ForgeRecord {
+    @prop({ required: true })
+    todayIndex: number;
+
+    @prop({ required: true })
+    material: string;
+
+    @prop({ required: true })
+    isSuccess: boolean;
+}
+
+@index({ roleId: 1, activityId: 1 })
+
+export default class Activity_Forge extends BaseModel {
+    @prop({ required: true })
+    serverId: number;				// 服Id
+
+    @prop({ required: true })
+    activityId: number;				// 活动Id
+
+    @prop({ required: true })
+    roundIndex: number;				// 活动Id
+
+    @prop({ required: true })
+    roleId: string;			        // 用户Id
+
+    @prop({ required: true })
+    manualId: number;	            // 图谱id
+
+    @prop({ required: true })
+    buildCnt: number;	            // 铸造次数
+
+    @prop({ required: true })
+    buyCnt: number;	                // 购买次数
+
+    @prop({ required: true, type: ForgeRecord, _id: false })
+    record: ForgeRecord[];           // 铸造记录
+
+    public static async findData(serverId: number, activityId: number, roundIndex: number, roleId: string) {
+        let result: ActivityForgeModelType[] = await ActivityForgeModel.find({ serverId, roleId, activityId, roundIndex }).lean();
+        return result;
+    }
+
+    public static async build(serverId: number, activityId: number, roleId: string, roundIndex: number, manualId: number, record: ForgeRecord) {
+        let result: ActivityForgeModelType = await ActivityForgeModel.findOneAndUpdate({ serverId, roleId, activityId, roundIndex, manualId }, { $inc: { buildCnt: record.isSuccess? 1: 0 }, $push: { record } }, { new: true, upsert: true }).lean();
+        return result;
+    }
+
+    public static async buyCnt(serverId: number, activityId: number, roleId: string, roundIndex: number, manualId: number, count: number) {
+        let result: ActivityForgeModelType = await ActivityForgeModel.findOneAndUpdate({ serverId, roleId, activityId, manualId, roundIndex }, { $inc: { buyCnt: count } }, { new: true, upsert: true }).lean();
+        return result;
+    }
+}
+
+export const ActivityForgeModel = getModelForClass(Activity_Forge);
+
+export interface ActivityForgeModelType extends Pick<DocumentType<Activity_Forge>, keyof Activity_Forge> { }
+export type ActivityForgeModelTypeParam = Partial<ActivityForgeModelType>; // 将所有字段变成可选项

shared/db/ActivityItem.ts

@@ -0,0 +1,85 @@
+import BaseModel from './BaseModel';
+import { index, getModelForClass, prop, DocumentType, modelOptions } from '@typegoose/typegoose';
+import { BAG } from '../pubUtils/dicParam';
+import { nowSeconds } from '../pubUtils/timeUtil';
+
+@index({ roleId: 1, id: 1 })
+@modelOptions({ schemaOptions: { id: false } })
+export default class ActivityItem extends BaseModel {
+    @prop({ required: true, default: '' })
+    roleId: string;					// 角色 id
+    @prop({ required: true, default: '' })
+    roleName: string;				// 角色名称
+
+    @prop({ required: true, default: '' })
+    id: number;				  // 道具 id
+    @prop({ required: true, default: '' })
+    itemName: string;			  // 道具名称
+
+    @prop({ required: true, default: 0 })
+    expireTime: number;			  // 限时
+
+    @prop({ required: true })
+    count: number;			    // 道具数量
+
+
+    public static async findbyRole(roleId: string, select = '') {
+        const items: ActivityItemType[] = await ActivityItemModel.find({ roleId, count: {$gte: 0}, expireTime: { $gte: nowSeconds() } }).select(select).lean();
+        return items;
+    }
+
+    public static async findbyRoleAndIds(roleId: string, ids: Array<number>, lean = true) {
+        const items: ActivityItemType[] = await ActivityItemModel.find({ roleId, id: { $in: ids }, count: {$gte: 0}, expireTime: { $gte: nowSeconds() } }).select('id count expireTime').lean(lean);
+        return items;
+    }
+
+    public static async findbyRoleAndGid(roleId: string, id: number, lean = true) {
+        const items: ActivityItemType = await ActivityItemModel.findOne({ roleId, id }).select('id count expireTime').lean(lean);
+        return items;
+    }
+
+    public static async increaseActivityItem(roleId: string, id: number, count: number, itemInfo: { roleId: string, roleName: string, id: number, itemName: string, expireTime?: number }) {
+        const doc = new ActivityItemModel();
+        const setOnInsert = Object.assign(doc.toJSON(), itemInfo);
+        delete setOnInsert.expireTime;
+        let items: ActivityItemType = await ActivityItemModel.findOneAndUpdate({ roleId, id, expireTime: { $gte: nowSeconds() } }, { $setOnInsert: setOnInsert, $inc: { count }, $set: { expireTime: itemInfo.expireTime } }, { new: true, upsert: true }).lean();
+        if(items.count > BAG.BAG_GOODS_UPLIMITED) {
+            items = await ActivityItemModel.findOneAndUpdate({ roleId, id, count: { $gte: BAG.BAG_GOODS_UPLIMITED }, expireTime: { $gte: nowSeconds() } }, { $set: { count: BAG.BAG_GOODS_UPLIMITED, expireTime: itemInfo.expireTime } }, { new: true }).lean();
+        }
+        return items;
+    }
+
+    public static async decreaseActivityItems(roleId: string, items: Array<{ id: number, count: number }>, lean = true) {
+        let updateActivityItems = new Array<{ id: number, count: number }>(), hasError: boolean = false, result = new Array();
+        for (let { id, count } of items) {
+            let rec: ActivityItemType = await ActivityItemModel.findOneAndUpdate({ roleId, id, count: { $gte: count }, expireTime: { $gte: nowSeconds() } }, { $inc: { count: -1 * count } }, { new: true }).lean(lean);
+            if (!!rec) {
+                let index = result.findIndex(cur => cur.id == rec.id);
+                if (index != -1) {
+                    result[index].count = rec.count;
+                    result[index].inc += -count;
+                } else {
+                    result.push({ id: rec.id, count: rec.count, expireTime: rec.expireTime, inc: -count });
+                }
+                updateActivityItems.push({ id, count });
+            } else {
+                hasError = true; break;
+            }
+        }
+        if (hasError) { // 数量不足
+            for (let { id, count } of updateActivityItems) {
+                await ActivityItemModel.findOneAndUpdate({ roleId, id, expireTime: { $gte: nowSeconds() } }, { $inc: { count: -count } }, { new: true }).lean(lean);
+            }
+            return { hasError: true }
+        } else {
+            return { hasError: false, result }
+        }
+    }
+}
+
+
+export const ActivityItemModel = getModelForClass(ActivityItem);
+
+export interface ActivityItemType extends Pick<DocumentType<ActivityItem>, keyof ActivityItem> {
+    id: number;
+};