@chevre/domain 27.1.0-alpha.2 → 27.1.0-alpha.4

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

@@ -0,0 +1,236 @@
+import { Connection, FilterQuery, mongo } from 'mongoose';
+import { factory } from '../factory';
+export interface IAttributes4patchUpdate {
+    typeOf: factory.eventType.ScreeningEvent;
+    eventStatus?: factory.eventStatusType;
+}
+export interface IUpdateAggregateReservationParams {
+    $set: {
+        aggregateReservation: factory.event.screeningEvent.IAggregateReservation;
+        aggregateOffer?: Pick<factory.event.screeningEvent.IAggregateOffer, 'aggregateDate' | 'offerCount' | 'typeOf'>;
+        maximumAttendeeCapacity?: number;
+        remainingAttendeeCapacity?: number;
+        checkInCount?: number;
+        attendeeCount?: number;
+    };
+    $unset: {
+        noExistingAttributeName: 1;
+        maximumAttendeeCapacity?: '';
+        remainingAttendeeCapacity?: '';
+    };
+}
+type IUnset = {
+    [key in keyof factory.event.screeningEvent.IEvent]?: 1;
+};
+/**
+ * イベント管理リポジトリ
+ */
+export declare class AdminEventRepo {
+    private readonly eventModel;
+    constructor(connection: Connection);
+    /**
+     * イベントIDを生成する
+     */
+    static CREATE_ID(): string;
+    /**
+     * イベントコードをキーにして冪等置換
+     */
+    upsertManyScreeningEventByIdentifier(params: {
+        $set: factory.event.screeningEvent.IAttributes & {
+            id?: never;
+        };
+        $unset: IUnset;
+    }[], options: {
+        /**
+         * falseの場合setOnInsertのみ
+         * trueの場合setのみ
+         */
+        update: boolean;
+    }): Promise<{
+        bulkWriteResult?: mongo.BulkWriteResult;
+        modifiedEvents: {
+            id: string;
+        }[];
+    }>;
+    /**
+     * イベント部分更新
+     */
+    updatePartiallyById(params: {
+        project: {
+            id: string;
+        };
+        id: string;
+        attributes: IAttributes4patchUpdate;
+    }): Promise<void>;
+    /**
+     * 単一イベント編集
+     */
+    updateEventById(params: {
+        id: string;
+        attributes: factory.event.screeningEvent.IAttributes & {
+            id?: never;
+        };
+        /**
+         * ドキュメント作成時には無視される
+         */
+        $unset?: IUnset;
+    }): Promise<void>;
+    /**
+     * sskts専用
+     */
+    saveManyEvents(params: {
+        id: string;
+        attributes: factory.event.screeningEvent.IAttributes;
+        $unset?: IUnset;
+        upsert: boolean;
+    }[]): Promise<void>;
+    /**
+     * イベントをキャンセルする
+     */
+    cancelEvent(params: {
+        project: {
+            id: string;
+        };
+        id: string;
+    }): Promise<import("mongoose").UpdateWriteOpResult>;
+    /**
+     * 興行イベントのsuperEventを最新の情報に同期する
+     */
+    syncScreeningEventSeries2screeningEvents(params: {
+        project: {
+            id: string;
+        };
+        superEventFromDB: Pick<factory.eventSeries.IEvent, 'additionalProperty' | 'alternativeHeadline' | 'description' | 'dubLanguage' | 'endDate' | 'headline' | 'id' | 'kanaName' | 'location' | 'name' | 'soundFormat' | 'startDate' | 'subtitleLanguage' | 'typeOf' | 'workPerformed'>;
+        startDate: {
+            $gte: Date;
+        };
+    }): Promise<void>;
+    deleteEventById(params: {
+        project: {
+            id: string;
+        };
+        id: string;
+    }): Promise<void>;
+    deleteManyEventByOrganizerId(params: {
+        project: {
+            id: string;
+        };
+        organizer: {
+            id: string;
+        };
+    }): Promise<mongo.DeleteResult>;
+    deleteManyEventsByScreeningRoom(params: {
+        project: {
+            id: string;
+        };
+        location: {
+            /**
+             * ルームコード
+             */
+            branchCode: string;
+            containedInPlace: {
+                /**
+                 * 施設ID
+                 */
+                id: string;
+            };
+        };
+    }): Promise<mongo.DeleteResult>;
+    deleteManyBySuperEventId(params: {
+        project: {
+            id: string;
+        };
+        superEvent: {
+            id: string;
+        };
+    }): Promise<mongo.DeleteResult>;
+    deleteManyBySuperEventLocationId(params: {
+        project: {
+            id: string;
+        };
+        superEvent: {
+            location: {
+                id: string;
+            };
+        };
+    }): Promise<mongo.DeleteResult>;
+    /**
+     * 興行(プロダクト)から削除する
+     */
+    deleteManyEventsByItemOfferedId(params: {
+        project: {
+            id: string;
+        };
+        offers: {
+            itemOffered: {
+                id: {
+                    $in: string[];
+                };
+            };
+        };
+    }): Promise<mongo.DeleteResult>;
+    deleteManyEventsEndedByProject(params: {
+        typeOf: {
+            $in: factory.eventType.ScreeningEvent[];
+        };
+        project: {
+            id: string;
+        };
+        endDate: {
+            $lte: Date;
+        };
+    }): Promise<mongo.DeleteResult>;
+    deleteManyEventsEnded(params: {
+        typeOf: {
+            $eq: factory.eventType.ScreeningEvent;
+        };
+        endDate: {
+            $lte: Date;
+        };
+    }): Promise<mongo.DeleteResult>;
+    deleteByProject(params: {
+        project: {
+            id: string;
+        };
+    }): Promise<void>;
+    /**
+     * 集計属性を更新する
+     */
+    updateAggregationById(params: {
+        id: string;
+    }, update: IUpdateAggregateReservationParams): Promise<void>;
+    bulkWrite(bulkWriteOps: any[]): Promise<mongo.BulkWriteResult & {
+        mongoose?: {
+            validationErrors: import("mongoose").Error[];
+        } | undefined;
+    }>;
+    getCursor(conditions: FilterQuery<any>, projection: any): import("mongoose").Cursor<import("mongoose").Document<unknown, Record<string, never>, import("@chevre/factory/lib/chevre/event/screeningEvent").IAttributes & {
+        _id: string;
+        aggregateOffer?: factory.event.screeningEvent.IAggregateOffer;
+    }, import("./mongoose/virtuals").IVirtuals, {}> & import("@chevre/factory/lib/chevre/event/screeningEvent").IAttributes & {
+        _id: string;
+        aggregateOffer?: factory.event.screeningEvent.IAggregateOffer;
+    } & Required<{
+        _id: string;
+    }> & {
+        __v: number;
+    }, import("mongoose").QueryOptions<import("@chevre/factory/lib/chevre/event/screeningEvent").IAttributes & {
+        _id: string;
+        aggregateOffer?: factory.event.screeningEvent.IAggregateOffer;
+    }>, (import("mongoose").Document<unknown, Record<string, never>, import("@chevre/factory/lib/chevre/event/screeningEvent").IAttributes & {
+        _id: string;
+        aggregateOffer?: factory.event.screeningEvent.IAggregateOffer;
+    }, import("./mongoose/virtuals").IVirtuals, {}> & import("@chevre/factory/lib/chevre/event/screeningEvent").IAttributes & {
+        _id: string;
+        aggregateOffer?: factory.event.screeningEvent.IAggregateOffer;
+    } & Required<{
+        _id: string;
+    }> & {
+        __v: number;
+    }) | null>;
+    unsetUnnecessaryFields(params: {
+        filter: FilterQuery<factory.event.screeningEvent.IEvent>;
+        $unset: IUnset;
+    }): Promise<import("mongoose").UpdateWriteOpResult>;
+}
+export {};

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 {};