@chevre/domain 22.9.0-alpha.116 → 22.9.0-alpha.118

package/example/src/chevre/offers/createSampleOffers.ts

@@ -0,0 +1,154 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../../lib/index';
+
+const project = { id: String(process.env.PROJECT_ID) };
+const NUM_CREATE_OFFERS = 300;
+const NUM_CREATE_SUB_CATALOGS = 10;
+
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const aggregateOfferRepo = await chevre.repository.AggregateOffer.createInstance(mongoose.connection);
+    const offerCatalogRepo = await chevre.repository.OfferCatalog.createInstance(mongoose.connection);
+    const productRepo = await chevre.repository.Product.createInstance(mongoose.connection);
+    const offerCatalogItemRepo = await chevre.repository.OfferCatalogItem.createInstance(mongoose.connection);
+
+    const savingOffers: Omit<chevre.factory.unitPriceOffer.IUnitPriceOffer, 'id'>[] =
+        // tslint:disable-next-line:prefer-array-literal
+        [...Array(NUM_CREATE_OFFERS)].map<Omit<chevre.factory.unitPriceOffer.IUnitPriceOffer, 'id'>>((__, i) => {
+            const identifier = `sampleFreeOffer${i}`;
+            const priceSpecification: chevre.factory.unitPriceOffer.IUnitPriceOfferPriceSpecification = {
+                typeOf: chevre.factory.priceSpecificationType.UnitPriceSpecification,
+                priceCurrency: chevre.factory.priceCurrency.JPY,
+                valueAddedTaxIncluded: true,
+                price: 0,
+                referenceQuantity: {
+                    value: 1,
+                    typeOf: 'QuantitativeValue',
+                    unitCode: chevre.factory.unitCode.C62
+                },
+                accounting: {
+                    typeOf: 'Accounting',
+                    accountsReceivable: 0
+                }
+            };
+
+            return {
+                project: { id: project.id, typeOf: chevre.factory.organizationType.Project },
+                typeOf: chevre.factory.offerType.Offer,
+                identifier,
+                description: { en: identifier, ja: identifier },
+                alternateName: { ja: identifier },
+                name: { en: identifier, ja: identifier },
+                availability: chevre.factory.itemAvailability.InStock,
+                availableAtOrFrom: [
+                    { id: '51qbjcfr72h62m06vtv5kkhgje' }
+                ],
+                itemOffered: { typeOf: chevre.factory.product.ProductType.EventService },
+                priceCurrency: chevre.factory.priceCurrency.JPY,
+                priceSpecification
+            };
+        });
+    const saveOfferResult = await aggregateOfferRepo.upsertByIdentifier(savingOffers);
+    console.log('saveOfferResult:', saveOfferResult);
+
+    const offerIds: string[] = (Array.isArray(saveOfferResult?.modifiedOffers)) ? saveOfferResult.modifiedOffers.map(({ id }) => id) : [];
+    const catalogIdentifier = 'sampleFreeOffersCatalog';
+    const savingOfferCatalog: chevre.factory.offerCatalog.IOfferCatalog = {
+        project: { id: project.id, typeOf: chevre.factory.organizationType.Project },
+        typeOf: 'OfferCatalog',
+        identifier: catalogIdentifier,
+        description: { en: catalogIdentifier, ja: catalogIdentifier },
+        name: { en: catalogIdentifier, ja: catalogIdentifier },
+        itemListElement: offerIds.map((id) => ({ id, typeOf: chevre.factory.offerType.Offer })),
+        itemOffered: { typeOf: chevre.factory.product.ProductType.EventService }
+    };
+    const saveCatalogResult = await offerCatalogRepo.saveByIdentifier(savingOfferCatalog);
+    console.log('saveCatalogResult:', saveCatalogResult);
+
+    const productId = 'sampleFreeEventService';
+    const savingProduct: chevre.factory.product.IProduct & {
+        offers?: never;
+    } = {
+        project: { id: project.id, typeOf: chevre.factory.organizationType.Project },
+        typeOf: chevre.factory.product.ProductType.EventService,
+        name: { en: productId, ja: productId },
+        productID: productId,
+        hasOfferCatalog: {
+            typeOf: 'OfferCatalog',
+            itemListElement: [{ id: saveCatalogResult.id }]
+        }
+    };
+    const saveProductResult = await productRepo.upsertManyByProductId([{
+        $set: savingProduct
+    }]);
+    console.log('saveProductResult:', saveProductResult);
+
+    // 以下サブカタログ
+    const offerIds4subCatalog: string[] = (Array.isArray(saveOfferResult?.modifiedOffers))
+        // tslint:disable-next-line:no-magic-numbers
+        ? saveOfferResult.modifiedOffers.slice(0, 100)
+            .map(({ id }) => id) :
+        [];
+    const savingSubOfferCatalogs: chevre.factory.offerCatalog.IOfferCatalog[] =
+        // tslint:disable-next-line:prefer-array-literal
+        [...Array(NUM_CREATE_SUB_CATALOGS)].map<chevre.factory.offerCatalog.IOfferCatalog>((__, i) => {
+            const subCatalogIdentifier = `sampleFreeOffersSubCatalog${i}`;
+
+            return {
+                project: { id: project.id, typeOf: chevre.factory.organizationType.Project },
+                typeOf: 'OfferCatalog',
+                identifier: subCatalogIdentifier,
+                description: { en: subCatalogIdentifier, ja: subCatalogIdentifier },
+                name: { en: subCatalogIdentifier, ja: subCatalogIdentifier },
+                itemListElement: offerIds4subCatalog.map((id) => ({ id, typeOf: chevre.factory.offerType.Offer })),
+                itemOffered: { typeOf: chevre.factory.product.ProductType.EventService }
+            };
+        });
+    const saveSubCatalogResult = await offerCatalogItemRepo.upsertManyByIdentifier(savingSubOfferCatalogs.map((savingSubOfferCatalog) => {
+        return {
+            $set: savingSubOfferCatalog
+        };
+    }));
+    console.log('saveSubCatalogResult:', saveSubCatalogResult);
+
+    const subCatalogIds: string[] =
+        (Array.isArray(saveSubCatalogResult?.modifiedCatalogs)) ? saveSubCatalogResult.modifiedCatalogs.map(({ id }) => id) : [];
+    const catalogBySubCatalogIdentifier = 'sampleFreeOffersCatalogBySub';
+    const savingOfferCatalogBySubCatalog: chevre.factory.offerCatalog.IOfferCatalog = {
+        project: { id: project.id, typeOf: chevre.factory.organizationType.Project },
+        typeOf: 'OfferCatalog',
+        identifier: catalogBySubCatalogIdentifier,
+        description: { en: catalogBySubCatalogIdentifier, ja: catalogBySubCatalogIdentifier },
+        name: { en: catalogBySubCatalogIdentifier, ja: catalogBySubCatalogIdentifier },
+        itemListElement: subCatalogIds.map((id) => ({ id, typeOf: 'OfferCatalog' })),
+        itemOffered: { typeOf: chevre.factory.product.ProductType.EventService }
+    };
+    const saveCatalogBySubResult = await offerCatalogRepo.saveByIdentifier(savingOfferCatalogBySubCatalog);
+    console.log('saveCatalogBySubResult:', saveCatalogBySubResult);
+
+    const productIdBySubCatalog = 'sampleFreeEventServiceBySub';
+    const savingProductBySubCatalog: chevre.factory.product.IProduct & {
+        offers?: never;
+    } = {
+        project: { id: project.id, typeOf: chevre.factory.organizationType.Project },
+        typeOf: chevre.factory.product.ProductType.EventService,
+        name: { en: productIdBySubCatalog, ja: productIdBySubCatalog },
+        productID: productIdBySubCatalog,
+        hasOfferCatalog: {
+            typeOf: 'OfferCatalog',
+            itemListElement: [{ id: saveCatalogBySubResult.id }]
+        }
+    };
+    const saveProductBySubCatalogResult = await productRepo.upsertManyByProductId([{
+        $set: savingProductBySubCatalog
+    }]);
+    console.log('saveProductBySubCatalogResult:', saveProductBySubCatalogResult);
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/{searchOfferCatalogItemAvailability.ts → offers/searchAvaialbleAppliesToMovieTicketByOfferCatalogId.ts}

