@chevre/domain 27.1.0-alpha.1 → 27.1.0-alpha.3

package/lib/chevre/repo/adminEvent.js

@@ -0,0 +1,388 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdminEventRepo = void 0;
+const mongoose_1 = require("mongoose");
+const errorHandler_1 = require("../errorHandler");
+const factory_1 = require("../factory");
+const EventFactory = __importStar(require("../factory/event"));
+const event_1 = require("./mongoose/schemas/event");
+// export type ICreatingEvent4ttts = Pick<
+//     factory.event.screeningEvent.IAttributes,
+//     'additionalProperty' | 'doorTime' | 'endDate' | 'eventStatus'
+//     | 'location' | 'name' | 'offers' | 'organizer' | 'project' | 'startDate' | 'superEvent' | 'typeOf'
+// > & {
+//     identifier: string;
+// };
+/**
+ * イベント管理リポジトリ
+ */
+class AdminEventRepo {
+    eventModel;
+    constructor(connection) {
+        this.eventModel = connection.model(event_1.modelName, (0, event_1.createSchema)());
+    }
+    /**
+     * イベントIDを生成する
+     */
+    static CREATE_ID() {
+        // implement using ObjectId(2025-10-17~)
+        // return (USE_OBJECT_ID_AS_EVENT_ID) ? new Types.ObjectId().toHexString() : uniqid();
+        return new mongoose_1.Types.ObjectId().toHexString(); // 設定を廃止(2025-11-20~)
+    }
+    /**
+     * イベントコードをキーにして冪等置換
+     */
+    async upsertManyScreeningEventByIdentifier(params, options) {
+        const { update } = options;
+        const bulkWriteOps = [];
+        const queryFilters = [];
+        if (Array.isArray(params)) {
+            params.forEach(({ $set, $unset }) => {
+                const { project, identifier } = $set;
+                if (typeof identifier !== 'string' || identifier.length === 0) {
+                    throw new factory_1.factory.errors.ArgumentNull('identifier');
+                }
+                // リソースのユニークネスを保証するfilter
+                const filter = {
+                    'project.id': { $eq: project.id },
+                    identifier: { $exists: true, $eq: identifier }
+                };
+                queryFilters.push({
+                    'project.id': { $eq: project.id },
+                    identifier: { $exists: true, $eq: identifier }
+                });
+                if (update === true) {
+                    const { maximumPhysicalAttendeeCapacity, additionalProperty, eventStatus, location, name, superEvent, offers, doorTime, endDate, startDate } = $set;
+                    const setFields = {
+                        maximumPhysicalAttendeeCapacity, additionalProperty,
+                        eventStatus, location, name, superEvent, offers,
+                        doorTime, endDate, startDate
+                    };
+                    const updateOne = {
+                        filter,
+                        update: {
+                            $set: setFields,
+                            ...($unset !== undefined) ? { $unset } : undefined
+                        },
+                        upsert: false
+                    };
+                    bulkWriteOps.push({ updateOne });
+                }
+                else {
+                    const { id, coaInfo, description, // eslint-disable-line @typescript-eslint/no-unused-vars
+                    maximumAttendeeCapacity, remainingAttendeeCapacity, checkInCount, attendeeCount, aggregateReservation, // eslint-disable-line @typescript-eslint/no-unused-vars
+                    ...setOnInsertFields } = $set;
+                    const setOnInsert = {
+                        ...setOnInsertFields,
+                        identifier,
+                        _id: AdminEventRepo.CREATE_ID()
+                    };
+                    const updateOne = {
+                        filter,
+                        update: {
+                            $setOnInsert: setOnInsert
+                        },
+                        upsert: true
+                    };
+                    bulkWriteOps.push({ updateOne });
+                }
+            });
+        }
+        if (bulkWriteOps.length > 0) {
+            const bulkWriteResult = await this.eventModel.bulkWrite(bulkWriteOps, { ordered: false });
+            // update:falseの場合、upsertedIdsのみmodifiedEventsとして返せばよい(2026-01-16~)
+            if (!update) {
+                // BulkWriteResult -> upsertedIds: { '0': '7iri6p4m54k0r3g' }
+                return {
+                    bulkWriteResult,
+                    modifiedEvents: Object.values(bulkWriteResult.upsertedIds)
+                        .map((id) => ({ id: String(id) }))
+                };
+            }
+            else {
+                // modifiedの場合upsertedIdsに含まれないので、idを検索する
+                const modifiedEvents = await this.eventModel.find({ $or: queryFilters }, {
+                    _id: 0,
+                    id: { $toString: '$_id' }
+                })
+                    .lean()
+                    .exec();
+                return { bulkWriteResult, modifiedEvents };
+            }
+        }
+        return { modifiedEvents: [] };
+    }
+    /**
+     * イベント部分更新
+     */
+    async updatePartiallyById(params) {
+        // let doc: Document | null;
+        const { typeOf, ...updateFields } = params.attributes;
+        if (typeof typeOf !== 'string' || typeOf.length === 0) {
+            throw new factory_1.factory.errors.ArgumentNull('attributes.typeOf');
+        }
+        const doc = await this.eventModel.findOneAndUpdate({
+            _id: { $eq: params.id },
+            'project.id': { $eq: params.project.id },
+            typeOf: { $eq: typeOf }
+        }, {
+            $set: updateFields
+        }, { upsert: false, new: false, projection: { _id: 1 } })
+            .lean()
+            .exec();
+        if (doc === null) {
+            throw new factory_1.factory.errors.NotFound(this.eventModel.modelName);
+        }
+    }
+    /**
+     * 単一イベント編集
+     */
+    async updateEventById(params) {
+        let doc;
+        const { identifier, project, typeOf, // eslint-disable-line @typescript-eslint/no-unused-vars
+        organizer, aggregateReservation, maximumAttendeeCapacity, remainingAttendeeCapacity, checkInCount, attendeeCount, // eslint-disable-line @typescript-eslint/no-unused-vars
+        coaInfo, // eslint-disable-line @typescript-eslint/no-unused-vars
+        ...updateFields
+        // maximumPhysicalAttendeeCapacity, additionalProperty,
+        // eventStatus, location, name, superEvent, offers,
+        // doorTime, endDate, startDate
+         } = params.attributes;
+        if (typeof typeOf !== 'string' || typeOf.length === 0) {
+            throw new factory_1.factory.errors.ArgumentNull('attributes.typeOf');
+        }
+        if (typeof params.id !== 'string' || params.id === '') {
+            throw new factory_1.factory.errors.ArgumentNull('id');
+        }
+        try {
+            doc = await this.eventModel.findOneAndUpdate({
+                _id: { $eq: params.id },
+                typeOf: { $eq: typeOf }
+            }, {
+                // 編集のためのみのメソッドになったので、setOnInsertは廃止(2025-10-27~)
+                // 上書き禁止属性を除外(2022-08-24~)
+                // $setOnInsert: {
+                //     typeOf,
+                //     project,
+                //     ...(typeof identifier === 'string' && identifier !== '') ? { identifier } : undefined
+                // },
+                $set: updateFields,
+                ...(params.$unset !== undefined) ? { $unset: params.$unset } : undefined
+            }, {
+                upsert: false,
+                new: true,
+                projection: { _id: 1 }
+            })
+                .lean()
+                .exec();
+        }
+        catch (error) {
+            if (await (0, errorHandler_1.isMongoDuplicateError)(error)) {
+                throw new factory_1.factory.errors.AlreadyInUse(factory_1.factory.eventType.ScreeningEvent, ['offeredBy.member.identifier']);
+            }
+            throw error;
+        }
+        if (doc === null) {
+            throw new factory_1.factory.errors.NotFound(this.eventModel.modelName);
+        }
+    }
+    /**
+     * sskts専用
+     */
+    async saveManyEvents(params) {
+        const bulkWriteOps = []; // eslint-disable-line @typescript-eslint/no-explicit-any
+        if (Array.isArray(params)) {
+            params.forEach((p) => {
+                const upsert = p.upsert === true;
+                if (p.attributes.typeOf === factory_1.factory.eventType.ScreeningEvent) {
+                    // 上書き禁止属性を除外(2022-08-24~)
+                    const { identifier, project, typeOf, remainingAttendeeCapacity, ...updateFields } = p.attributes; // eslint-disable-line @typescript-eslint/no-unused-vars
+                    bulkWriteOps.push({
+                        updateOne: {
+                            filter: {
+                                _id: p.id,
+                                typeOf: p.attributes.typeOf
+                            },
+                            update: {
+                                $setOnInsert: {
+                                    typeOf: p.attributes.typeOf,
+                                    project: p.attributes.project,
+                                    ...(typeof p.attributes.identifier === 'string')
+                                        ? { identifier: p.attributes.identifier } : undefined,
+                                    ...(typeof p.attributes.remainingAttendeeCapacity === 'number')
+                                        ? { remainingAttendeeCapacity: p.attributes.remainingAttendeeCapacity }
+                                        : undefined
+                                },
+                                $set: updateFields,
+                                // $unsetに対応(2022-08-31~)
+                                ...(p.$unset !== undefined) ? { $unset: p.$unset } : undefined
+                            },
+                            upsert
+                        }
+                    });
+                }
+                else if (p.attributes.typeOf === factory_1.factory.eventType.ScreeningEventSeries) {
+                    throw new factory_1.factory.errors.Internal('typeOf: ScreeningEventSeries discontinued');
+                }
+            });
+        }
+        if (bulkWriteOps.length > 0) {
+            await this.eventModel.bulkWrite(bulkWriteOps, { ordered: false });
+        }
+    }
+    /**
+     * イベントをキャンセルする
+     */
+    async cancelEvent(params) {
+        return this.eventModel.updateOne({
+            _id: { $eq: params.id },
+            'project.id': { $eq: params.project.id }
+        }, { $set: { eventStatus: factory_1.factory.eventStatusType.EventCancelled } }, {
+        // includeResultMetadata: true
+        })
+            .exec();
+    }
+    /**
+     * 興行イベントのsuperEventを最新の情報に同期する
+     */
+    async syncScreeningEventSeries2screeningEvents(params) {
+        const superEvent = EventFactory.minimizeSuperEvent({ superEventFromDB: params.superEventFromDB });
+        await this.eventModel.updateMany({
+            typeOf: { $eq: factory_1.factory.eventType.ScreeningEvent },
+            'project.id': { $eq: params.project.id },
+            'superEvent.id': { $exists: true, $eq: params.superEventFromDB.id },
+            startDate: { $gte: params.startDate.$gte }
+        }, {
+            $set: {
+                superEvent
+            }
+        })
+            .exec();
+    }
+    async deleteEventById(params) {
+        await this.eventModel.findOneAndDelete({
+            _id: params.id,
+            'project.id': { $eq: params.project.id }
+        })
+            .exec();
+    }
+    async deleteManyEventByOrganizerId(params) {
+        return this.eventModel.deleteMany({
+            'project.id': { $eq: params.project.id },
+            'organizer.id': { $exists: true, $eq: params.organizer.id }
+        })
+            .exec();
+    }
+    async deleteManyEventsByScreeningRoom(params) {
+        return this.eventModel.deleteMany({
+            'project.id': { $eq: params.project.id },
+            'location.branchCode': { $exists: true, $eq: params.location.branchCode },
+            'superEvent.location.id': { $exists: true, $eq: params.location.containedInPlace.id }
+        })
+            .exec();
+    }
+    async deleteManyBySuperEventId(params) {
+        return this.eventModel.deleteMany({
+            'project.id': { $eq: params.project.id },
+            'superEvent.id': { $exists: true, $eq: params.superEvent.id }
+        })
+            .exec();
+    }
+    async deleteManyBySuperEventLocationId(params) {
+        return this.eventModel.deleteMany({
+            'project.id': { $eq: params.project.id },
+            'superEvent.location.id': { $exists: true, $eq: params.superEvent.location.id }
+        })
+            .exec();
+    }
+    /**
+     * 興行(プロダクト)から削除する
+     */
+    async deleteManyEventsByItemOfferedId(params) {
+        return this.eventModel.deleteMany({
+            'project.id': { $eq: params.project.id },
+            'offers.itemOffered.id': { $exists: true, $in: params.offers.itemOffered.id.$in }
+        })
+            .exec();
+    }
+    async deleteManyEventsEndedByProject(params) {
+        return this.eventModel.deleteMany({
+            typeOf: { $in: params.typeOf.$in },
+            'project.id': { $eq: params.project.id },
+            endDate: { $lte: params.endDate.$lte }
+        })
+            .exec();
+    }
+    async deleteManyEventsEnded(params) {
+        return this.eventModel.deleteMany({
+            typeOf: { $eq: params.typeOf.$eq },
+            endDate: { $lte: params.endDate.$lte }
+        })
+            .exec();
+    }
+    async deleteByProject(params) {
+        await this.eventModel.deleteMany({
+            'project.id': { $eq: params.project.id }
+        })
+            .exec();
+    }
+    /**
+     * 集計属性を更新する
+     */
+    async updateAggregationById(params, update) {
+        const doc = await this.eventModel.findOneAndUpdate({ _id: { $eq: params.id } }, update, {
+            new: false,
+            projection: { _id: 1 }
+        })
+            .lean()
+            .exec();
+        if (doc === null) {
+            throw new factory_1.factory.errors.NotFound(this.eventModel.modelName);
+        }
+    }
+    async bulkWrite(bulkWriteOps) {
+        return this.eventModel.bulkWrite(bulkWriteOps, { ordered: false });
+    }
+    getCursor(conditions, projection) {
+        return this.eventModel.find(conditions, projection)
+            .sort({ startDate: factory_1.factory.sortType.Descending })
+            .cursor();
+    }
+    async unsetUnnecessaryFields(params) {
+        return this.eventModel.updateMany(params.filter, { $unset: params.$unset }, { timestamps: false })
+            .exec();
+    }
+}
+exports.AdminEventRepo = AdminEventRepo;

