@chevre/domain 21.37.0-alpha.1 → 21.37.0-alpha.10

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

@@ -0,0 +1,79 @@
+// tslint:disable:no-console
+import * as moment from 'moment';
+import * as mongoose from 'mongoose';
+import * as redis from 'redis';
+
+import { chevre } from '../../../../lib/index';
+
+const project = { id: String(process.env.PROJECT_ID) };
+
+async function main() {
+    const redisClient = redis.createClient<redis.RedisDefaultModules, Record<string, never>, Record<string, never>>({
+        socket: {
+            port: Number(<string>process.env.REDIS_PORT),
+            host: <string>process.env.REDIS_HOST
+        },
+        password: <string>process.env.REDIS_KEY
+    });
+    await redisClient.connect();
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const transactionNumberRepo = await chevre.repository.TransactionNumber.createInstance(redisClient);
+    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>(
+        {
+            typeOf: chevre.factory.assetTransactionType.Reserve,
+            id: reserveTransaction.id
+        },
+        ['status', 'transactionNumber', 'project', 'typeOf']
+    );
+    console.log('transaction:', transaction);
+
+    transaction = await assetTransactionRepo.findByTransactionNumber<chevre.factory.assetTransactionType.Reserve>(
+        {
+            typeOf: chevre.factory.assetTransactionType.Reserve,
+            transactionNumber
+        },
+        ['status']
+    );
+    console.log('transaction:', transaction);
+
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

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

@@ -45,6 +45,7 @@ interface IStatus {
 export interface IAggregateReserve {
     statuses: IStatus[];
 }
+type IKeyOfProjection<T extends factory.assetTransactionType> = keyof Pick<factory.assetTransaction.ITransaction<factory.assetTransactionType>, 'agent' | 'endDate' | 'expires' | 'project' | 'startDate' | 'status' | 'typeOf' | 'transactionNumber'> | Exclude<keyof factory.assetTransaction.ITransaction<T>, 'id'>;
 /**
  * 資産取引リポジトリ
  */
@@ -56,22 +57,20 @@ export declare class MongoRepository {
      * 取引を開始する
      */
     start<T extends factory.assetTransactionType>(params: factory.assetTransaction.IStartParams<T>): Promise<factory.assetTransaction.ITransaction<T>>;
+    startWithMinimalResponse<T extends factory.assetTransactionType>(params: factory.assetTransaction.IStartParams<T>): Promise<Pick<factory.assetTransaction.ITransaction<factory.assetTransactionType>, 'id'>>;
     findById<T extends factory.assetTransactionType>(params: {
         typeOf: T;
         id: string;
-    }): Promise<factory.assetTransaction.ITransaction<T>>;
+    }, inclusion?: IKeyOfProjection<T>[]): Promise<factory.assetTransaction.ITransaction<T>>;
     findByTransactionNumber<T extends factory.assetTransactionType>(params: {
         typeOf: T;
         transactionNumber: string;
-    }): Promise<factory.assetTransaction.ITransaction<T>>;
+    }, inclusion?: IKeyOfProjection<T>[]): Promise<factory.assetTransaction.ITransaction<T>>;
     addReservations(params: {
         typeOf: factory.assetTransactionType.Reserve;
         id: string;
-        object: Pick<factory.assetTransaction.reserve.IObject, 'acceptedOffer' | 'issuedThrough' | 'reservationFor' | 'subReservation'> & {
-            issuedThrough: factory.assetTransaction.reserve.IIssuedThrough;
-            reservationFor: factory.assetTransaction.reserve.IReservationFor;
-        };
-    }): Promise<factory.assetTransaction.ITransaction<factory.assetTransactionType.Reserve>>;
+        object: Pick<factory.assetTransaction.reserve.IObject, 'acceptedOffer' | 'subReservation'>;
+    }): Promise<void>;
     /**
      * 取引を確定する
      */
@@ -147,7 +146,9 @@ export declare class MongoRepository {
         typeOf: T;
         id?: string;
         transactionNumber?: string;
-    }): Promise<factory.assetTransaction.ITransaction<T>>;
+    }): Promise<{
+        id: string;
+    }>;
     count<T extends factory.assetTransactionType>(params: factory.assetTransaction.ISearchConditions<T>): Promise<number>;
     /**
      * 取引を検索する

package/lib/chevre/repo/assetTransaction.js

@@ -299,7 +299,9 @@ class MongoRepository {
     /**
      * 取引を開始する
      */
