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

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;

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

@@ -1,47 +1,7 @@
-import { Connection, FilterQuery, mongo } from 'mongoose';
+import { Connection, FilterQuery } from 'mongoose';
 import { factory } from '../factory';
 import * as EventFactory from '../factory/event';
-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?: '';
-    };
-}
 export type ISearchConditions = factory.event.screeningEvent.ISearchConditions;
-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 import IMinimizedIndividualEvent = EventFactory.IMinimizedIndividualEvent;
 type IKeyOfProjection = Exclude<keyof factory.event.screeningEvent.IEvent, 'id'> | 'aggregateOffer' | 'superEvent.location.id' | 'offers.itemOffered' | 'offers.itemOffered.id' | 'offers.typeOf';
 type IKeyOfProjection4publicFields = Exclude<keyof factory.event.screeningEvent.IEvent, 'id' | 'offers'>;
@@ -50,75 +10,13 @@ type IKeyOfProjection4publicFields = Exclude<keyof factory.event.screeningEvent.
  * add(2024-07-18~)
  */
 type IKeyOfProjection4minimizedEvent = Exclude<keyof IMinimizedIndividualEvent, 'additionalProperty' | 'id'> | 'superEvent.id' | 'location.branchCode' | 'superEvent.workPerformed.identifier' | 'superEvent.location.id' | 'offers.itemOffered' | 'offers.itemOffered.id' | 'offers.offeredThrough' | 'offers.unacceptedPaymentMethod' | 'offers.eligibleQuantity';
-type IUnset = {
-    [key in keyof factory.event.screeningEvent.IEvent]?: 1;
-};
-export type ICreatingEvent4ttts = Pick<factory.event.screeningEvent.IAttributes, 'additionalProperty' | 'doorTime' | 'endDate' | 'eventStatus' | 'location' | 'name' | 'offers' | 'organizer' | 'project' | 'startDate' | 'superEvent' | 'typeOf'> & {
-    identifier: string;
-};
 /**
  * イベントリポジトリ
  */
 export declare class EventRepo {
     private readonly eventModel;
     constructor(connection: Connection);
-    /**
-     * イベントIDを生成する
-     */
-    static CREATE_ID(): string;
     static CREATE_MONGO_CONDITIONS(conditions: ISearchConditions): FilterQuery<factory.event.screeningEvent.IEvent>[];
-    /**
-     * イベントコードをキーにして冪等置換
-     */
-    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>;
     /**
      * イベントを検索する(inclusion projection)
      */
@@ -159,7 +57,10 @@ export declare class EventRepo {
             };
         };
     }): Promise<Omit<factory.event.screeningEvent.IEvent, 'aggregateOffer'>>;
-    searchEventIds(params: ISearchConditions): Promise<string[]>;
+    /**
+     * COAイベントキャンセル時に使用
+     */
+    searchEventIds(params: Pick<ISearchConditions, 'project' | 'typeOf' | 'superEvent' | 'startFrom' | 'startThrough'>): Promise<string[]>;
     /**
      * 特定イベントから指定フィールドのみ取得する
      * イベント IDは必ず返ります
@@ -167,164 +68,5 @@ export declare class EventRepo {
     projectEventFieldsById(params: {
         id: string;
     }, inclusion: IKeyOfProjection4minimizedEvent[]): Promise<IMinimizedIndividualEvent>;
-    /**
-     * イベントをキャンセルする
-     */
-    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>;
-    aggregateEvent(params: {
-        project?: {
-            id?: {
-                $ne?: string;
-            };
-        };
-        startFrom: Date;
-        startThrough: Date;
-        typeOf: factory.eventType.ScreeningEvent;
-    }): Promise<IAggregateEvent>;
-    private agggregateByStatus;
 }
 export {};