@chevre/domain 23.0.0-alpha.15 → 23.0.0-alpha.18

package/example/src/chevre/assetTransaction/processReserve.ts

@@ -6,8 +6,16 @@ import * as redis from 'redis';
 import { chevre } from '../../../../lib/index';
 
 const project = { id: String(process.env.PROJECT_ID) };
+const { EVENT_ID, OFFER_ID, APPLICATION_ID, OFFER_TOKEN } = process.env;
 
+// tslint:disable-next-line:max-func-body-length
 async function main() {
+    if (typeof EVENT_ID !== 'string'
+        || typeof OFFER_ID !== 'string'
+        || typeof APPLICATION_ID !== 'string') {
+        throw new Error('environment variables required');
+    }
+
     const redisClient = redis.createClient<redis.RedisDefaultModules, Record<string, never>, Record<string, never>>({
         socket: {
             port: Number(<string>process.env.REDIS_PORT),
@@ -21,59 +29,113 @@ async function main() {
     const transactionNumberRepo = await chevre.repository.TransactionNumber.createInstance({
         connection: mongoose.connection
     });
-    const assetTransactionRepo = await chevre.repository.AssetTransaction.createInstance(mongoose.connection);
-
     const { transactionNumber } = await transactionNumberRepo.publishByTimestamp({ startDate: new Date() });
     const provider: chevre.factory.reservation.IProvider = {
         id: '59d20831e53ebc2b4e774466',
         typeOf: chevre.factory.organizationType.Corporation
     };
-    const reserveTransaction = await assetTransactionRepo.start<chevre.factory.assetTransactionType.Reserve>({
-        project: { id: project.id, typeOf: chevre.factory.organizationType.Project },
-        typeOf: chevre.factory.assetTransactionType.Reserve,
-        transactionNumber,
-        agent: { ...provider, name: 'sample agent name' },
-        object: {
-            provider,
-            reservationNumber: transactionNumber,
-            reservationStatus: chevre.factory.reservationStatusType.ReservationPending,
-            disablePendingReservations: true,
-            useHoldStockByTransactionNumber: true,
-            typeOf: chevre.factory.reservationType.ReservationPackage
-        },
-        expires: moment()
-            .add(1, 'minute')
-            .toDate()
-    });
-    let cancelResult = await assetTransactionRepo.cancel<chevre.factory.assetTransactionType.Reserve>({
-        typeOf: reserveTransaction.typeOf,
-        id: reserveTransaction.id
-    });
-    console.log('cancelResult:', cancelResult);
-    cancelResult = await assetTransactionRepo.cancel<chevre.factory.assetTransactionType.Reserve>({
-        typeOf: reserveTransaction.typeOf,
-        id: reserveTransaction.id
-    });
-    console.log('cancelResult:', cancelResult);
 
-    let transaction = await assetTransactionRepo.findById<chevre.factory.assetTransactionType.Reserve>(
+    const { transaction } = await (await chevre.service.assetTransaction.createService()).reserve.start(
         {
+            project: { id: project.id, typeOf: chevre.factory.organizationType.Project },
             typeOf: chevre.factory.assetTransactionType.Reserve,
-            id: reserveTransaction.id
+            transactionNumber,
+            agent: { ...provider, name: 'sample agent name' },
+            object: {
+                acceptedOffer: [{
+                    /**
+                     * オファーID
+                     */
+                    id: OFFER_ID,
+                    /**
+                     * アイテム情報
+                     * 予約の詳細指定など
+                     */
+                    itemOffered: {
+                        serviceOutput: {
+                            typeOf: chevre.factory.reservationType.EventReservation,
+                            reservedTicket: {
+                                /**
+                                 * チケット識別子
+                                 * 指定された場合、決済カードの対象チケット識別子と関連付けされます
+                                 * /^[0-9a-zA-Z]{8,16}$/
+                                 */
+                                // identifier?: string;
+                                // issuedBy?: ReservationFactory.IUnderName;
+                                typeOf: 'Ticket',
+                                ticketedSeat: {
+                                    typeOf: chevre.factory.placeType.Seat,
+                                    seatNumber: 'A-01',
+                                    seatRow: '',
+                                    seatSection: 'Default'
+                                }
+                            }
+                        }
+                    }
+                }],
+                reservationFor: {
+                    id: EVENT_ID,
+                    offers: {
+                        token: OFFER_TOKEN,
+                        identifier: 'LegacyReservation'
+                    }
+                }
+            },
+            expires: moment()
+                // tslint:disable-next-line:no-magic-numbers
+                .add(5, 'seconds')
+                .toDate(),
+            validateEvent: false,
+            validateEventOfferPeriod: true,
+            validateAppliesToMovieTicket: true,
+            instrument: [],
+            availableAtOrFrom: { id: APPLICATION_ID }
+            // stockHoldUntilDaysAfterEventEnd: STOCK_HOLD_UNTIL_DAYS_AFTER_EVENT_END
         },
-        ['status', 'transactionNumber', 'project', 'typeOf']
-    );
-    console.log('transaction:', transaction);
-
-    transaction = await assetTransactionRepo.findByTransactionNumber<chevre.factory.assetTransactionType.Reserve>(
+        { maxReservationGracePeriodInDays: 93 }
+    )(
         {
-            typeOf: chevre.factory.assetTransactionType.Reserve,
-            transactionNumber
+            advanceBookingRequirement: await chevre.repository.AdvanceBookingRequirement.createInstance(mongoose.connection),
+            project: await chevre.repository.Project.createInstance(mongoose.connection),
+            stockHolder: await chevre.repository.StockHolder.createInstance({ connection: mongoose.connection }),
+            event: await chevre.repository.Event.createInstance(mongoose.connection),
+            eventSeries: await chevre.repository.EventSeries.createInstance(mongoose.connection),
+            issuer: await chevre.repository.Issuer.createInstance(mongoose.connection),
+            memberProgram: await chevre.repository.MemberProgram.createInstance(mongoose.connection),
+            offer: await chevre.repository.Offer.createInstance(mongoose.connection),
+            offerCatalog: await chevre.repository.OfferCatalog.createInstance(mongoose.connection),
+            offerCatalogItem: await chevre.repository.OfferCatalogItem.createInstance(mongoose.connection),
+            offerRateLimit: await chevre.repository.rateLimit.Offer.createInstance(redisClient),
+            paymentService: await chevre.repository.PaymentService.createInstance(mongoose.connection),
+            priceSpecification: await chevre.repository.PriceSpecification.createInstance(mongoose.connection),
+            product: await chevre.repository.Product.createInstance(mongoose.connection),
+            productOffer: await chevre.repository.ProductOffer.createInstance(mongoose.connection),
+            seat: await chevre.repository.place.Seat.createInstance(mongoose.connection),
+            setting: await chevre.repository.Setting.createInstance(mongoose.connection),
+            task: await chevre.repository.Task.createInstance(mongoose.connection),
+            assetTransaction: await chevre.repository.AssetTransaction.createInstance(mongoose.connection)
         },
-        ['status']
+        new chevre.settings.Settings({
+            abortedTasksWithoutReport: [],
+            numTryConfirmReserveTransaction: 10,
+            deliverOrderLimit: 1,
+            coa: { timeout: 20000 },
+            gmo: {
+                timeout: 5000,
+                timeoutBackground: 5000,
+                useFetch: true
+            },
+            movieticketReserve: {
+                timeout: 5000,
+                timeoutCheck: 5000,
+                minIntervalBetweenPayAndRefund: 1,
+                credentialsExpireInSeconds: 300
+            },
+            // useAssetTransactionSyncProcessing: process.env.USE_ASSET_TRANSACTION_SYNC_PROCESSING === '1',
+            useExperimentalFeature: false
+        })
     );
     console.log('transaction:', transaction);
-
 }
 
 main()

package/example/src/chevre/event/updateEventSellerMakesOffer.ts

@@ -0,0 +1,100 @@
+// tslint:disable:no-console
+import * as moment from 'moment';
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../../lib/index';
+
+const project = { id: String(process.env.PROJECT_ID) };
+const { EVENT_ID } = process.env;
+
+async function main() {
+    if (typeof EVENT_ID !== 'string') {
+        throw new Error('environment variables required');
+    }
+
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const eventSellerMakesOfferRepo = await chevre.repository.EventSellerMakesOffer.createInstance(mongoose.connection);
+    const availabilityEnds = moment('2025-10-26T05:20:00.000Z')
+        .toDate();
+    const availabilityStarts = moment('2025-10-23T15:00:00.000Z')
+        .toDate();
+    const validFrom = moment('2025-10-12T15:00:00.000Z')
+        .toDate();
+    const validThrough = moment('2025-10-26T05:20:00.000Z')
+        .toDate();
+    const result = await eventSellerMakesOfferRepo.updateOffersByEventId(
+        {
+            project: { id: project.id },
+            offers: [
+                {
+                    typeOf: chevre.factory.offerType.Offer,
+                    availableAtOrFrom: {
+                        id: '3eo6okferrsdpfd9j2ce1iv9k7'
+                    },
+                    availabilityEnds,
+                    availabilityStarts,
+                    validFrom,
+                    validThrough
+                },
+                {
+                    typeOf: chevre.factory.offerType.Offer,
+                    availableAtOrFrom: {
+                        id: '51qbjcfr72h62m06vtv5kkhgje'
+                    },
+                    availabilityEnds,
+                    availabilityStarts,
+                    validFrom,
+                    validThrough
+                },
+                {
+                    typeOf: chevre.factory.offerType.Offer,
+                    availableAtOrFrom: {
+                        id: '5h3gs22mu9j3ok7o63uog9o9i3'
+                    },
+                    availabilityEnds,
+                    availabilityStarts,
+                    validFrom,
+                    validThrough
+                },
+                {
+                    typeOf: chevre.factory.offerType.Offer,
+                    availableAtOrFrom: {
+                        id: '66e7p2g713675v96nrhdm975kg'
+                    },
+                    availabilityEnds,
+                    availabilityStarts,
+                    validFrom,
+                    validThrough
+                },
+                {
+                    typeOf: chevre.factory.offerType.Offer,
+                    availableAtOrFrom: {
+                        id: '7divuoimobsfgq95tp1csorjqq'
+                    },
+                    availabilityEnds,
+                    availabilityStarts,
+                    validFrom,
+                    validThrough
+                },
+                {
+                    typeOf: chevre.factory.offerType.Offer,
+                    availableAtOrFrom: {
+                        id: 'ckevmf3fueqcunnideu6artt'
+                    },
+                    availabilityEnds,
+                    availabilityStarts,
+                    validFrom,
+                    validThrough
+                }
+            ],
+            itemOffered: { id: EVENT_ID }
+        }
+    );
+    // tslint:disable-next-line:no-null-keyword
+    console.dir(result, { depth: null });
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/signPayload.ts

@@ -3,13 +3,18 @@ import * as jwt from 'jsonwebtoken';
 
 async function main(): Promise<void> {
     const payload = {
-        member: {
-            memberOf: {
-                identifier: 'bronze',
-                isTierOf: {
-                    identifier: 'DefaultMemberProgram'
-                }
-            }
+        /**
+         * アプリケーションオファーコード
+         */
+        identifier: 'LegacyReservation',
+        validFrom: '2025-10-20T00:00:00Z',
+        validThrough: '2025-10-25T00:00:00Z',
+        eligibleQuantity: { maxValue: 1 },
+        itemOffered: {
+            /**
+             * イベント識別子
+             */
+            identifier: '251025001001010900'
         }
     };
 

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

@@ -1,6 +1,5 @@
 import { AnyExpression, Connection, FilterQuery, Types } from 'mongoose';
 import * as factory from '../factory';
-type IKeyOfProjection = keyof factory.categoryCode.ICategoryCode;
 type IUnset = {
     [key in keyof Pick<factory.categoryCode.ICategoryCode, 'additionalProperty' | 'color' | 'image' | 'paymentMethod'>]?: 1;
 };
@@ -17,6 +16,8 @@ type IMovieTicketType = Pick<factory.categoryCode.ICategoryCode, 'additionalProp
         identifier: factory.categoryCode.CategorySetIdentifier.MovieTicketType;
     };
 };
+type IKeyOfProjection = keyof factory.categoryCode.ICategoryCode;
+type IKeyOfProjectionExceptMovieTicketType = keyof ICategoryCodeExceptMovieTicketType;
 /**
  * 区分リポジトリ
  */
@@ -30,9 +31,11 @@ export declare class CategoryCodeRepo {
         [field: string]: AnyExpression;
     };
     /**
-     * 集計検索(publicな属性検索が目的)
+     * 区分集計検索(publicな属性検索が目的)
      */
-    searchByAggregate(conditions: factory.categoryCode.ISearchConditions, inclusion: IKeyOfProjection[]): Promise<factory.categoryCode.ICategoryCode[]>;
+    findCategoryCodesByAggregate(conditions: factory.categoryCode.ISearchConditions, inclusion: IKeyOfProjectionExceptMovieTicketType[]): Promise<(ICategoryCodeExceptMovieTicketType & {
+        id: string;
+    })[]>;
     /**
      * 区分検索
      */

package/lib/chevre/repo/categoryCode.js

@@ -192,9 +192,9 @@ class CategoryCodeRepo {
         return projectStage;
     }
     /**
-     * 集計検索(publicな属性検索が目的)
+     * 区分集計検索(publicな属性検索が目的)
      */
-    searchByAggregate(conditions, inclusion) {
+    findCategoryCodesByAggregate(conditions, inclusion) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
             const matchStages = CategoryCodeRepo.CREATE_MONGO_CONDITIONS(conditions)
@@ -208,8 +208,6 @@ class CategoryCodeRepo {
                     : [],
                 { $project: projectStage }
             ]);
-            // tslint:disable-next-line:no-single-line-block-comment
-            /* istanbul ignore else */
             if (typeof conditions.limit === 'number' && conditions.limit > 0) {
                 const page = (typeof conditions.page === 'number' && conditions.page > 0) ? conditions.page : 1;
                 aggregate.limit(conditions.limit * page)

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

@@ -1,54 +1,21 @@
 import type { Connection } from 'mongoose';
 import * as factory from '../factory';
-type IAggregateMakesOfferResult = Pick<factory.event.screeningEvent.ISellerMakesOffer, 'availabilityEnds' | 'availabilityStarts' | 'validFrom' | 'validThrough'> & {
-    itemOffered: {
-        serviceOutput: {
-            reservationFor: {
-                /**
-                 * イベントID
-                 */
-                id: string;
-            };
-        };
-    };
-};
 /**
- * イベントの販売者makesOfferリポジトリ
+ * イベントのアプリケーションオファーリポジトリ
  */
 export declare class EventSellerMakesOfferRepo {
     private readonly eventModel;
     constructor(connection: Connection);
     /**
-     * 指定クライアントのオファーを集計する(2024-10-09~)
+     * 単一イベントのmakesOfferを更新する
      */
-    aggregateMakesOffer(conditions: {
-        limit?: number;
-        page?: number;
+    updateOffersByEventId(params: {
         project: {
-            id: {
-                $eq: string;
-            };
-        };
-        /**
-         * アプリケーション(指定必須)
-         */
-        availableAtOrFrom: {
-            id: {
-                $eq: string;
-            };
+            id: string;
         };
+        offers: factory.event.screeningEvent.ISellerMakesOffer[];
         itemOffered: {
-            serviceOutput: {
-                reservationFor: {
-                    /**
-                     * イベントID
-                     */
-                    id: {
-                        $in?: string[];
-                    };
-                };
-            };
+            id: string;
         };
-    }): Promise<IAggregateMakesOfferResult[]>;
+    }): Promise<void>;
 }
-export {};

package/lib/chevre/repo/eventSellerMakesOffer.js

@@ -11,62 +11,53 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EventSellerMakesOfferRepo = void 0;
 const factory = require("../factory");
-const settings_1 = require("../settings");
+// import { MONGO_MAX_TIME_MS } from '../settings';
 const event_1 = require("./mongoose/schemas/event");
+// type IMatchStage = PipelineStage.Match;
+// type IAggregateMakesOfferResult = Pick<
+//     factory.event.screeningEvent.ISellerMakesOffer,
+//     'availabilityEnds' | 'availabilityStarts' | 'validFrom' | 'validThrough'
+// > & {
+//     itemOffered: {
+//         serviceOutput: {
+//             reservationFor: {
+//                 /**
+//                  * イベントID
+//                  */
+//                 id: string;
+//             };
+//         };
+//     };
+// };
 /**
- * イベントの販売者makesOfferリポジトリ
+ * イベントのアプリケーションオファーリポジトリ
  */
 class EventSellerMakesOfferRepo {
     constructor(connection) {
         this.eventModel = connection.model(event_1.modelName, (0, event_1.createSchema)());
     }
     /**
-     * 指定クライアントのオファーを集計する(2024-10-09~)
+     * 単一イベントのmakesOfferを更新する
      */
-    aggregateMakesOffer(conditions) {
+    updateOffersByEventId(params) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const { availableAtOrFrom } = conditions;
-            if (typeof ((_a = availableAtOrFrom === null || availableAtOrFrom === void 0 ? void 0 : availableAtOrFrom.id) === null || _a === void 0 ? void 0 : _a.$eq) !== 'string' || availableAtOrFrom.id.$eq === '') {
-                throw new factory.errors.ArgumentNull('availableAtOrFrom.id.$eq');
-            }
-            const matchStages = [
-                { $match: { 'project.id': { $eq: conditions.project.id.$eq } } },
-                { $match: { 'offers.seller.makesOffer.availableAtOrFrom.id': { $exists: true, $eq: availableAtOrFrom.id.$eq } } }
-            ];
-            const reservationForIdIn = conditions.itemOffered.serviceOutput.reservationFor.id.$in;
-            if (Array.isArray(reservationForIdIn)) {
-                matchStages.push({ $match: { _id: { $in: reservationForIdIn } } });
-            }
-            const aggregate = this.eventModel.aggregate([
-                { $unwind: '$offers.seller.makesOffer' },
-                ...matchStages,
-                { $sort: { _id: factory.sortType.Ascending } },
-                {
-                    $project: {
-                        _id: 0,
-                        availabilityEnds: '$offers.seller.makesOffer.availabilityEnds',
-                        availabilityStarts: '$offers.seller.makesOffer.availabilityStarts',
-                        validFrom: '$offers.seller.makesOffer.validFrom',
-                        validThrough: '$offers.seller.makesOffer.validThrough',
-                        itemOffered: {
-                            serviceOutput: {
-                                reservationFor: {
-                                    id: { $toString: '$_id' }
-                                }
-                            }
-                        }
-                    }
+            const { offers, itemOffered, project } = params;
+            const updateQuery = {
+                $set: {
+                    'offers.seller.makesOffer': offers
                 }
-            ]);
-            if (typeof conditions.limit === 'number' && conditions.limit > 0) {
-                const page = (typeof conditions.page === 'number' && conditions.page > 0) ? conditions.page : 1;
-                aggregate.limit(conditions.limit * page)
-                    .skip(conditions.limit * (page - 1));
-            }
-            return aggregate
-                .option({ maxTimeMS: settings_1.MONGO_MAX_TIME_MS })
+            };
+            const updateFilter = {
+                _id: { $eq: itemOffered.id },
+                'project.id': { $eq: project.id }
+            };
+            const queryOptions = { upsert: false, new: false, projection: { _id: 1 } };
+            const doc = yield this.eventModel.findOneAndUpdate(updateFilter, updateQuery, queryOptions)
+                .lean()
                 .exec();
+            if (doc === null) {
+                throw new factory.errors.NotFound(this.eventModel.modelName);
+            }
         });
     }
 }

package/lib/chevre/service/assetTransaction/reserve/start.js

@@ -100,9 +100,9 @@ function fixEvent(params) {
             // additionalProperty, // discontinue(2024-07-20~)
             'name', 'doorTime', 'endDate', 'eventStatus',
             'location', 'startDate', 'superEvent',
-            'offers', 'maximumPhysicalAttendeeCapacity'
+            'offers', 'maximumPhysicalAttendeeCapacity',
+            'identifier' // support identifier(2025-10-24~)
             // 'coaInfo', // discontinue(2024-07-24~)
-            // 'identifier' // discontinue(2024-07-24~)
         ]);
         const offeredThroughIdentifier = (_b = event.offers.offeredThrough) === null || _b === void 0 ? void 0 : _b.identifier;
         if (offeredThroughIdentifier === factory.service.webAPI.Identifier.COA) {

package/lib/chevre/service/assetTransaction/reserve/validateStartRequest/validateIssuedOfferIfExists.d.ts

@@ -0,0 +1,15 @@
+import * as factory from '../../../../factory';
+import { IMinimizedIndividualEvent } from '../../../../factory/event';
+import type { IssuerRepo } from '../../../../repo/issuer';
+/**
+ * オファートークン検証(2025-10-21~)
+ */
+declare function validateIssuedOfferIfExists(params: {
+    event: Pick<IMinimizedIndividualEvent, 'offers' | 'id' | 'project' | 'identifier'>;
+    now: Date;
+    object: factory.assetTransaction.reserve.IObjectWithoutDetail;
+    makesOfferOnApplication: factory.event.screeningEvent.ISellerMakesOffer;
+}): (repos: {
+    issuer: IssuerRepo;
+}) => Promise<void>;
+export { validateIssuedOfferIfExists };