-    start(params) {
+    start(params
+    // ): Promise<Pick<factory.assetTransaction.ITransaction<T>, 'id'>> {
+    ) {
         return __awaiter(this, void 0, void 0, function* () {
             return this.transactionModel.create(Object.assign(Object.assign({}, params), { typeOf: params.typeOf, status: factory.transactionStatusType.InProgress, startDate: new Date(), endDate: undefined, tasksExportAction: {
                     actionStatus: factory.actionStatusType.PotentialActionStatus
@@ -307,12 +309,38 @@ class MongoRepository {
                 .then((doc) => doc.toObject());
         });
     }
-    findById(params) {
+    startWithMinimalResponse(params) {
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
+            const { typeOf } = params;
+            const creatingTransaction = Object.assign(Object.assign({}, params), { typeOf, status: factory.transactionStatusType.InProgress, startDate: new Date(), 
+                // endDate: undefined,
+                tasksExportAction: {
+                    actionStatus: factory.actionStatusType.PotentialActionStatus
+                } });
+            const result = yield this.transactionModel.insertMany(creatingTransaction, { ordered: false, rawResult: true });
+            const id = (_b = (_a = result.insertedIds) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.toHexString();
+            if (typeof id !== 'string') {
+                throw new factory.errors.Internal('assetTransaction not saved');
+            }
+            return { id };
+        });
+    }
+    findById(params, inclusion) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let projection = {};
+            if (Array.isArray(inclusion) && inclusion.length > 0) {
+                inclusion.forEach((field) => {
+                    projection[field] = 1;
+                });
+            }
+            else {
+                projection = {};
+            }
             const doc = yield this.transactionModel.findOne({
-                _id: params.id,
-                typeOf: params.typeOf
-            })
+                _id: { $eq: params.id },
+                typeOf: { $eq: params.typeOf }
+            }, projection)
                 .exec();
             if (doc === null) {
                 throw new factory.errors.NotFound(this.transactionModel.modelName);
@@ -320,12 +348,21 @@ class MongoRepository {
             return doc.toObject();
         });
     }
-    findByTransactionNumber(params) {
+    findByTransactionNumber(params, inclusion) {
         return __awaiter(this, void 0, void 0, function* () {
+            let projection = {};
+            if (Array.isArray(inclusion) && inclusion.length > 0) {
+                inclusion.forEach((field) => {
+                    projection[field] = 1;
+                });
+            }
+            else {
+                projection = {};
+            }
             const doc = yield this.transactionModel.findOne({
                 transactionNumber: { $eq: params.transactionNumber },
-                typeOf: params.typeOf
-            })
+                typeOf: { $eq: params.typeOf }
+            }, projection)
                 .exec();
             if (doc === null) {
                 throw new factory.errors.NotFound(this.transactionModel.modelName);
@@ -340,16 +377,18 @@ class MongoRepository {
                 typeOf: { $eq: params.typeOf },
                 status: { $eq: factory.transactionStatusType.InProgress }
             }, {
-                'object.acceptedOffer': params.object.acceptedOffer,
-                'object.issuedThrough': params.object.issuedThrough,
-                'object.reservationFor': params.object.reservationFor,
-                'object.subReservation': params.object.subReservation
-            }, { new: true })
+                $set: {
+                    'object.acceptedOffer': params.object.acceptedOffer,
+                    // 'object.issuedThrough': params.object.issuedThrough, // start時保管へ移行(2024-07-01~)
+                    // 'object.reservationFor': params.object.reservationFor, // start時保管へ移行(2024-07-01~)
+                    'object.subReservation': params.object.subReservation
+                }
+            }, { new: false, projection: { _id: 1 } })
                 .exec();
             if (doc === null) {
                 throw new factory.errors.NotFound(this.transactionModel.modelName);
             }
-            return doc.toObject();
+            // return doc.toObject();
         });
     }
     /**
@@ -373,15 +412,15 @@ class MongoRepository {
                 .exec();
             // NotFoundであれば取引状態確認
             if (doc === null) {
-                const transaction = yield this.findById({ typeOf: params.typeOf, id: params.id });
+                const transaction = yield this.findById({ typeOf: params.typeOf, id: params.id }, ['status']);
                 if (transaction.status === factory.transactionStatusType.Confirmed) {
                     // すでに確定済の場合スルー
                 }
                 else if (transaction.status === factory.transactionStatusType.Expired) {
-                    throw new factory.errors.Argument('Transaction id', `Transaction ${transaction.typeOf} ${transaction.transactionNumber} already expired`);
+                    throw new factory.errors.Argument('Transaction id', `Transaction ${params.typeOf} ${params.id} already expired`);
                 }
                 else if (transaction.status === factory.transactionStatusType.Canceled) {
-                    throw new factory.errors.Argument('Transaction id', `Transaction ${transaction.typeOf} ${transaction.transactionNumber} already canceled`);
+                    throw new factory.errors.Argument('Transaction id', `Transaction ${params.typeOf} ${params.id} already canceled`);
                 }
                 else {
                     throw new factory.errors.NotFound(this.transactionModel.modelName);
@@ -593,26 +632,31 @@ class MongoRepository {
      */
     cancel(params) {
         return __awaiter(this, void 0, void 0, function* () {
-            const endDate = new Date();
             // 進行中ステータスの取引を中止する
             const doc = yield this.transactionModel.findOneAndUpdate(Object.assign(Object.assign(Object.assign({ typeOf: { $eq: params.typeOf } }, (typeof params.id === 'string') ? { _id: { $eq: params.id } } : undefined), (typeof params.transactionNumber === 'string')
                 ? { transactionNumber: { $eq: params.transactionNumber } }
                 : undefined), { status: { $eq: factory.transactionStatusType.InProgress } }), {
-                status: factory.transactionStatusType.Canceled,
-                endDate: endDate
-            }, { new: true })
+                $set: {
+                    status: factory.transactionStatusType.Canceled,
+                    endDate: new Date()
+                }
+            }, {
+                new: true,
+                projection: { _id: 1 }
+            })
                 .exec();
-            let transaction;
+            let result;
             // NotFoundであれば取引状態確認
             if (doc === null) {
+                let transaction;
                 if (typeof params.id === 'string') {
-                    transaction = yield this.findById({ typeOf: params.typeOf, id: params.id });
+                    transaction = yield this.findById({ typeOf: params.typeOf, id: params.id }, ['status']);
                 }
                 else if (typeof params.transactionNumber === 'string') {
                     transaction = yield this.findByTransactionNumber({
                         typeOf: params.typeOf,
                         transactionNumber: params.transactionNumber
-                    });
+                    }, ['status']);
                 }
                 else {
                     throw new factory.errors.ArgumentNull('Transaction ID or Transaction Number');
@@ -621,24 +665,25 @@ class MongoRepository {
                     // すでに中止済の場合スルー
                 }
                 else if (transaction.status === factory.transactionStatusType.Expired) {
-                    throw new factory.errors.Argument('Transaction id', `Transaction ${transaction.typeOf} ${transaction.transactionNumber} already expired`);
+                    throw new factory.errors.Argument('Transaction id', `Transaction ${params.typeOf} ${transaction.id} already expired`);
                 }
                 else if (transaction.status === factory.transactionStatusType.Confirmed) {
-                    throw new factory.errors.Argument('Transaction id', `Confirmed transaction ${transaction.typeOf} ${transaction.transactionNumber} unable to cancel`);
+                    throw new factory.errors.Argument('Transaction id', `Confirmed transaction ${params.typeOf} ${transaction.id} unable to cancel`);
                 }
                 else {
                     throw new factory.errors.NotFound(this.transactionModel.modelName);
                 }
+                result = { id: transaction.id };
             }
             else {
-                transaction = doc.toObject();
+                result = { id: doc.toObject().id };
             }
             assetTransaction_2.assetTransactionEventEmitter.emitAssetTransactionStatusChanged({
-                id: transaction.id,
+                id: result.id,
                 typeOf: params.typeOf,
                 status: factory.transactionStatusType.Canceled
             });