package/lib/chevre/repo/aggregateEvent.d.ts

@@ -0,0 +1,42 @@
+import type { Connection } from 'mongoose';
+import { factory } from '../factory';
+interface IAggregationByStatus {
+    eventCount: number;
+    reservationCount: number;
+    avgOfferCount: number;
+    maximumAttendeeCapacity: number;
+    remainingAttendeeCapacity: number;
+    avgRemainingCapacityRate: number;
+    maxRemainingCapacityRate: number;
+    minRemainingCapacityRate: number;
+    percentilesRemainingCapacityRate: {
+        name: string;
+        value: number;
+    }[];
+}
+interface IStatus {
+    status: factory.eventStatusType;
+    aggregation: IAggregationByStatus;
+}
+interface IAggregateEvent {
+    statuses: IStatus[];
+}
+/**
+ * イベント集計リポジトリ
+ */
+export declare class AggregateEventRepo {
+    private readonly eventModel;
+    constructor(connection: Connection);
+    aggregateEvent(params: {
+        project?: {
+            id?: {
+                $ne?: string;
+            };
+        };
+        startFrom: Date;
+        startThrough: Date;
+        typeOf: factory.eventType.ScreeningEvent;
+    }): Promise<IAggregateEvent>;
+    private agggregateByStatus;
+}
+export {};

