@chevre/domain 15.65.0-alpha.9 → 20.0.0-alpha.1

package/lib/chevre/service/aggregation/event/aggregateScreeningEvent.js

@@ -0,0 +1,447 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aggregateByEvent = exports.aggregateScreeningEvent = void 0;
+/**
+ * イベント集計サービス
+ */
+const createDebug = require("debug");
+const moment = require("moment-timezone");
+const factory = require("../../../factory");
+const debug = createDebug('chevre-domain:service');
+/**
+ * イベントデータをID指定で集計する
+ */
+function aggregateScreeningEvent(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        // 集計対象イベント検索
+        const event = yield repos.event.findById(params);
+        let aggregatingEvents = [event];
+        const availableOffers = yield findOffers({ event })(repos);
+        const offerRateLimitExists = availableOffers.some((o) => { var _a; return typeof ((_a = o.validRateLimit) === null || _a === void 0 ? void 0 : _a.scope) === 'string'; });
+        if (offerRateLimitExists) {
+            // 同location、かつ同時間帯、のイベントに関しても集計する(ttts暫定対応)
+            const startFrom = moment(event.startDate)
+                .startOf('hour')
+                .toDate();
+            const startThrough = moment(startFrom)
+                .add(1, 'hour')
+                .add(-1, 'second')
+                .toDate();
+            aggregatingEvents = yield repos.event.search({
+                limit: 100,
+                page: 1,
+                project: { id: { $eq: event.project.id } },
+                typeOf: event.typeOf,
+                eventStatuses: [factory.eventStatusType.EventScheduled],
+                startFrom: startFrom,
+                startThrough: startThrough,
+                location: { branchCode: { $eq: event.location.branchCode } }
+            });
+            // ID指定されたイベントについてはEventScheduledでなくても集計したいので、集計対象を調整
+            aggregatingEvents = aggregatingEvents.filter((e) => e.id !== event.id);
+            aggregatingEvents = [event, ...aggregatingEvents];
+        }
+        debug(aggregatingEvents.length, 'aggregatingEvents found', aggregatingEvents.map((e) => e.id));
+        for (const aggregatingEvent of aggregatingEvents) {
+            yield aggregateByEvent({ event: aggregatingEvent })(repos);
+        }
+    });
+}
+exports.aggregateScreeningEvent = aggregateScreeningEvent;
+function aggregateByEvent(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        const now = new Date();
+        // 集計対象イベント検索
+        let event = params.event;
+        // 施設取得
+        const movieTheater = yield findLocation(params)(repos);
+        // 万が一施設が存在しなければ処理終了
+        if (movieTheater === undefined) {
+            return;
+        }
+        const screeningRoom = movieTheater.containsPlace.find((p) => p.branchCode === event.location.branchCode);
+        if (screeningRoom === undefined) {
+            // 基本的にありえないはずだが、万が一スクリーンが見つからなければcapacityは0のまま
+            // tslint:disable-next-line:no-console
+            console.error(new Error(`Screening room not found. branchCode: ${event.location.branchCode}`));
+            return;
+        }
+        // 予約集計
+        const { maximumAttendeeCapacity, remainingAttendeeCapacity, aggregateReservation } = yield aggregateReservationByEvent({
+            aggregateDate: now,
+            event: event,
+            screeningRoom: screeningRoom
+        })(repos);
+        // オファーごとの集計
+        const aggregateOffer = yield aggregateOfferByEvent({
+            aggregateDate: now,
+            event: Object.assign(Object.assign({}, event), { maximumAttendeeCapacity,
+                remainingAttendeeCapacity }),
+            screeningRoom: screeningRoom
+        })(repos);
+        debug('offers aggregated', aggregateOffer);
+        // 入場ゲートごとの集計
+        // const aggregateEntranceGate = await aggregateEntranceGateByEvent({
+        //     aggregateDate: now,
+        //     event,
+        //     entranceGates: movieTheater.hasEntranceGate
+        // })(repos);
+        // debug('entrances aggregated', aggregateEntranceGate);
+        // 値がundefinedの場合に更新しないように注意
+        const update = {
+            $set: Object.assign(Object.assign(Object.assign(Object.assign({ updatedAt: new Date(), // $setオブジェクトが空だとMongoエラーになるので
+                // aggregateEntranceGate,
+                aggregateReservation,
+                aggregateOffer }, (maximumAttendeeCapacity !== undefined) ? { maximumAttendeeCapacity: maximumAttendeeCapacity } : undefined), (remainingAttendeeCapacity !== undefined) ? { remainingAttendeeCapacity: remainingAttendeeCapacity } : undefined), (aggregateReservation.checkInCount !== undefined) ? { checkInCount: aggregateReservation.checkInCount } : undefined), (aggregateReservation.attendeeCount !== undefined) ? { attendeeCount: aggregateReservation.attendeeCount } : undefined),
+            $unset: Object.assign(Object.assign({ noExistingAttributeName: 1 }, (maximumAttendeeCapacity === undefined) ? { maximumAttendeeCapacity: '' } : undefined), (remainingAttendeeCapacity === undefined) ? { remainingAttendeeCapacity: '' } : undefined)
+        };
+        debug('update:', update);
+        // 保管
+        event = yield repos.event.updateAggregationById({ id: event.id }, update);
+        yield onAggregated({ event })({
+            project: repos.project,
+            task: repos.task
+        });
+    });
+}
+exports.aggregateByEvent = aggregateByEvent;
+/**
+ * イベントロケーション取得
+ * NotFoundエラーをハンドリングする
+ */
+function findLocation(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        let movieTheater;
+        try {
+            movieTheater = yield repos.place.findById({ id: params.event.superEvent.location.id });
+        }
+        catch (error) {
+            let throwsError = true;
+            if (error instanceof factory.errors.NotFound) {
+                throwsError = false;
+            }
+            if (throwsError) {
+                throw error;
+            }
+        }
+        return movieTheater;
+    });
+}
+/**
+ * 集計後アクション
+ */
+function onAggregated(__1) {
+    return (__2) => __awaiter(this, void 0, void 0, function* () {
+        // const event = params.event;
+    });
+}
+function reservedSeatsAvailable(params) {
+    var _a, _b, _c;
+    const eventOffers = params.event.offers;
+    return ((_c = (_b = (_a = eventOffers === null || eventOffers === void 0 ? void 0 : eventOffers.itemOffered) === null || _a === void 0 ? void 0 : _a.serviceOutput) === null || _b === void 0 ? void 0 : _b.reservedTicket) === null || _c === void 0 ? void 0 : _c.ticketedSeat) !== undefined;
+}
+function aggregateOfferByEvent(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c;
+        const availableOffers = yield findOffers(params)(repos);
+        // オファーごとの予約集計
+        const offersWithAggregateReservation = [];
+        for (const o of availableOffers) {
+            const { maximumAttendeeCapacity, remainingAttendeeCapacity, aggregateReservation } = yield aggregateReservationByOffer({
+                aggregateDate: params.aggregateDate,
+                event: params.event,
+                screeningRoom: params.screeningRoom,
+                offer: o
+            })(repos);
+            offersWithAggregateReservation.push(Object.assign(Object.assign(Object.assign({ typeOf: o.typeOf, id: o.id, identifier: o.identifier, aggregateReservation: aggregateReservation, name: {
+                    en: (_a = o.name) === null || _a === void 0 ? void 0 : _a.en,
+                    ja: (_b = o.name) === null || _b === void 0 ? void 0 : _b.ja
+                } }, (typeof maximumAttendeeCapacity === 'number') ? { maximumAttendeeCapacity } : undefined), (typeof remainingAttendeeCapacity === 'number') ? { remainingAttendeeCapacity } : undefined), (typeof ((_c = o.category) === null || _c === void 0 ? void 0 : _c.codeValue) === 'string') ? { category: o.category } : undefined));
+        }
+        return {
+            typeOf: factory.offerType.AggregateOffer,
+            offerCount: availableOffers.length,
+            offers: offersWithAggregateReservation
+        };
+    });
+}
+/**
+ * イベントオファー検索
+ * NotFoundエラーをハンドリングする
+ */
+function findOffers(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        let availableOffers = [];
+        try {
+            // 興行設定があれば興行のカタログを参照する(2022-08-31~)
+            const eventOffers = params.event.offers;
+            if (typeof ((_a = eventOffers === null || eventOffers === void 0 ? void 0 : eventOffers.itemOffered) === null || _a === void 0 ? void 0 : _a.id) === 'string') {
+                const eventService = yield repos.product.findById({ id: eventOffers.itemOffered.id });
+                if (typeof ((_b = eventService.hasOfferCatalog) === null || _b === void 0 ? void 0 : _b.id) === 'string') {
+                    availableOffers = yield repos.offer.findOffersByOfferCatalogId({
+                        offerCatalog: { id: eventService.hasOfferCatalog.id }
+                    });
+                }
+            }
+            else {
+                // hasOfferCatalog参照廃止(2022-09-02~)
+                throw new factory.errors.NotFound('event.offers.itemOffered.id');
+                // if (typeof params.event.hasOfferCatalog?.id === 'string') {
+                //     availableOffers = await repos.offer.findOffersByOfferCatalogId({
+                //         offerCatalog: {
+                //             id: params.event.hasOfferCatalog.id
+                //         }
+                //     });
+                // }
+            }
+        }
+        catch (error) {
+            let throwsError = true;
+            // 万が一カタログが見つからない場合に対応
+            if (error instanceof factory.errors.NotFound) {
+                throwsError = false;
+            }
+            if (throwsError) {
+                throw error;
+            }
+        }
+        return availableOffers;
+    });
+}
+function aggregateReservationByOffer(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        let reservationCount4offer;
+        let attendeeCount4offer;
+        let checkInCount4offer;
+        reservationCount4offer = yield repos.reservation.count({
+            typeOf: factory.reservationType.EventReservation,
+            reservationFor: { ids: [params.event.id] },
+            reservationStatuses: [factory.reservationStatusType.ReservationConfirmed],
+            reservedTicket: { ticketType: { ids: [params.offer.id] } }
+        });
+        attendeeCount4offer = yield repos.reservation.count({
+            typeOf: factory.reservationType.EventReservation,
+            reservationFor: { ids: [params.event.id] },
+            reservationStatuses: [factory.reservationStatusType.ReservationConfirmed],
+            reservedTicket: { ticketType: { ids: [params.offer.id] } },
+            attended: true
+        });
+        checkInCount4offer = yield repos.reservation.count({
+            typeOf: factory.reservationType.EventReservation,
+            reservationFor: { ids: [params.event.id] },
+            reservationStatuses: [factory.reservationStatusType.ReservationConfirmed],
+            reservedTicket: { ticketType: { ids: [params.offer.id] } },
+            checkedIn: true
+        });
+        const { maximumAttendeeCapacity, remainingAttendeeCapacity } = yield calculateCapacityByOffer(params)(repos);
+        return Object.assign(Object.assign({ aggregateReservation: {
+                typeOf: 'AggregateReservation',
+                aggregateDate: params.aggregateDate,
+                reservationCount: reservationCount4offer,
+                attendeeCount: attendeeCount4offer,
+                checkInCount: checkInCount4offer
+            } }, (typeof maximumAttendeeCapacity === 'number') ? { maximumAttendeeCapacity } : undefined), (typeof remainingAttendeeCapacity === 'number') ? { remainingAttendeeCapacity } : undefined);
+    });
+}
+/**
+ * オファーごとのキャパシティを算出する
+ */
+function calculateCapacityByOffer(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        let maximumAttendeeCapacity;
+        let remainingAttendeeCapacity;
+        if (reservedSeatsAvailable({ event: params.event })) {
+            // 基本的にはイベントのキャパシティに同じ
+            maximumAttendeeCapacity = params.event.maximumAttendeeCapacity;
+            remainingAttendeeCapacity = params.event.remainingAttendeeCapacity;
+            // 座席タイプ制約のあるオファーの場合
+            const eligibleSeatingTypes = params.offer.eligibleSeatingType;
+            if (Array.isArray(eligibleSeatingTypes)) {
+                const filterByEligibleSeatingTypeResult = yield filterByEligibleSeatingType({
+                    event: params.event,
+                    screeningRoom: params.screeningRoom,
+                    eligibleSeatingTypes: eligibleSeatingTypes.map((e) => e.codeValue)
+                })(repos);
+                maximumAttendeeCapacity = filterByEligibleSeatingTypeResult.maximumAttendeeCapacity;
+                remainingAttendeeCapacity = filterByEligibleSeatingTypeResult.remainingAttendeeCapacity;
+            }
+            // 適用サブ予約がある場合
+            const eligibleSubReservation = params.offer.eligibleSubReservation;
+            if (Array.isArray(eligibleSubReservation)) {
+                // 適用サブ予約の座席タイプごとにキャパシティ算出
+                const capacities = yield Promise.all(eligibleSubReservation
+                    .filter((subReservation) => typeof subReservation.amountOfThisGood === 'number' && subReservation.amountOfThisGood > 0)
+                    .map((subReservation) => __awaiter(this, void 0, void 0, function* () {
+                    const filterByEligibleSeatingTypeResult = yield filterByEligibleSeatingType({
+                        event: params.event,
+                        screeningRoom: params.screeningRoom,
+                        eligibleSeatingTypes: [subReservation.typeOfGood.seatingType]
+                    })(repos);
+                    return {
+                        maximumAttendeeCapacity: Math.floor(filterByEligibleSeatingTypeResult.maximumAttendeeCapacity / subReservation.amountOfThisGood),
+                        remainingAttendeeCapacity: Math.floor(filterByEligibleSeatingTypeResult.remainingAttendeeCapacity / subReservation.amountOfThisGood)
+                    };
+                })));
+                // 座席タイプごとのキャパシティの中から、最小数を選択する
+                maximumAttendeeCapacity = Math.min(...(typeof maximumAttendeeCapacity === 'number') ? [maximumAttendeeCapacity] : [], ...capacities.map((c) => c.maximumAttendeeCapacity));
+                remainingAttendeeCapacity = Math.min(...(typeof remainingAttendeeCapacity === 'number') ? [remainingAttendeeCapacity] : [], ...capacities.map((c) => c.remainingAttendeeCapacity));
+            }
+            // 単価スペックの単位が1より大きい場合
+            const referenceQuantityValue = (_a = params.offer.priceSpecification) === null || _a === void 0 ? void 0 : _a.referenceQuantity.value;
+            if (typeof referenceQuantityValue === 'number' && referenceQuantityValue > 1) {
+                if (typeof maximumAttendeeCapacity === 'number') {
+                    maximumAttendeeCapacity -= maximumAttendeeCapacity % referenceQuantityValue;
+                }
+                if (typeof remainingAttendeeCapacity === 'number') {
+                    remainingAttendeeCapacity -= remainingAttendeeCapacity % referenceQuantityValue;
+                }
+            }
+        }
+        // レート制限がある場合、考慮する
+        if (yield isHoldByRateLimit(params)({ offerRateLimit: repos.offerRateLimit })) {
+            remainingAttendeeCapacity = 0;
+        }
+        return { maximumAttendeeCapacity, remainingAttendeeCapacity };
+    });
+}
+function isHoldByRateLimit(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        let isHold = false;
+        const scope = (_a = params.offer.validRateLimit) === null || _a === void 0 ? void 0 : _a.scope;
+        const unitInSeconds = (_b = params.offer.validRateLimit) === null || _b === void 0 ? void 0 : _b.unitInSeconds;
+        if (typeof scope === 'string' && typeof unitInSeconds === 'number') {
+            const rateLimitKey = {
+                reservedTicket: {
+                    ticketType: {
+                        validRateLimit: { scope: scope, unitInSeconds: unitInSeconds }
+                    }
+                },
+                reservationFor: {
+                    startDate: moment(params.event.startDate)
+                        .toDate()
+                },
+                reservationNumber: ''
+            };
+            const holder = yield repos.offerRateLimit.getHolder(rateLimitKey);
+            // ロックされていれば在庫0
+            if (typeof holder === 'string' && holder.length > 0) {
+                isHold = true;
+            }
+        }
+        return isHold;
+    });
+}
+function filterByEligibleSeatingType(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        // 適用座席タイプに絞る
+        const eligibleSeatOffers = (Array.isArray(params.screeningRoom.containsPlace))
+            ? params.screeningRoom.containsPlace.reduce((a, b) => {
+                return [
+                    ...a,
+                    ...(Array.isArray(b.containsPlace))
+                        ? b.containsPlace.filter((place) => {
+                            const seatingTypes = (Array.isArray(place.seatingType)) ? place.seatingType
+                                : (typeof place.seatingType === 'string') ? [place.seatingType]
+                                    : [];
+                            return seatingTypes.some((seatingTypeCodeValue) => params.eligibleSeatingTypes.some((eligibleSeatingType) => eligibleSeatingType === seatingTypeCodeValue));
+                        })
+                            .map((place) => {
+                            return {
+                                seatSection: b.branchCode,
+                                seatNumber: place.branchCode
+                            };
+                        })
+                        : []
+                ];
+            }, [])
+            : [];
+        const maximumAttendeeCapacity = eligibleSeatOffers.length;
+        let remainingAttendeeCapacity;
+        if (maximumAttendeeCapacity > 0) {
+            const availabilities = yield repos.eventAvailability.searchAvailability({
+                eventId: params.event.id,
+                offers: eligibleSeatOffers
+            });
+            remainingAttendeeCapacity = availabilities.filter((a) => a.availability === factory.itemAvailability.InStock).length;
+        }
+        else {
+            remainingAttendeeCapacity = 0;
+        }
+        return { maximumAttendeeCapacity, remainingAttendeeCapacity };
+    });
+}
+function aggregateReservationByEvent(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        // 収容人数を集計
+        let maximumAttendeeCapacity;
+        let remainingAttendeeCapacity;
+        let attendeeCount;
+        let checkInCount;
+        let reservationCount;
+        reservationCount = yield repos.reservation.count({
+            typeOf: factory.reservationType.EventReservation,
+            reservationFor: { ids: [params.event.id] },
+            reservationStatuses: [factory.reservationStatusType.ReservationConfirmed]
+        });
+        // maximumAttendeeCapacityを決定
+        const eventLocationMaximumAttendeeCapacity = params.event.location.maximumAttendeeCapacity;
+        if (typeof eventLocationMaximumAttendeeCapacity === 'number') {
+            maximumAttendeeCapacity = eventLocationMaximumAttendeeCapacity;
+        }
+        if (reservedSeatsAvailable({ event: params.event })) {
+            const screeningRoomSeatCount = (Array.isArray(params.screeningRoom.containsPlace))
+                // b.containsPlaceがundefinedの場合があるので注意(座席未登録)
+                ? params.screeningRoom.containsPlace.reduce((a, b) => a + ((Array.isArray(b.containsPlace)) ? b.containsPlace.length : 0), 0)
+                : 0;
+            maximumAttendeeCapacity = screeningRoomSeatCount;
+            // イベントのキャパシティ設定がスクリーン座席数より小さければmaximumAttendeeCapacityを上書き
+            if (typeof eventLocationMaximumAttendeeCapacity === 'number' && eventLocationMaximumAttendeeCapacity < screeningRoomSeatCount) {
+                maximumAttendeeCapacity = eventLocationMaximumAttendeeCapacity;
+            }
+        }
+        // remainingAttendeeCapacityを決定
+        if (typeof maximumAttendeeCapacity === 'number') {
+            // 残席数を座席ロック数から計算
+            const unavailableOfferCount = yield repos.eventAvailability.countUnavailableOffers({ event: { id: params.event.id } });
+            remainingAttendeeCapacity = maximumAttendeeCapacity - unavailableOfferCount;
+            if (remainingAttendeeCapacity < 0) {
+                remainingAttendeeCapacity = 0;
+            }
+        }
+        attendeeCount = yield repos.reservation.count({
+            typeOf: factory.reservationType.EventReservation,
+            reservationFor: { ids: [params.event.id] },
+            // reservationStatuses: [factory.reservationStatusType.ReservationConfirmed],
+            attended: true
+        });
+        checkInCount = yield repos.reservation.count({
+            typeOf: factory.reservationType.EventReservation,
+            reservationFor: { ids: [params.event.id] },
+            // reservationStatuses: [factory.reservationStatusType.ReservationConfirmed],
+            checkedIn: true
+        });
+        return {
+            maximumAttendeeCapacity,
+            remainingAttendeeCapacity,
+            aggregateReservation: {
+                typeOf: 'AggregateReservation',
+                aggregateDate: params.aggregateDate,
+                attendeeCount,
+                checkInCount,
+                reservationCount
+            }
+        };
+    });
+}