-            return transaction;
+            return result;
         });
     }
     count(params) {

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

@@ -226,15 +226,15 @@ const indexes = [
             }
         }
     ],
-    [
-        { 'object.acceptedOffer.itemOffered.serviceOutput.reservedTicket.ticketedSeat.seatNumber': 1, startDate: -1 },
-        {
-            name: 'searchByObjectAcceptedOfferItemOfferedServiceOutputSeatNumber',
-            partialFilterExpression: {
-                'object.acceptedOffer.itemOffered.serviceOutput.reservedTicket.ticketedSeat.seatNumber': { $exists: true }
-            }
-        }
-    ],
+    // [
+    //     { 'object.acceptedOffer.itemOffered.serviceOutput.reservedTicket.ticketedSeat.seatNumber': 1, startDate: -1 },
+    //     {
+    //         name: 'searchByObjectAcceptedOfferItemOfferedServiceOutputSeatNumber',
+    //         partialFilterExpression: {
+    //             'object.acceptedOffer.itemOffered.serviceOutput.reservedTicket.ticketedSeat.seatNumber': { $exists: true }
+    //         }
+    //     }
+    // ], // discontinue(2024-07-02~)
     [
         { 'object.orderNumber': 1, startDate: -1 },
         {

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

@@ -60,10 +60,13 @@ const schemaOptions = {
     writeConcern: writeConcern_1.writeConcern,
     strict: true,
     strictQuery: false,
-    timestamps: {
-        createdAt: 'createdAt',
-        updatedAt: 'updatedAt'
-    },
+    // discontinue(2024-07-02~)
+    // timestamps: {
+    //     createdAt: 'createdAt',
+    //     updatedAt: 'updatedAt'
+    // },
+    timestamps: false,
+    versionKey: false,
     toJSON: {
         getters: false,
         virtuals: false,

package/lib/chevre/service/assetTransaction/cancelReservation.d.ts

@@ -22,7 +22,7 @@ export declare function start(params: factory.assetTransaction.cancelReservation
     seller: {
         id?: string;
     };
-}): IStartOperation<factory.assetTransaction.cancelReservation.ITransaction>;
+}): IStartOperation<Pick<factory.assetTransaction.cancelReservation.ITransaction, 'id'>>;
 /**
  * 取引確定
  */

package/lib/chevre/service/assetTransaction/refund/potentialActions.js

@@ -50,17 +50,15 @@ function createInformPaymentActions(params) {
                     : String(transaction.agent.id),
                 url: String((_c = a.recipient) === null || _c === void 0 ? void 0 : _c.url)
             };
+            // optimize(2024-07-01~)
             return {
-                project: transaction.project,
-                typeOf: factory.actionType.InformAction,
-                agent: transaction.project,
+                // project: transaction.project,
+                // typeOf: factory.actionType.InformAction,
+                // agent: transaction.project,
                 recipient,
                 // 実際にタスクが生成される直前にactionに置き換える
-                object: {},
-                purpose: {
-                    typeOf: transaction.typeOf,
-                    id: transaction.id
-                }
+                // object: {},
+                purpose: { typeOf: transaction.typeOf, id: transaction.id }
             };
         }));
     }