package/lib/chevre/repo/aggregateEvent.js

@@ -0,0 +1,221 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AggregateEventRepo = void 0;
+const factory_1 = require("../factory");
+const event_1 = require("./mongoose/schemas/event");
+/**
+ * イベント集計リポジトリ
+ */
+class AggregateEventRepo {
+    eventModel;
+    constructor(connection) {
+        this.eventModel = connection.model(event_1.modelName, (0, event_1.createSchema)());
+    }
+    async aggregateEvent(params) {
+        const statuses = await Promise.all([
+            factory_1.factory.eventStatusType.EventScheduled,
+            factory_1.factory.eventStatusType.EventCancelled,
+            factory_1.factory.eventStatusType.EventPostponed
+        ].map(async (eventStatus) => {
+            const matchConditions = {
+                startDate: {
+                    $gte: params.startFrom,
+                    $lte: params.startThrough
+                },
+                typeOf: { $eq: params.typeOf },
+                eventStatus: { $eq: eventStatus },
+                ...(typeof params.project?.id?.$ne === 'string')
+                    ? { 'project.id': { $ne: params.project.id.$ne } }
+                    : undefined
+            };
+            return this.agggregateByStatus({ matchConditions, status: eventStatus });
+        }));
+        return { statuses };
+    }
+    async agggregateByStatus(params) {
+        const matchConditions = params.matchConditions;
+        const eventStatus = params.status;
+        const aggregations = await this.eventModel.aggregate([
+            {
+                $match: matchConditions
+            },
+            {
+                $project: {
+                    remainingCapacityRate: {
+                        $cond: {
+                            if: {
+                                $and: [
+                                    { $isNumber: '$maximumAttendeeCapacity' },
+                                    { $isNumber: '$remainingAttendeeCapacity' }
+                                ]
+                            },
+                            then: {
+                                $cond: {
+                                    if: { $gt: ['$maximumAttendeeCapacity', 0] },
+                                    then: {
+                                        $multiply: [
+                                            { $divide: ['$remainingAttendeeCapacity', '$maximumAttendeeCapacity'] },
+                                            100
+                                        ]
+                                    },
+                                    else: 0
+                                }
+                            },
+                            else: 0
+                        }
+                    },
+                    eventStatus: '$eventStatus',
+                    startDate: '$startDate',
+                    endDate: '$endDate',
+                    typeOf: '$typeOf',
+                    maximumAttendeeCapacity: {
+                        $cond: {
+                            if: { $isNumber: '$maximumAttendeeCapacity' },
+                            then: '$maximumAttendeeCapacity',
+                            else: 0
+                        }
+                    },
+                    remainingAttendeeCapacity: {
+                        $cond: {
+                            if: { $isNumber: '$remainingAttendeeCapacity' },
+                            then: '$remainingAttendeeCapacity',
+                            else: 0
+                        }
+                    },
+                    reservationCount: {
+                        $cond: {
+                            if: { $isNumber: '$aggregateReservation.reservationCount' },
+                            then: '$aggregateReservation.reservationCount',
+                            else: 0
+                        }
+                    },
+                    offerCount: {
+                        $cond: {
+                            if: { $isNumber: '$aggregateOffer.offerCount' },
+                            then: '$aggregateOffer.offerCount',
+                            else: 0
+                        }
+                    }
+                }
+            },
+            {
+                $group: {
+                    _id: '$typeOf',
+                    eventCount: { $sum: 1 },
+                    reservationCount: { $sum: '$reservationCount' },
+                    avgOfferCount: { $avg: '$offerCount' },
+                    maximumAttendeeCapacity: { $sum: '$maximumAttendeeCapacity' },
+                    remainingAttendeeCapacity: { $sum: '$remainingAttendeeCapacity' },
+                    avgRemainingCapacityRate: { $avg: '$remainingCapacityRate' },
+                    maxRemainingCapacityRate: { $max: '$remainingCapacityRate' },
+                    minRemainingCapacityRate: { $min: '$remainingCapacityRate' }
+                }
+            },
+            {
+                $project: {
+                    _id: 0,
+                    eventCount: '$eventCount',
+                    reservationCount: '$reservationCount',
+                    avgOfferCount: '$avgOfferCount',
+                    maximumAttendeeCapacity: '$maximumAttendeeCapacity',
+                    remainingAttendeeCapacity: '$remainingAttendeeCapacity',
+                    avgRemainingCapacityRate: '$avgRemainingCapacityRate',
+                    maxRemainingCapacityRate: '$maxRemainingCapacityRate',
+                    minRemainingCapacityRate: '$minRemainingCapacityRate'
+                }
+            }
+        ])
+            .exec();
+        const percents = [50, 95, 99];
+        if (aggregations.length === 0) {
+            return {
+                status: eventStatus,
+                aggregation: {
+                    eventCount: 0,
+                    reservationCount: 0,
+                    avgOfferCount: 0,
+                    maximumAttendeeCapacity: 0,
+                    remainingAttendeeCapacity: 0,
+                    avgRemainingCapacityRate: 0,
+                    maxRemainingCapacityRate: 0,
+                    minRemainingCapacityRate: 0,
+                    percentilesRemainingCapacityRate: percents.map((percent) => {
+                        return {
+                            name: String(percent),
+                            value: 0
+                        };
+                    })
+                }
+            };
+        }
+        const ranks4percentile = percents.map((percentile) => {
+            return {
+                percentile,
+                rank: Math.floor(aggregations[0].eventCount * percentile / 100)
+            };
+        });
+        const aggregations2 = await this.eventModel.aggregate([
+            {
+                $match: matchConditions
+            },
+            {
+                $project: {
+                    remainingCapacityRate: {
+                        $cond: {
+                            if: {
+                                $and: [
+                                    { $isNumber: '$maximumAttendeeCapacity' },
+                                    { $isNumber: '$remainingAttendeeCapacity' }
+                                ]
+                            },
+                            then: {
+                                $cond: {
+                                    if: { $gt: ['$maximumAttendeeCapacity', 0] },
+                                    then: {
+                                        $multiply: [
+                                            { $divide: ['$remainingAttendeeCapacity', '$maximumAttendeeCapacity'] },
+                                            100
+                                        ]
+                                    },
+                                    else: 0
+                                }
+                            },
+                            else: 0
+                        }
+                    },
+                    eventStatus: '$eventStatus',
+                    startDate: '$startDate',
+                    endDate: '$endDate',
+                    typeOf: '$typeOf'
+                }
+            },
+            { $sort: { remainingCapacityRate: 1 } },
+            {
+                $group: {
+                    _id: '$typeOf',
+                    remainingCapacityRates: { $push: '$remainingCapacityRate' }
+                }
+            },
+            {
+                $project: {
+                    _id: 0,
+                    percentilesRemainingCapacityRate: ranks4percentile.map((rank) => {
+                        return {
+                            name: String(rank.percentile),
+                            value: { $arrayElemAt: ['$remainingCapacityRates', rank.rank] }
+                        };
+                    })
+                }
+            }
+        ])
+            .exec();
+        return {
+            status: eventStatus,
+            aggregation: {
+                ...aggregations[0],
+                ...aggregations2[0]
+            }
+        };
+    }
+}
+exports.AggregateEventRepo = AggregateEventRepo;