@@ -1,7 +1,9 @@
 // tslint:disable:no-console
 import * as mongoose from 'mongoose';
 
-import { chevre } from '../../../lib/index';
+import { chevre } from '../../../../lib/index';
+
+const formatter = new Intl.NumberFormat('ja-JP');
 
 // const PROJECT_ID = process.env.PROJECT_ID;
 mongoose.Model.on('index', (...args) => {
@@ -9,29 +11,39 @@ mongoose.Model.on('index', (...args) => {
 });
 
 async function main() {
+    let startTime: [number, number] = process.hrtime();
+    let diff: [number, number] = process.hrtime(startTime);
+    let result: any;
+
     await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
 
     const eventRepo = await chevre.repository.Event.createInstance(mongoose.connection);
+    const eventSeriesRepo = await chevre.repository.EventSeries.createInstance(mongoose.connection);
     const offerRepo = await chevre.repository.Offer.createInstance(mongoose.connection);
     const offerCatalogRepo = await chevre.repository.OfferCatalog.createInstance(mongoose.connection);
     const productRepo = await chevre.repository.Product.createInstance(mongoose.connection);
 
-    const result = await (await chevre.service.offer.createService()).event.searchOfferCatalogItemAvailability({
+    startTime = process.hrtime();
+    result = await (await chevre.service.offer.createService()).event.searchOfferAppliesToMovieTicket({
         event: {
-            id: 'bm0f0cadh'
+            id: 'cm8dwc74k'
         },
         limit: 10,
         page: 1,
-        availableAtOrFrom: { id: '3eo6okferrsdpfd9j2ce1iv9k7' },
-        options: { considerUnacceptedPaymentMethod: true }
+        store: { id: '51qbjcfr72h62m06vtv5kkhgje' },
+        onlyValid: true,
+        options: { useIncludeInDataCatalog: false }
     })({
         event: eventRepo,
+        eventSeries: eventSeriesRepo,
         offer: offerRepo,
         offerCatalog: offerCatalogRepo,
         product: productRepo
     });
+    diff = process.hrtime(startTime);
     console.log(result);
     console.log(result.length);
+    console.log('diff:', [diff[0], formatter.format(diff[1])]);
 }
 
 main()

package/example/src/chevre/offers/searchOfferCatalogItemAvailability.ts

@@ -0,0 +1,68 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../../lib/index';
+
+const formatter = new Intl.NumberFormat('ja-JP');
+
+// const PROJECT_ID = process.env.PROJECT_ID;
+mongoose.Model.on('index', (...args) => {
+    console.error('******** index event emitted. ********\n', args);
+});
+
+async function main() {
+    let startTime: [number, number] = process.hrtime();
+    let diff: [number, number] = process.hrtime(startTime);
+    let result: any;
+
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const eventRepo = await chevre.repository.Event.createInstance(mongoose.connection);
+    const offerRepo = await chevre.repository.Offer.createInstance(mongoose.connection);
+    const offerCatalogRepo = await chevre.repository.OfferCatalog.createInstance(mongoose.connection);
+    const productRepo = await chevre.repository.Product.createInstance(mongoose.connection);
+
+    // startTime = process.hrtime();
+    // result = await (await chevre.service.offer.createService()).event.searchOfferCatalogItemAvailability({
+    //     event: {
+    //         id: 'cm8dwc74j'
+    //     },
+    //     limit: 10,
+    //     page: 1,
+    //     availableAtOrFrom: { id: '51qbjcfr72h62m06vtv5kkhgje' },
+    //     options: { considerUnacceptedPaymentMethod: true, useIncludeInDataCatalog: true }
+    // })({
+    //     event: eventRepo,
+    //     offer: offerRepo,
+    //     offerCatalog: offerCatalogRepo,
+    //     product: productRepo
+    // });
+    // diff = process.hrtime(startTime);
+    // console.log(result);
+    // console.log(result.length);
+    // console.log('diff:', [diff[0], formatter.format(diff[1])]);
+
+    startTime = process.hrtime();
+    result = await (await chevre.service.offer.createService()).event.searchOfferCatalogItemAvailability({
+        event: {
+            id: 'cm8dwc74j'
+        },
+        limit: 10,
+        page: 1,
+        availableAtOrFrom: { id: '51qbjcfr72h62m06vtv5kkhgje' },
+        options: { considerUnacceptedPaymentMethod: true, useIncludeInDataCatalog: false }
+    })({
+        event: eventRepo,
+        offer: offerRepo,
+        offerCatalog: offerCatalogRepo,
+        product: productRepo
+    });
+    diff = process.hrtime(startTime);
+    console.log(result);
+    console.log(result.length);
+    console.log('diff:', [diff[0], formatter.format(diff[1])]);
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/lib/chevre/repo/mongoose/schemas/note.js

@@ -84,27 +84,27 @@ const indexes = [
     [
         { identifier: 1, dateCreated: -1 },
         { name: 'identifier' }
-    ],
-    // tslint:disable-next-line:no-suspicious-comment
-    [
-        { identifier: 1 },
-        { name: 'searchByIdentifier' }
-    ],
-    // tslint:disable-next-line:no-suspicious-comment
-    [
-        { 'project.id': 1, identifier: 1 },
-        { name: 'searchByProjectId' }
-    ],
-    // tslint:disable-next-line:no-suspicious-comment
-    [
-        { 'provider.id': 1, identifier: 1 },
-        { name: 'searchByProviderId' }
-    ],
-    // tslint:disable-next-line:no-suspicious-comment
-    [
-        { 'about.id': 1, identifier: 1 },
-        { name: 'searchByAboutId' }
     ]
+    // discontinue(2025-05-08~)
+    // [
+    //     { identifier: 1 },
+    //     { name: 'searchByIdentifier' }
+    // ],
+    // discontinue(2025-05-08~)
+    // [
+    //     { 'project.id': 1, identifier: 1 },
+    //     { name: 'searchByProjectId' }
+    // ],
+    // discontinue(2025-05-08~)
+    // [
+    //     { 'provider.id': 1, identifier: 1 },
+    //     { name: 'searchByProviderId' }
+    // ],
+    // discontinue(2025-05-08~)
+    // [
+    //     { 'about.id': 1, identifier: 1 },
+    //     { name: 'searchByAboutId' }
+    // ]
 ];
 exports.indexes = indexes;
 /**

package/lib/chevre/repo/offer/unitPriceInCatalog.d.ts

@@ -92,9 +92,10 @@ export declare class OfferRepo implements OfferInCatalogReadOnlyRepo {
     searchAvaialbleAppliesToMovieTicketByOfferCatalogId(params: {
         subOfferCatalog: {
             /**
-             * サブカタログID
+             * カタログID or サブカタログID
              */
             id: string;
+            isOfferCatalogItem: boolean;
         };
         availableAtOrFrom?: {
             id?: string;
@@ -104,6 +105,7 @@ export declare class OfferRepo implements OfferInCatalogReadOnlyRepo {
         onlyValid?: boolean;
         limit?: number;
         page?: number;
+        useIncludeInDataCatalog: boolean;
     }): Promise<Pick<factory.priceSpecification.unitPrice.IAppliesToMovieTicket, 'serviceOutput'>[]>;
     /**
      * クライアントの利用可能カタログを検索する
@@ -122,6 +124,21 @@ export declare class OfferRepo implements OfferInCatalogReadOnlyRepo {
     }): Promise<{
         id: string;
     }[]>;
+    /**
+     * サブカタログがクライアントで利用可能かどうか
+     */
+    isCatalogAvailable(params: {
+        includedInDataCatalog: {
+            /**
+             * サブカタログID
+             */
+            id: string;
+        };
+        availableAtOrFrom: {
+            id: string;
+        };
+        unacceptedPaymentMethod: string[];
+    }): Promise<boolean>;
     count(params: Omit<factory.unitPriceOffer.ISearchConditions, 'limit' | 'page' | 'sort'>): Promise<number>;
     search(params: factory.unitPriceOffer.ISearchConditions, projection?: IProjection): Promise<IOfferInCatalog[]>;
     /**

package/lib/chevre/repo/offer/unitPriceInCatalog.js

@@ -226,20 +226,31 @@ class OfferRepo {
      */
     searchAvaialbleAppliesToMovieTicketByOfferCatalogId(params) {
         return __awaiter(this, void 0, void 0, function* () {
-            // let sortedOfferIds: string[] = [];
-            // if (!params.useIncludeInDataCatalog) {
-            //     // useIncludeInDataCatalogでない場合のみ集計オファーIDリストを検索する
-            //     sortedOfferIds = await this.searchAggregateOfferIdsBySubOfferCatalog({
-            //         id: params.subOfferCatalog.id,
-            //         isOfferCatalogItem: params.subOfferCatalog.isOfferCatalogItem
-            //     });
-            // }
             var _a;
-            const searchOffersConditions = Object.assign(Object.assign({ 
-                // ...(params.useIncludeInDataCatalog)
-                //     ? { includedInDataCatalog: { id: { $in: [params.subOfferCatalog.id] } } }
-                //     : { parentOffer: { id: { $in: sortedOfferIds } } },
-                includedInDataCatalog: { id: { $in: [params.subOfferCatalog.id] } } }, (typeof ((_a = params.availableAtOrFrom) === null || _a === void 0 ? void 0 : _a.id) === 'string')
+            const { useIncludeInDataCatalog } = params;
+            // カタログのみ対応でよい?
+            let offerIds;
+            if (!useIncludeInDataCatalog) {
+                if (params.subOfferCatalog.isOfferCatalogItem) {
+                    const offerCatalog = yield this.offerCatalogItemModel.findOne({ _id: { $eq: params.subOfferCatalog.id } }, { _id: 0, itemListElement: 1 })
+                        .lean()
+                        .exec();
+                    offerIds = offerCatalog === null || offerCatalog === void 0 ? void 0 : offerCatalog.itemListElement.map(({ id }) => id);
+                }
+                else {
+                    const offerCatalog = yield this.offerCatalogModel.findOne({ _id: { $eq: params.subOfferCatalog.id } }, { _id: 0, itemListElement: 1 })
+                        .lean()
+                        .exec();
+                    offerIds = offerCatalog === null || offerCatalog === void 0 ? void 0 : offerCatalog.itemListElement.map(({ id }) => id);
+                }
+                if (!Array.isArray(offerIds) || offerIds.length === 0) {
+                    return [];
+                }
+            }
+            // support useIncludeInDataCatalog(2025-05-08~)
+            const searchOffersConditions = Object.assign(Object.assign(Object.assign({}, (Array.isArray(offerIds))
+                ? { parentOffer: { id: { $in: offerIds } } }
+                : { includedInDataCatalog: { id: { $in: [params.subOfferCatalog.id] } } }), (typeof ((_a = params.availableAtOrFrom) === null || _a === void 0 ? void 0 : _a.id) === 'string')
                 ? { availableAtOrFrom: { id: { $eq: params.availableAtOrFrom.id } } }
                 : undefined), { priceSpecification: {
                     appliesToMovieTicket: Object.assign({ 
@@ -308,6 +319,36 @@ class OfferRepo {
             return aggregate.exec();
         });
     }
+    /**
+     * サブカタログがクライアントで利用可能かどうか
+     */
+    isCatalogAvailable(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { unacceptedPaymentMethod } = params;
+            // サブカタログのみ対応でよい
+            const offerCatalogItem = yield this.offerCatalogItemModel.findOne({ _id: { $eq: params.includedInDataCatalog.id } }, { _id: 0, itemListElement: 1 })
+                .lean()
+                .exec();
+            const offerIds = offerCatalogItem === null || offerCatalogItem === void 0 ? void 0 : offerCatalogItem.itemListElement.map(({ id }) => id);
+            if (!Array.isArray(offerIds) || offerIds.length === 0) {
+                return false;
+            }
+            const doc = yield this.aggregateOfferModel.findOne(Object.assign({ 
+                // 'project.id': { $eq: params.project.id },
+                _id: { $in: offerIds }, 'offers.availableAtOrFrom.id': { $exists: true, $eq: params.availableAtOrFrom.id } }, (Array.isArray(unacceptedPaymentMethod) && unacceptedPaymentMethod.length > 0)
+                ? {
+                    'offers.priceSpecification.appliesToMovieTicket.serviceOutput.typeOf': {
+                        $nin: unacceptedPaymentMethod
+                    }
+                }
+                : undefined), {
+                _id: 1
+            })
+                .lean()
+                .exec();
+            return doc !== null;
+        });
+    }
     count(params) {
         return __awaiter(this, void 0, void 0, function* () {
             const matchStages = aggregateOffer_1.AggregateOfferRepo.CREATE_MATCH_STAGE(params);

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

@@ -86,6 +86,15 @@ export declare class PendingReservationRepo implements AbstractStockHolderRepo {
             $eq: string;
         };
     }): Promise<IProjectSubReservationResult[]>;
+    /**
+     * expiresを最新の情報に同期する
+     */
+    syncEvent2expires(params: {
+        expires: Date;
+        reservationFor: {
+            id: string;
+        };
+    }): Promise<import("mongoose").UpdateWriteOpResult>;
     private aggregateNumSeats;
     private createReservationPackageIfPossible;
     private deleteReservationPackage;

package/lib/chevre/repo/pendingReservation.js

@@ -468,6 +468,24 @@ class PendingReservationRepo {
                 .exec();
         });
     }
+    /**
+     * expiresを最新の情報に同期する
+     */
+    syncEvent2expires(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { expires, reservationFor } = params;
+            if (!(expires instanceof Date)) {
+                throw new factory.errors.Argument('expires', 'must be Date');
+            }
+            return this.pendingReservationModel.updateMany({
+                'reservationFor.id': { $eq: reservationFor.id },
+                numSeats: { $gte: 1 } // numSeats:0についてはもはや不要なドキュメントなので除外
+            }, {
+                $set: { expires }
+            })
+                .exec();
+        });
+    }
     aggregateNumSeats(params) {
         return __awaiter(this, void 0, void 0, function* () {
             const { bookingTime, dateCreated, reservationFor, limit } = params;

package/lib/chevre/service/event.js

@@ -859,9 +859,7 @@ function createScreeningRoomFromCOA(project, seller, screenFromCOA) {
     };
 }
 function updateEvent4ttts(params) {
-    return (repos
-    // settings: Settings
-    ) => __awaiter(this, void 0, void 0, function* () {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
         const actionAttributes = Object.assign({ project: { typeOf: factory.organizationType.Project, id: params.project.id }, typeOf: factory.actionType.UpdateAction, agent: params.agent, object: {
                 id: params.oldEventId,
                 typeOf: factory.eventType.ScreeningEvent
@@ -899,7 +897,7 @@ function updateEvent4ttts(params) {
             isNew: false,
             useInform: true
         })(repos
-        // settings
+        // スケジュールによるイベント作成ではendDateに変更がないのでpendingReservationsへの同期はひとまず必要なし
         );
     });
 }

package/lib/chevre/service/offer/event/searchOfferAppliesToMovieTicket.d.ts

@@ -28,6 +28,9 @@ declare function searchOfferAppliesToMovieTicket(params: {
      * 有効なオファーのみ対象とするか
      */
     onlyValid?: boolean;
+    options: {
+        useIncludeInDataCatalog: boolean;
+    };
 }): (repos: {
     event: EventRepo;
     eventSeries: EventSeriesRepo;

package/lib/chevre/service/offer/event/searchOfferAppliesToMovieTicket.js

@@ -75,22 +75,21 @@ function searchOfferAppliesToMovieTicket(params) {
         }
         // サブカタログIDを決定
         let subOfferCatalogId = catalogId;
-        // let isOfferCatalogItem: boolean = false;
+        let isOfferCatalogItem = false;
         const offerCatalogFirstElement = yield repos.offerCatalog.findFirstItemListElementById({ id: catalogId });
         if (offerCatalogFirstElement.typeOf === 'OfferCatalog') {
             subOfferCatalogId = offerCatalogFirstElement.id;
-            // isOfferCatalogItem = true;
+            isOfferCatalogItem = true;
         }
         return repos.offer.searchAvaialbleAppliesToMovieTicketByOfferCatalogId({
-            // subOfferCatalog: { id: subOfferCatalogId, isOfferCatalogItem },
-            subOfferCatalog: { id: subOfferCatalogId },
+            subOfferCatalog: { id: subOfferCatalogId, isOfferCatalogItem },
             availableAtOrFrom: { id: (_d = params.store) === null || _d === void 0 ? void 0 : _d.id },
             unacceptedPaymentMethod: unacceptedPaymentMethod,
             excludeAppliesToMovieTicket: excludeAppliesToMovieTicket,
             onlyValid: params.onlyValid === true,
-            // useIncludeInDataCatalog: params.useIncludeInDataCatalog,
             limit: params.limit,
-            page: params.page
+            page: params.page,
+            useIncludeInDataCatalog: params.options.useIncludeInDataCatalog
         });
     });
 }

package/lib/chevre/service/offer/event/searchOfferCatalogItemAvailability.d.ts

@@ -38,6 +38,7 @@ declare function searchOfferCatalogItemAvailability(params: {
              */
             id: string;
         };
+        useIncludeInDataCatalog: boolean;
     };
 }): (repos: {
     event: EventRepo;

package/lib/chevre/service/offer/event/searchOfferCatalogItemAvailability.js

@@ -21,20 +21,26 @@ function getUnacceptedPaymentMethodByEvent(params) {
     }
     return unacceptedPaymentMethod;
 }
+const MAX_LIMIT_SEARCH_OFFER_CATALOG_ITEMS = 10;
 /**
  * サブカタログ利用可能性検索
  */
 // tslint:disable-next-line:max-func-body-length
 function searchOfferCatalogItemAvailability(params) {
+    // tslint:disable-next-line:max-func-body-length
     return (repos) => __awaiter(this, void 0, void 0, function* () {
         var _a, _b, _c, _d;
-        const { considerUnacceptedPaymentMethod } = params.options;
+        const { considerUnacceptedPaymentMethod, useIncludeInDataCatalog } = params.options;
         if (typeof params.limit !== 'number') {
             throw new factory.errors.Argument('limit', 'must be number');
         }
         if (typeof params.page !== 'number') {
             throw new factory.errors.Argument('page', 'must be number');
         }
+        // オファー検索時の_id条件がitemListElementCount * MAX_LIMIT_SEARCH_OFFER_CATALOG_ITEMS以下になるように制限
+        if (params.limit > MAX_LIMIT_SEARCH_OFFER_CATALOG_ITEMS) {
+            throw new factory.errors.Argument('limit', `must be <=${MAX_LIMIT_SEARCH_OFFER_CATALOG_ITEMS}`);
+        }
         let availabilities = [];
         // optimize(2024-07-18~)
         const event = yield repos.event.projectEventFieldsById({ id: params.event.id }, ['project', 'offers.itemOffered.id', 'offers.unacceptedPaymentMethod']);
@@ -85,19 +91,34 @@ function searchOfferCatalogItemAvailability(params) {
             });
             const unacceptedPaymentMethod = getUnacceptedPaymentMethodByEvent({ event });
             if (catalogItemListElements.length > 0) {
-                // 単価オファーから利用可能なサブカタログを検索
-                const availableCatalogs = yield repos.offer.searchAvailableCatalogs({
-                    project: { id: event.project.id },
-                    includedInDataCatalog: { id: catalogItemListElements.map((element) => element.id) },
-                    availableAtOrFrom: { id: params.availableAtOrFrom.id },
-                    unacceptedPaymentMethod: (considerUnacceptedPaymentMethod) ? unacceptedPaymentMethod : []
-                });
-                availabilities = catalogItemListElements.map((element) => {
-                    return {
-                        id: element.id,
-                        isAvailable: availableCatalogs.some((item) => item.id === element.id)
-                    };
-                });
+                if (useIncludeInDataCatalog) {
+                    // 単価オファーから利用可能なサブカタログを検索
+                    const availableCatalogs = yield repos.offer.searchAvailableCatalogs({
+                        project: { id: event.project.id },
+                        includedInDataCatalog: { id: catalogItemListElements.map((element) => element.id) },
+                        availableAtOrFrom: { id: params.availableAtOrFrom.id },
+                        unacceptedPaymentMethod: (considerUnacceptedPaymentMethod) ? unacceptedPaymentMethod : []
+                    });
+                    availabilities = catalogItemListElements.map((element) => {
+                        return {
+                            id: element.id,
+                            isAvailable: availableCatalogs.some((item) => item.id === element.id)
+                        };
+                    });
+                }
+                else {
+                    // support no dependency on includedInDataCatalog(2025-05-07~)
+                    for (const element of catalogItemListElements) {
+                        availabilities.push({
+                            id: element.id,
+                            isAvailable: yield repos.offer.isCatalogAvailable({
+                                includedInDataCatalog: { id: element.id },
+                                availableAtOrFrom: { id: params.availableAtOrFrom.id },
+                                unacceptedPaymentMethod: (considerUnacceptedPaymentMethod) ? unacceptedPaymentMethod : []
+                            })
+                        });
+                    }
+                }
             }
         }
         else {

package/lib/chevre/service/offer/onEventChanged.d.ts

@@ -1,5 +1,6 @@
 import type { EventRepo } from '../../repo/event';
 import type { EventSeriesRepo } from '../../repo/eventSeries';
+import type { PendingReservationRepo } from '../../repo/pendingReservation';
 import type { ProjectRepo } from '../../repo/project';
 import type { SettingRepo } from '../../repo/setting';
 import type { TaskRepo } from '../../repo/task';
@@ -10,6 +11,7 @@ import * as factory from '../../factory';
 declare function onEventChanged(params: factory.task.onEventChanged.IData): (repos: {
     event: EventRepo;
     eventSeries: EventSeriesRepo;
+    pendingReservation?: PendingReservationRepo;
     project: ProjectRepo;
     setting: SettingRepo;
     task: TaskRepo;

package/lib/chevre/service/offer/onEventChanged.js

@@ -10,7 +10,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.onEventChanged = onEventChanged;
+const createDebug = require("debug");
+const moment = require("moment");
 const factory = require("../../factory");
+const debug = createDebug('chevre-domain:service:offer:onEventChanged');
 /**
  * イベント変更時処理
  */
@@ -49,6 +52,19 @@ function onEventChanged(params) {
                     // no op
                 }
             }
+            if (params.typeOf === factory.eventType.Event || params.typeOf === factory.eventType.ScreeningEvent) {
+                if (repos.pendingReservation !== undefined) {
+                    // sync pendingReservations.expires(2025-05-08~)
+                    yield syncEventEndDate2pendingReservations({
+                        ids: params.id,
+                        typeOf: params.typeOf
+                    })({
+                        event: repos.event,
+                        pendingReservation: repos.pendingReservation,
+                        setting: repos.setting
+                    });
+                }
+            }
         }
     });
 }
@@ -263,3 +279,33 @@ function createInform2aggTasks(params, setting) {
         }
     });
 }
+function syncEventEndDate2pendingReservations(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        const setting = yield repos.setting.findOne({ project: { id: { $eq: '*' } } }, ['storage']);
+        const stockHoldAfterEventEndInDays = (_a = setting === null || setting === void 0 ? void 0 : setting.storage) === null || _a === void 0 ? void 0 : _a.stockHoldAfterEventEndInDays;
+        if (typeof stockHoldAfterEventEndInDays !== 'number') {
+            throw new factory.errors.NotFound('setting.storage.stockHoldAfterEventEndInDays');
+        }
+        for (const eventId of params.ids) {
+            const events = yield repos.event.projectEventFields({
+                limit: 1,
+                page: 1,
+                id: { $eq: eventId },
+                typeOf: params.typeOf
+            }, ['endDate']);
+            const endDate = (_b = events.shift()) === null || _b === void 0 ? void 0 : _b.endDate;
+            if (endDate instanceof Date) {
+                const expires = moment(endDate)
+                    .add(stockHoldAfterEventEndInDays, 'days')
+                    .toDate();
+                debug('syncEvent2expires processing...', eventId, endDate, expires);
+                const syncResult = yield repos.pendingReservation.syncEvent2expires({
+                    expires,
+                    reservationFor: { id: eventId }
+                });
+                debug('syncEvent2expires processed.', syncResult);
+            }
+        }
+    });
+}

package/lib/chevre/service/task/onEventChanged.js

@@ -12,6 +12,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.call = call;
 const event_1 = require("../../repo/event");
 const eventSeries_1 = require("../../repo/eventSeries");
+const pendingReservation_1 = require("../../repo/pendingReservation");
 const project_1 = require("../../repo/project");
 const setting_1 = require("../../repo/setting");
 const task_1 = require("../../repo/task");
@@ -24,11 +25,10 @@ function call(data) {
         yield (0, onEventChanged_1.onEventChanged)(data)({
             event: new event_1.EventRepo(connection),
             eventSeries: new eventSeries_1.EventSeriesRepo(connection),
+            pendingReservation: new pendingReservation_1.PendingReservationRepo(connection),
             project: new project_1.ProjectRepo(connection),
             setting: new setting_1.SettingRepo(connection),
             task: new task_1.TaskRepo(connection)
-        }
-        // settings
-        );
+        });
     });
 }

package/package.json

@@ -113,5 +113,5 @@
     "postversion": "git push origin --tags",
     "prepublishOnly": "npm run clean && npm run build && npm test && npm run doc"
   },
-  "version": "22.9.0-alpha.116"
+  "version": "22.9.0-alpha.118"
 }