package/lib/chevre/service/assetTransaction/refund.d.ts

@@ -24,7 +24,7 @@ export type IExportTasksOperation<T> = (repos: {
 /**
  * 取引開始
  */
-export declare function start(params: factory.assetTransaction.refund.IStartParamsWithoutDetail): IStartOperation<factory.assetTransaction.refund.ITransaction>;
+export declare function start(params: factory.assetTransaction.refund.IStartParamsWithoutDetail): IStartOperation<Pick<factory.assetTransaction.refund.ITransaction, 'id'>>;
 /**
  * 取引確定
  */

package/lib/chevre/service/assetTransaction/reserve/cancel.d.ts

@@ -0,0 +1,22 @@
+import type { MongoRepository as ActionRepo } from '../../../repo/action';
+import type { MongoRepository as AssetTransactionRepo } from '../../../repo/assetTransaction';
+import type { RedisRepository as OfferRateLimitRepo } from '../../../repo/rateLimit/offer';
+import type { MongoRepository as ReservationRepo } from '../../../repo/reservation';
+import type { StockHolderRepository as StockHolderRepo } from '../../../repo/stockHolder';
+import type { MongoRepository as TaskRepo } from '../../../repo/task';
+type ICancelOperation<T> = (repos: {
+    action: ActionRepo;
+    stockHolder: StockHolderRepo;
+    offerRateLimit: OfferRateLimitRepo;
+    reservation: ReservationRepo;
+    task: TaskRepo;
+    assetTransaction: AssetTransactionRepo;
+}) => Promise<T>;
+/**
+ * 取引中止
+ */
+declare function cancel(params: {
+    id?: string;
+    transactionNumber?: string;
+}): ICancelOperation<void>;
+export { cancel };

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

@@ -0,0 +1,41 @@
+"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.cancel = void 0;
+const factory = require("../../../factory");
+const cancelReservation_1 = require("../../reserve/cancelReservation");
+/**
+ * 取引中止
+ */
+function cancel(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        // まず取引状態変更
+        const { id } = yield repos.assetTransaction.cancel({
+            typeOf: factory.assetTransactionType.Reserve,
+            id: params.id,
+            transactionNumber: params.transactionNumber
+        });
+        // 本来非同期でタスクが実行されるが、同期的に仮予約取消が実行されていないと、サービス利用側が困る可能性があるので、
+        // 同期的にもcancelPendingReservationを実行しておく
+        // optimize(2024-07-01~)
+        // const cancelActionAttributes = createCancelPendingReservationAction({ transaction });
+        // if (cancelActionAttributes !== undefined) {
+        //     await cancelPendingReservation(cancelActionAttributes)(repos);
+        // }
+        yield (0, cancelReservation_1.cancelPendingReservation)({
+            purpose: {
+                id,
+                typeOf: factory.assetTransactionType.Reserve
+            }
+        })(repos);
+    });
+}
+exports.cancel = cancel;