package/lib/chevre/service/aggregation/event/aggregateUseActionsOnEvent.d.ts

@@ -0,0 +1,15 @@
+import { MongoRepository as ActionRepo } from '../../../repo/action';
+import { MongoRepository as EventRepo } from '../../../repo/event';
+import { MongoRepository as OfferRepo } from '../../../repo/offer';
+import { MongoRepository as PlaceRepo } from '../../../repo/place';
+import { MongoRepository as ProductRepo } from '../../../repo/product';
+export declare type IAggregateOperation<T> = (repos: {
+    action: ActionRepo;
+    event: EventRepo;
+    offer: OfferRepo;
+    place: PlaceRepo;
+    product: ProductRepo;
+}) => Promise<T>;
+export declare function aggregateUseActionsOnEvent(params: {
+    id: string;
+}): IAggregateOperation<void>;

package/lib/chevre/service/aggregation/event/aggregateUseActionsOnEvent.js

@@ -0,0 +1,170 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aggregateUseActionsOnEvent = void 0;
+/**
+ * イベント入場集計サービス
+ */
+const createDebug = require("debug");
+const factory = require("../../../factory");
+const debug = createDebug('chevre-domain:service');
+function aggregateUseActionsOnEvent(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        const now = new Date();
+        // 集計対象イベント検索
+        const event = yield repos.event.findById(params);
+        // 入場ゲート検索
+        const entranceGates = yield findEntranceGates({ event })(repos);
+        // 入場ゲートごとの集計
+        const aggregateEntranceGate = yield aggregateEntranceGateByEvent({
+            aggregateDate: now,
+            event,
+            entranceGates
+        })(repos);
+        debug('entrances aggregated', aggregateEntranceGate);
+        // 値がundefinedの場合に更新しないように注意
+        const update = {
+            $set: {
+                updatedAt: new Date(),
+                aggregateEntranceGate
+            },
+            $unset: {
+                noExistingAttributeName: 1 // $unsetは空だとエラーになるので
+            }
+        };
+        debug('update:', update);
+        // 保管
+        yield repos.event.updateAggregationById({ id: event.id }, update);
+    });
+}
+exports.aggregateUseActionsOnEvent = aggregateUseActionsOnEvent;
+/**
+ * イベントロケーション取得
+ * NotFoundエラーをハンドリングする
+ */
+function findEntranceGates(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        let movieTheater;
+        try {
+            movieTheater = yield repos.place.findById({ id: params.event.superEvent.location.id }, 
+            // 不要な属性を取得しない
+            {
+                containsPlace: 0,
+                hasPOS: 0,
+                offers: 0,
+                parentOrganization: 0
+            });
+        }
+        catch (error) {
+            let throwsError = true;
+            if (error instanceof factory.errors.NotFound) {
+                throwsError = false;
+            }
+            if (throwsError) {
+                throw error;
+            }
+        }
+        return movieTheater === null || movieTheater === void 0 ? void 0 : movieTheater.hasEntranceGate;
+    });
+}
+/**
+ * イベントオファー検索
+ * NotFoundエラーをハンドリングする
+ */
+function findOffers(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        let availableOffers = [];
+        try {
+            // 興行設定があれば興行のカタログを参照する(2022-08-31~)
+            const eventOffers = params.event.offers;
+            if (typeof ((_a = eventOffers === null || eventOffers === void 0 ? void 0 : eventOffers.itemOffered) === null || _a === void 0 ? void 0 : _a.id) === 'string') {
+                const eventService = yield repos.product.findById({ id: eventOffers.itemOffered.id });
+                if (typeof ((_b = eventService.hasOfferCatalog) === null || _b === void 0 ? void 0 : _b.id) === 'string') {
+                    availableOffers = yield repos.offer.findOffersByOfferCatalogId({
+                        offerCatalog: { id: eventService.hasOfferCatalog.id }
+                    });
+                }
+            }
+            else {
+                // hasOfferCatalog参照廃止(2022-09-02~)
+                throw new factory.errors.NotFound('event.offers.itemOffered.id');
+                // if (typeof params.event.hasOfferCatalog?.id === 'string') {
+                //     availableOffers = await repos.offer.findOffersByOfferCatalogId({
+                //         offerCatalog: { id: params.event.hasOfferCatalog.id }
+                //     });
+                // }
+            }
+        }
+        catch (error) {
+            let throwsError = true;
+            // 万が一カタログが見つからない場合に対応
+            if (error instanceof factory.errors.NotFound) {
+                throwsError = false;
+            }
+            if (throwsError) {
+                throw error;
+            }
+        }
+        return availableOffers;
+    });
+}
+/**
+ * 入場ゲートごとに集計する
+ */
+function aggregateEntranceGateByEvent(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        // 入場ゲートの予約使用アクション集計
+        const places = [];
+        if (Array.isArray(params.entranceGates) && params.entranceGates.length > 0) {
+            const availableOffers = yield findOffers(params)(repos);
+            // 念のため、identifierの存在する入場ゲートに絞る
+            const entranceGates = params.entranceGates.filter((e) => {
+                return typeof e.identifier === 'string' && e.identifier.length > 0;
+            });
+            for (const entranceGate of entranceGates) {
+                const entranceGateIdentifier = String(entranceGate.identifier);
+                const aggregateResult = yield repos.action.countUseActionsByEntranceGate({
+                    event: { id: params.event.id },
+                    entranceGateIdentifier
+                });
+                debug('aggregateResult:', aggregateResult);
+                const offersOnEntranceGate = yield Promise.all(availableOffers.map((offer) => __awaiter(this, void 0, void 0, function* () {
+                    var _a, _b;
+                    // このオファーでの予約使用アクション数
+                    let useActionCount = (_a = aggregateResult.find((a) => a._id[0] === offer.id)) === null || _a === void 0 ? void 0 : _a.useActionCount;
+                    if (typeof useActionCount !== 'number') {
+                        useActionCount = 0;
+                    }
+                    debug('useActionCount:', useActionCount, entranceGateIdentifier, offer.id);
+                    return Object.assign(Object.assign({ typeOf: offer.typeOf, id: offer.id, identifier: offer.identifier }, (typeof ((_b = offer.category) === null || _b === void 0 ? void 0 : _b.codeValue) === 'string') ? { category: offer.category } : undefined), { aggregateReservation: {
+                            typeOf: 'AggregateReservation',
+                            aggregateDate: params.aggregateDate,
+                            useActionCount
+                        } });
+                })));
+                places.push({
+                    typeOf: entranceGate.typeOf,
+                    identifier: entranceGateIdentifier,
+                    aggregateOffer: {
+                        typeOf: factory.offerType.AggregateOffer,
+                        offers: offersOnEntranceGate
+                    }
+                });
+            }
+        }
+        debug('AggregatePlace created,', places);
+        return {
+            typeOf: factory.placeType.AggregatePlace,
+            places: places
+        };
+    });
+}

package/lib/chevre/service/aggregation/event/importFromCOA.d.ts

@@ -0,0 +1,16 @@
+import { MongoRepository as EventRepo } from '../../../repo/event';
+import * as factory from '../../../factory';
+/**
+ * イベント席数を更新する
+ */
+export declare function importFromCOA(params: {
+    project: {
+        id: string;
+        typeOf: factory.organizationType.Project;
+    };
+    locationBranchCode: string;
+    importFrom: Date;
+    importThrough: Date;
+}): (repos: {
+    event: EventRepo;
+}) => Promise<void>;