package/lib/chevre/service/assetTransaction/reserve/confirm/factory.d.ts

@@ -0,0 +1,8 @@
+import * as factory from '../../../../factory';
+declare function createPotentialActions(params: {
+    order?: Pick<factory.order.IOrder, 'orderNumber' | 'customer' | 'typeOf'>;
+}): {
+    potentialActions: factory.assetTransaction.reserve.IPotentialActions;
+    underName?: factory.reservation.IUnderName<factory.reservationType.EventReservation>;
+};
+export { createPotentialActions };

package/lib/chevre/service/assetTransaction/reserve/confirm/factory.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPotentialActions = void 0;
+// tslint:disable-next-line:max-func-body-length
+function createPotentialActions(params) {
+    // const transaction = params.transaction;
+    // const reservationFor = transaction.object.reservationFor;
+    // if (reservationFor === undefined) {
+    //     throw new factory.errors.NotFound('transaction.object.reservationFor');
+    // }
+    var _a;
+    // discontinue(2024-07-01~)
+    // const useOptimizeReservation: boolean = !USE_OPTIMIZE_RESERVATION_EXCEPTIONS.includes(transaction.project.id);
+    // 予約アクション属性作成
+    // const pendingReservations = (Array.isArray(transaction.object.subReservation)) ? transaction.object.subReservation : [];
+    // let reserveActionAttributes: factory.action.reserve.IAttributes[] = [];
+    // let reservationPackage: factory.action.reserve.IObject | undefined;
+    let underName;
+    // purpose:Orderの指定があれば、underName,issuedByを調整(2022-05-23~)
+    if (typeof ((_a = params.order) === null || _a === void 0 ? void 0 : _a.typeOf) === 'string') {
+        const ordre2reservationUnderNameResult = ordre2reservationUnderName({ order: params.order });
+        underName = ordre2reservationUnderNameResult.underName;
+    }
+    // if (pendingReservations.length > 0) {
+    //     const moneyTransferActions: factory.action.transfer.moneyTransfer.IAttributes[] = [];
+    //     pendingReservations.forEach((reservation) => {
+    //         const acceptedOffer4reservation = transaction.object.acceptedOffer?.find(
+    //             (o) => o.itemOffered?.serviceOutput?.id === reservation.id
+    //         );
+    //         moneyTransferActions.push(...createMoneyTransferActions({
+    //             acceptedOffer: acceptedOffer4reservation,
+    //             reservation,
+    //             transaction: params.transaction,
+    //             underName
+    //         }));
+    //     });
+    //     reservationPackage = {
+    //         reservationFor: {
+    //             id: String(reservationFor.id),
+    //             typeOf: reservationFor.typeOf,
+    //             optimized: true
+    //         }, // optimize(2024-01-24~)
+    //         reservationNumber: transaction.object.reservationNumber,
+    //         reservationStatus: (typeof params.transaction.object.reservationStatus === 'string')
+    //             ? params.transaction.object.reservationStatus
+    //             : factory.reservationStatusType.ReservationPending,
+    //         typeOf: factory.reservationType.ReservationPackage
+    //     };
+    //     reserveActionAttributes = [{
+    //         project: transaction.project,
+    //         typeOf: <factory.actionType.ReserveAction>factory.actionType.ReserveAction,
+    //         object: reservationPackage,
+    //         agent: transaction.project,
+    //         potentialActions: {
+    //             moneyTransfer: moneyTransferActions
+    //         },
+    //         purpose: { typeOf: transaction.typeOf, id: transaction.id }
+    //     }];
+    // }
+    return {
+        potentialActions: {
+        // reserve: reserveActionAttributes // discontinue(2024-07-01~)
+        },
+        // reservationPackage,
+        underName
+    };
+}
+exports.createPotentialActions = createPotentialActions;
+/**
+ * 予約のunderName.identifierを決定する
+ */
+function createReservationUnderNameIdentifier(params) {
+    // 必要最低限の識別子のみ継承する(2024-03-16~)
+    let identifiersFromCustomer = (Array.isArray(params.order.customer.identifier)) ? params.order.customer.identifier : [];
+    // if (params.useOptimizeReservation) {
+    //     identifiersFromCustomer = identifiersFromCustomer.filter(({ name }) => name === 'clientId');
+    // }
+    identifiersFromCustomer = identifiersFromCustomer.filter(({ name }) => name === 'clientId');
+    return [
+        { name: 'orderNumber', value: params.order.orderNumber },
+        ...identifiersFromCustomer
+    ];
+}
+function createReservationUnderName(params) {
+    return Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ identifier: createReservationUnderNameIdentifier({ order: params.order }), name: String(params.order.customer.name), typeOf: params.order.customer.typeOf }, (typeof params.order.customer.address === 'string') ? { address: params.order.customer.address } : undefined), (typeof params.order.customer.age === 'string') ? { age: params.order.customer.age } : undefined), (typeof params.order.customer.email === 'string') ? { email: params.order.customer.email } : undefined), (typeof params.order.customer.familyName === 'string') ? { familyName: params.order.customer.familyName } : undefined), (typeof params.order.customer.gender === 'string') ? { gender: params.order.customer.gender } : undefined), (typeof params.order.customer.givenName === 'string') ? { givenName: params.order.customer.givenName } : undefined), (typeof params.order.customer.id === 'string') ? { id: params.order.customer.id } : undefined), (typeof params.order.customer.telephone === 'string') ? { telephone: params.order.customer.telephone } : undefined), (typeof params.order.customer.url === 'string') ? { url: params.order.customer.url } : undefined);
+}
+/**
+ * 注文者情報を予約者情報へ変換する
+ */
+function ordre2reservationUnderName(params) {
+    return {
+        underName: createReservationUnderName({ order: params.order })
+    };
+}

package/lib/chevre/service/assetTransaction/reserve/confirm.d.ts

@@ -0,0 +1,19 @@
+import * as factory from '../../../factory';
+import type { MongoRepository as ActionRepo } from '../../../repo/action';
+import type { MongoRepository as AssetTransactionRepo } from '../../../repo/assetTransaction';
+import type { MongoRepository as OrderRepo } from '../../../repo/order';
+import type { MongoRepository as ReservationRepo } from '../../../repo/reservation';
+import type { MongoRepository as TaskRepo } from '../../../repo/task';
+interface IConfirmRepo {
+    action: ActionRepo;
+    assetTransaction: AssetTransactionRepo;
+    order: OrderRepo;
+    reservation: ReservationRepo;
+    task: TaskRepo;
+}
+type IConfirmOperation<T> = (repos: IConfirmRepo) => Promise<T>;
+/**
+ * 取引確定
+ */
+declare function confirm(params: factory.assetTransaction.reserve.IConfirmParams): IConfirmOperation<void>;
+export { confirm };