@chevre/domain 25.2.0-alpha.2 → 25.2.0-alpha.21

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

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.call = call;
 const accountingReport_1 = require("../../repo/accountingReport");
-// import { ActionRepo } from '../../repo/action';
 const acceptPay_1 = require("../../repo/action/acceptPay");
 const authorizePaymentMethod_1 = require("../../repo/action/authorizePaymentMethod");
 const assetTransaction_1 = require("../../repo/assetTransaction");
@@ -10,8 +9,8 @@ const paymentService_1 = require("../../repo/paymentService");
 const paymentServiceProvider_1 = require("../../repo/paymentServiceProvider");
 const sellerPaymentAccepted_1 = require("../../repo/sellerPaymentAccepted");
 const task_1 = require("../../repo/task");
+const orderInTransaction_1 = require("../../repo/orderInTransaction");
 const placeOrder_1 = require("../../repo/transaction/placeOrder");
-// import { TransactionRepo } from '../../repo/transaction';
 const any_1 = require("../payment/any");
 /**
  * タスク実行関数
@@ -24,7 +23,6 @@ function call(params) {
             sameAs: { id: params.id }
         })({
             accountingReport: new accountingReport_1.AccountingReportRepo(connection),
-            // action: new ActionRepo(connection),
             acceptPayAction: new acceptPay_1.AcceptPayActionRepo(connection),
             authorizePaymentMethodAction: new authorizePaymentMethod_1.AuthorizePaymentMethodActionRepo(connection),
             assetTransaction: new assetTransaction_1.AssetTransactionRepo(connection),
@@ -32,10 +30,8 @@ function call(params) {
             paymentService: new paymentService_1.PaymentServiceRepo(connection),
             paymentServiceProvider: new paymentServiceProvider_1.PaymentServiceProviderRepo(connection),
             task: new task_1.TaskRepo(connection),
+            orderInTransaction: new orderInTransaction_1.OrderInTransactionRepo(connection),
             placeOrder: new placeOrder_1.PlaceOrderRepo(connection)
-            // transaction: new TransactionRepo(connection)
-        }
-        // settings
-        );
+        });
     };
 }

package/lib/chevre/service/transaction/deleteTransaction/deletePayTransactionsByPlaceOrder.d.ts

@@ -0,0 +1,15 @@
+import { factory } from '../../../factory';
+import type { AssetTransactionRepo } from '../../../repo/assetTransaction';
+type IAuthorizeOfferAction = factory.action.authorize.offer.eventService.IAction;
+type IAuthorizePaymentAction = factory.action.authorize.paymentMethod.any.IAction;
+export declare function deletePayTransactionsByPlaceOrder(params: {
+    authorizeActions: (IAuthorizeOfferAction | IAuthorizePaymentAction)[];
+    transaction: Pick<factory.transaction.placeOrder.ITransaction, 'project'>;
+}): (repos: {
+    assetTransaction: AssetTransactionRepo;
+}) => Promise<{
+    deletePayTransactionResult: any;
+    deleteRefundResult: any;
+    payTransactionNumbers: string[];
+}>;
+export {};

package/lib/chevre/service/transaction/deleteTransaction/deletePayTransactionsByPlaceOrder.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deletePayTransactionsByPlaceOrder = deletePayTransactionsByPlaceOrder;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const factory_1 = require("../../../factory");
+function deletePayTransactionsByPlaceOrder(params) {
+    return async (repos) => {
+        let deletePayTransactionResult;
+        let deleteRefundResult;
+        const authorizeActions = params.authorizeActions;
+        // 決済取引番号を抽出
+        const authorizePaymentActions = authorizeActions
+            .filter((a) => {
+            return a.object.typeOf === factory_1.factory.action.authorize.paymentMethod.any.ResultType.Payment
+                && typeof a.object?.paymentMethodId === 'string'
+                && a.object.paymentMethodId.length > 0;
+        });
+        const payTransactionNumbers = authorizePaymentActions.map((a) => String(a.object.paymentMethodId));
+        if (payTransactionNumbers.length > 0) {
+            // 決済取引を削除(プロジェクトでも絞ること)(2022-06-07~)
+            const deleteAssetTransactionsResult = await repos.assetTransaction.deleteByTransactionNumber({
+                project: { id: params.transaction.project.id },
+                transactionNumbers: payTransactionNumbers,
+                typeOf: factory_1.factory.assetTransactionType.Pay
+            });
+            deletePayTransactionResult = {
+                n: deleteAssetTransactionsResult?.n,
+                ok: deleteAssetTransactionsResult?.ok,
+                deletedCount: deleteAssetTransactionsResult?.deletedCount
+            };
+            // 返金取引も削除(2023-05-19~)
+            const refundTransactions = await repos.assetTransaction.search({
+                typeOf: factory_1.factory.assetTransactionType.Refund,
+                object: { paymentMethodId: { $in: payTransactionNumbers } }
+            }, ['transactionNumber'], []);
+            if (refundTransactions.length > 0) {
+                const deleteRefundAssetTransactionsResult = await repos.assetTransaction.deleteByTransactionNumber({
+                    project: { id: params.transaction.project.id },
+                    transactionNumbers: refundTransactions.map(({ transactionNumber }) => transactionNumber),
+                    typeOf: factory_1.factory.assetTransactionType.Refund
+                });
+                deleteRefundResult = {
+                    n: deleteRefundAssetTransactionsResult?.n,
+                    ok: deleteRefundAssetTransactionsResult?.ok,
+                    deletedCount: deleteRefundAssetTransactionsResult?.deletedCount
+                };
+            }
+        }
+        return { deletePayTransactionResult, deleteRefundResult, payTransactionNumbers };
+    };
+}

package/lib/chevre/service/transaction/deleteTransaction/deleteReservationsByPlaceOrder.d.ts

@@ -0,0 +1,23 @@
+import { factory } from '../../../factory';
+import type { AssetTransactionRepo } from '../../../repo/assetTransaction';
+import type { ReservationRepo } from '../../../repo/reservation';
+type IAuthorizeOfferAction = factory.action.authorize.offer.eventService.IAction;
+type IAuthorizePaymentAction = factory.action.authorize.paymentMethod.any.IAction;
+interface IDeleteResult {
+    n?: number;
+    ok?: number;
+    deletedCount?: number;
+}
+export declare function deleteReservationsByPlaceOrder(params: {
+    authorizeActions: (IAuthorizeOfferAction | IAuthorizePaymentAction)[];
+    transaction: Pick<factory.transaction.placeOrder.ITransaction, 'project'>;
+}): (repos: {
+    assetTransaction: AssetTransactionRepo;
+    reservation: ReservationRepo;
+}) => Promise<{
+    deleteResult?: IDeleteResult;
+    deleteReserveTransactionResult?: IDeleteResult;
+    deleteCancelReservationTransactionResult?: IDeleteResult;
+    reserveTransactionNumbers: string[];
+}>;
+export {};

package/lib/chevre/service/transaction/deleteTransaction/deleteReservationsByPlaceOrder.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteReservationsByPlaceOrder = deleteReservationsByPlaceOrder;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const factory_1 = require("../../../factory");
+function deleteReservationsByPlaceOrder(params) {
+    return async (repos) => {
+        let deleteResult;
+        let deleteReserveTransactionResult;
+        let deleteCancelReservationTransactionResult;
+        const authorizeActions = params.authorizeActions;
+        // 予約取引番号を抽出
+        const authorizeReservationOfferActions = authorizeActions
+            .filter((a) => {
+            return a.object.typeOf === factory_1.factory.action.authorize.offer.eventService.ObjectType.SeatReservation
+                && a.instrument?.transactionNumber === 'string'
+                && a.instrument.transactionNumber.length > 0;
+        });
+        const reserveTransactionNumbers = authorizeReservationOfferActions
+            .map((a) => String(a.instrument?.transactionNumber));
+        if (reserveTransactionNumbers.length > 0) {
+            // 該当予約番号の予約を削除する(プロジェクトでも絞ること)
+            const deleteReservationsResult = await repos.reservation.deleteByReservationNumbers({
+                project: { id: params.transaction.project.id },
+                reservationNumbers: reserveTransactionNumbers
+            });
+            deleteResult = {
+                n: deleteReservationsResult?.n,
+                ok: deleteReservationsResult?.ok,
+                deletedCount: deleteReservationsResult?.deletedCount
+            };
+            // 予約取引を削除(プロジェクトでも絞ること)(2022-06-07~)
+            const deleteAssetTransactionsResult = await repos.assetTransaction.deleteByTransactionNumber({
+                project: { id: params.transaction.project.id },
+                transactionNumbers: reserveTransactionNumbers,
+                typeOf: factory_1.factory.assetTransactionType.Reserve
+            });
+            deleteReserveTransactionResult = {
+                n: deleteAssetTransactionsResult?.n,
+                ok: deleteAssetTransactionsResult?.ok,
+                deletedCount: deleteAssetTransactionsResult?.deletedCount
+            };
+            // 予約番号で予約取消取引を検索
+            const deletingCancelReservationTransactions = await repos.assetTransaction.search({
+                project: { id: { $eq: params.transaction.project.id } },
+                object: { reservationNumber: { $in: reserveTransactionNumbers } },
+                typeOf: factory_1.factory.assetTransactionType.CancelReservation
+            }, ['transactionNumber'], []);
+            if (deletingCancelReservationTransactions.length > 0) {
+                // 予約取消取引も削除(2024-04-18~)
+                const deleteCancelReservationResult = await repos.assetTransaction.deleteByTransactionNumber({
+                    project: { id: params.transaction.project.id },
+                    transactionNumbers: deletingCancelReservationTransactions.map(({ transactionNumber }) => String(transactionNumber)),
+                    typeOf: factory_1.factory.assetTransactionType.CancelReservation
+                });
+                deleteCancelReservationTransactionResult = {
+                    n: deleteCancelReservationResult?.n,
+                    ok: deleteCancelReservationResult?.ok,
+                    deletedCount: deleteCancelReservationResult?.deletedCount
+                };
+            }
+        }
+        return { deleteResult, deleteReserveTransactionResult, deleteCancelReservationTransactionResult, reserveTransactionNumbers };
+    };
+}

package/lib/chevre/service/transaction/deleteTransaction.js

@@ -4,6 +4,8 @@ exports.deleteTransaction = deleteTransaction;
 /* eslint-disable @typescript-eslint/no-explicit-any */
 const factory_1 = require("../../factory");
 const deleteOrder_1 = require("../order/deleteOrder");
+const deletePayTransactionsByPlaceOrder_1 = require("./deleteTransaction/deletePayTransactionsByPlaceOrder");
+const deleteReservationsByPlaceOrder_1 = require("./deleteTransaction/deleteReservationsByPlaceOrder");
 /**
  * 取引に関わるリソースを削除する
  * 冪等性を確保すること
@@ -30,7 +32,6 @@ function deleteTransactionById(params) {
         if (typeof deletingTransactionId !== 'string' || deletingTransactionId.length === 0) {
             throw new factory_1.factory.errors.ArgumentNull('object.id');
         }
-        // let deletingOrderNumberByTask: string | undefined;
         let transaction;
         if (params.object.typeOf === factory_1.factory.transactionType.PlaceOrder) {
             transaction = (await repos.placeOrder.findPlaceOrderTransactions({
@@ -38,7 +39,6 @@ function deleteTransactionById(params) {
                 typeOf: params.object.typeOf,
                 inclusion: ['typeOf', 'project', 'status']
             })).shift();
-            // deletingOrderNumberByTask = params.object.object.orderNumber;
         }
         else if (params.object.typeOf === factory_1.factory.transactionType.ReturnOrder) {
             transaction = (await repos.returnOrder.findReturnOrderTransactions({
@@ -70,7 +70,7 @@ function deleteTransactionById(params) {
         let deleteCancelReservationTransactionResult;
         let deletedReservationNumbers = [];
         let deleteActionResult;
-        // let deleteMessagessResult: IDeleteResult | undefined;
+        let deleteOrderResult;
         const action = await repos.action.start(actionAttributes);
         try {
             const transactionTypeOf = transaction.typeOf;
@@ -90,12 +90,7 @@ function deleteTransactionById(params) {
                             break;
                         case factory_1.factory.transactionStatusType.Confirmed: {
                             // identifierによる削除に変更(2026-06-28~)
-                            // if (typeof deletingOrderNumberByTask === 'string') {
-                            //     await deleteOrder({
-                            //         object: { orderNumber: deletingOrderNumberByTask }
-                            //     })(repos);
-                            // }
-                            await (0, deleteOrder_1.deleteOrder)({
+                            deleteOrderResult = await (0, deleteOrder_1.deleteOrder)({
                                 object: { identifier: transaction.id }
                             })(repos);
                             break;
@@ -104,27 +99,29 @@ function deleteTransactionById(params) {
                             throw new factory_1.factory.errors.NotImplemented(`${transaction.status} not implemented`);
                     }
                     // 決済取引を削除
-                    const deletePayTransactionsByPlaceOrderResult = await deletePayTransactionsByPlaceOrder({ authorizeActions, transaction })(repos);
+                    const deletePayTransactionsByPlaceOrderResult = await (0, deletePayTransactionsByPlaceOrder_1.deletePayTransactionsByPlaceOrder)({ authorizeActions, transaction })(repos);
                     deletePayTransactionResult = deletePayTransactionsByPlaceOrderResult.deletePayTransactionResult;
                     deleteRefundResult = deletePayTransactionsByPlaceOrderResult.deleteRefundResult;
                     payTransactionNumbers = deletePayTransactionsByPlaceOrderResult.payTransactionNumbers;
                     // 取引上での予約を削除
-                    const deleteReservationsByPlaceOrderResult = await deleteReservationsByPlaceOrder({ authorizeActions, transaction })(repos);
+                    const deleteReservationsByPlaceOrderResult = await (0, deleteReservationsByPlaceOrder_1.deleteReservationsByPlaceOrder)({ authorizeActions, transaction })(repos);
                     deleteReservationsResult = deleteReservationsByPlaceOrderResult.deleteResult;
                     deleteReserveTransactionResult = deleteReservationsByPlaceOrderResult.deleteReserveTransactionResult;
                     deleteCancelReservationTransactionResult =
                         deleteReservationsByPlaceOrderResult.deleteCancelReservationTransactionResult;
                     deletedReservationNumbers = deleteReservationsByPlaceOrderResult.reserveTransactionNumbers;
                     // アクション削除(2023-05-19~)
-                    deleteActionResult = await repos.action.deleteByPurpose({
+                    deleteActionResult = await repos.action.deleteActionsByTransactionId({
                         project: { id: transaction.project.id },
-                        purpose: { id: transaction.id, typeOf: transactionTypeOf },
+                        transaction: { id: transaction.id, typeOf: transactionTypeOf },
                         typeOf: {
                             $in: [
-                                factory_1.factory.actionType.AuthorizeAction,
-                                factory_1.factory.actionType.CheckAction,
-                                factory_1.factory.actionType.InformAction,
-                                factory_1.factory.actionType.OrderAction
+                                factory_1.factory.actionType.AcceptAction, // オファー採用、決済採用
+                                factory_1.factory.actionType.AuthorizeAction, // オファー承認、決済承認
+                                factory_1.factory.actionType.CheckAction, // 決済カード認証
+                                // factory.actionType.InformAction, // 通知は特になし
+                                factory_1.factory.actionType.OrderAction, // 注文
+                                factory_1.factory.actionType.RefundAction // 決済採用返金
                             ]
                         }
                     });
@@ -166,143 +163,9 @@ function deleteTransactionById(params) {
             deleteCancelReservationTransactionResult,
             deletedReservationNumbers,
             deleteActionResult,
+            deleteOrderResult // 2026-07-10~
             // ...(deleteMessagessResult !== undefined) ? { deleteMessagessResult } : undefined
         };
         await repos.action.completeWithVoid({ typeOf: action.typeOf, id: action.id, result: actionResult });
     };
 }
-function deleteReservationsByPlaceOrder(params) {
-    return async (repos) => {
-        let deleteResult;
-        let deleteReserveTransactionResult;
-        let deleteCancelReservationTransactionResult;
-        const authorizeActions = params.authorizeActions;
-        // 予約取引番号を抽出
-        const authorizeReservationOfferActions = authorizeActions
-            .filter((a) => {
-            const pendingTransactionNumber = a.instrument?.transactionNumber;
-            return a.object.typeOf === factory_1.factory.action.authorize.offer.eventService.ObjectType.SeatReservation
-                && typeof pendingTransactionNumber === 'string'
-                && pendingTransactionNumber.length > 0;
-        });
-        const reserveTransactionNumbers = authorizeReservationOfferActions
-            .map((a) => String(a.instrument?.transactionNumber));
-        if (reserveTransactionNumbers.length > 0) {
-            // 該当予約番号の予約を削除する(プロジェクトでも絞ること)
-            const deleteReservationsResult = await repos.reservation.deleteByReservationNumbers({
-                project: { id: params.transaction.project.id },
-                reservationNumbers: reserveTransactionNumbers
-            });
-            deleteResult = {
-                n: deleteReservationsResult?.n,
-                ok: deleteReservationsResult?.ok,
-                deletedCount: deleteReservationsResult?.deletedCount
-            };
-            // 予約取引を削除(プロジェクトでも絞ること)(2022-06-07~)
-            const deleteAssetTransactionsResult = await repos.assetTransaction.deleteByTransactionNumber({
-                project: { id: params.transaction.project.id },
-                transactionNumbers: reserveTransactionNumbers,
-                typeOf: factory_1.factory.assetTransactionType.Reserve
-            });
-            deleteReserveTransactionResult = {
-                n: deleteAssetTransactionsResult?.n,
-                ok: deleteAssetTransactionsResult?.ok,
-                deletedCount: deleteAssetTransactionsResult?.deletedCount
-            };
-            // 予約番号で予約取消取引を検索
-            const deletingCancelReservationTransactions = await repos.assetTransaction.search({
-                project: { id: { $eq: params.transaction.project.id } },
-                object: { reservationNumber: { $in: reserveTransactionNumbers } },
-                typeOf: factory_1.factory.assetTransactionType.CancelReservation
-            }, ['transactionNumber'], []);
-            if (deletingCancelReservationTransactions.length > 0) {
-                // 予約取消取引も削除(2024-04-18~)
-                const deleteCancelReservationResult = await repos.assetTransaction.deleteByTransactionNumber({
-                    project: { id: params.transaction.project.id },
-                    transactionNumbers: deletingCancelReservationTransactions.map(({ transactionNumber }) => String(transactionNumber)),
-                    typeOf: factory_1.factory.assetTransactionType.CancelReservation
-                });
-                deleteCancelReservationTransactionResult = {
-                    n: deleteCancelReservationResult?.n,
-                    ok: deleteCancelReservationResult?.ok,
-                    deletedCount: deleteCancelReservationResult?.deletedCount
-                };
-            }
-        }
-        return { deleteResult, deleteReserveTransactionResult, deleteCancelReservationTransactionResult, reserveTransactionNumbers };
-    };
-}
-function deletePayTransactionsByPlaceOrder(params) {
-    return async (repos) => {
-        let deletePayTransactionResult;
-        let deleteRefundResult;
-        const authorizeActions = params.authorizeActions;
-        // 決済取引番号を抽出
-        const authorizePaymentActions = authorizeActions
-            .filter((a) => {
-            const pendingTransactionNumber = a.object?.paymentMethodId;
-            return a.object.typeOf === factory_1.factory.action.authorize.paymentMethod.any.ResultType.Payment
-                && typeof pendingTransactionNumber === 'string'
-                && pendingTransactionNumber.length > 0;
-        });
-        const payTransactionNumbers = authorizePaymentActions.map((a) => String(a.object.paymentMethodId));
-        if (payTransactionNumbers.length > 0) {
-            // 決済取引を削除(プロジェクトでも絞ること)(2022-06-07~)
-            const deleteAssetTransactionsResult = await repos.assetTransaction.deleteByTransactionNumber({
-                project: { id: params.transaction.project.id },
-                transactionNumbers: payTransactionNumbers,
-                typeOf: factory_1.factory.assetTransactionType.Pay
-            });
-            deletePayTransactionResult = {
-                n: deleteAssetTransactionsResult?.n,
-                ok: deleteAssetTransactionsResult?.ok,
-                deletedCount: deleteAssetTransactionsResult?.deletedCount
-            };
-            // 返金取引も削除(2023-05-19~)
-            const refundTransactions = await repos.assetTransaction.search({
-                typeOf: factory_1.factory.assetTransactionType.Refund,
-                object: { paymentMethodId: { $in: payTransactionNumbers } }
-            }, ['transactionNumber'], []);
-            if (refundTransactions.length > 0) {
-                const deleteRefundAssetTransactionsResult = await repos.assetTransaction.deleteByTransactionNumber({
-                    project: { id: params.transaction.project.id },
-                    transactionNumbers: refundTransactions.map(({ transactionNumber }) => transactionNumber),
-                    typeOf: factory_1.factory.assetTransactionType.Refund
-                });
-                deleteRefundResult = {
-                    n: deleteRefundAssetTransactionsResult?.n,
-                    ok: deleteRefundAssetTransactionsResult?.ok,
-                    deletedCount: deleteRefundAssetTransactionsResult?.deletedCount
-                };
-            }
-        }
-        return { deletePayTransactionResult, deleteRefundResult, payTransactionNumbers };
-    };
-}
-// function deleteMessagesByPlaceOrder(params: {
-//     transaction: factory.task.deleteTransaction.IObject;
-// }) {
-//     return async (repos: {
-//         message: MessageRepo;
-//     }): Promise<{
-//         deleteResult?: IDeleteResult;
-//     }> => {
-//         let deleteResult: IDeleteResult | undefined;
-//         if (params.transaction.typeOf === factory.transactionType.PlaceOrder
-//             && params.transaction.specifyingMethod === factory.action.update.deleteAction.ObjectAsTransactionSpecifyingMethod.Id) {
-//             const orderNumber = params.transaction.object.orderNumber;
-//             if (typeof orderNumber === 'string' && orderNumber.length > 0) {
-//                 const deleteReservationsResult = await repos.message.deleteByMainEntityOrderNumber({
-//                     project: { id: params.transaction.project.id },
-//                     mainEntity: { orderNumber }
-//                 });
-//                 deleteResult = {
-//                     n: deleteReservationsResult?.n,
-//                     ok: deleteReservationsResult?.ok,
-//                     deletedCount: deleteReservationsResult?.deletedCount
-//                 };
-//             }
-//         }
-//         return { deleteResult };
-//     };
-// }

package/lib/chevre/service/transaction/placeOrder/confirm/prepareUnitPriceOfferConditions.d.ts

@@ -0,0 +1,22 @@
+import type { OfferRepo } from '../../../../repo/offer/unitPriceInCatalog';
+import { factory } from '../../../../factory';
+export type IAuthorizeEventServiceOffer = factory.action.authorize.offer.eventService.IAction;
+type IOrderAcceptedOffer = Pick<factory.order.IAcceptedOffer, 'itemOffered' | 'offeredThrough' | 'serialNumber' | 'priceSpecification' | 'id'>;
+export declare function createAuthorizeOfferResultsExpected(params: {
+    authorizeEventServiceOfferActions: Pick<IAuthorizeEventServiceOffer, 'id' | 'result'>[];
+}): Pick<IAuthorizeEventServiceOffer, 'id' | 'result'>[];
+/**
+ * 注文ドキュメントと予約取引ドキュメントを参照することによって生成した、単価オファー検証条件
+ * 元々オファー承認アクションのresultに保管されていた
+ */
+type IPreparedUnitPriceOfferConditions = Pick<IAuthorizeEventServiceOffer, 'id' | 'result'>;
+declare function prepareUnitPriceOfferConditions(params: {
+    project: {
+        id: string;
+    };
+    acceptedOffers: IOrderAcceptedOffer[];
+    authorizeEventServiceOfferActions: IAuthorizeEventServiceOffer[];
+}): (repos: {
+    offer: OfferRepo;
+}) => Promise<IPreparedUnitPriceOfferConditions[]>;
+export { IPreparedUnitPriceOfferConditions, prepareUnitPriceOfferConditions };

package/lib/chevre/service/transaction/placeOrder/confirm/prepareUnitPriceOfferConditions.js

@@ -0,0 +1,120 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAuthorizeOfferResultsExpected = createAuthorizeOfferResultsExpected;
+exports.prepareUnitPriceOfferConditions = prepareUnitPriceOfferConditions;
+const debug_1 = __importDefault(require("debug"));
+const factory_1 = require("../../../../factory");
+const debug = (0, debug_1.default)('chevre-domain:service:transaction:placeOrder:confirm:prepareUnitPriceOfferConditions');
+function acceptedOffers2authorizeResult(params) {
+    const { acceptedOffers4result, unitPriceOffers } = params;
+    const programMembershipUsed = acceptedOffers2programMembershipUsed({ acceptedOffers: acceptedOffers4result });
+    // オファーIDごとに集計
+    const offerIds = [...new Set(acceptedOffers4result.map((o) => String(o.id)))];
+    const offers = offerIds.map((offerId) => {
+        const acceptedOffer = unitPriceOffers.find(({ id }) => id === offerId);
+        if (acceptedOffer === undefined) {
+            throw new factory_1.factory.errors.Internal(`acceptedOffer not found [id:${offerId}]`);
+        }
+        const amountOfThisGood = acceptedOffers4result.filter(({ id }) => id === offerId).length;
+        const { acceptedPaymentMethod, priceSpecification } = acceptedOffer;
+        const unitPriceSpec = priceSpecification;
+        if (unitPriceSpec === undefined) {
+            throw new factory_1.factory.errors.Internal(`unitPriceSpec not found [id:${offerId}]`);
+        }
+        const { eligibleQuantity } = unitPriceSpec;
+        return {
+            id: offerId,
+            includesObject: { amountOfThisGood },
+            typeOf: factory_1.factory.offerType.Offer,
+            priceSpecification: {
+                ...(eligibleQuantity !== undefined) ? { eligibleQuantity } : undefined,
+            },
+            ...(acceptedPaymentMethod !== undefined) ? { acceptedPaymentMethod } : undefined
+        };
+    });
+    return {
+        // amount: [], // discontinue(2026-07-06~)
+        itemOffered: {
+            serviceOutput: { programMembershipUsed } // add programMembershipUsed required(2024-08-15~)
+        },
+        offers
+    };
+}
+function acceptedOffers2programMembershipUsed(params) {
+    const programMembershipUsed = [];
+    const permitIdentifiers = [];
+    params.acceptedOffers.forEach(({ itemOffered }) => {
+        if (itemOffered.programMembershipUsed?.typeOf === factory_1.factory.programMembership.ProgramMembershipType.ProgramMembership) {
+            // メンバーシップコードに対してユニークに集計
+            if (!permitIdentifiers.includes(itemOffered.programMembershipUsed.identifier)) {
+                permitIdentifiers.push(itemOffered.programMembershipUsed.identifier);
+                const issuedThroughTypeOf = itemOffered.programMembershipUsed.issuedThrough.typeOf;
+                if (issuedThroughTypeOf === factory_1.factory.service.paymentService.PaymentServiceType.FaceToFace) {
+                    programMembershipUsed.push({
+                        typeOf: factory_1.factory.permit.PermitType.Permit,
+                        identifier: itemOffered.programMembershipUsed.identifier,
+                        issuedThrough: { typeOf: issuedThroughTypeOf }
+                    });
+                }
+                else {
+                    programMembershipUsed.push({
+                        typeOf: factory_1.factory.permit.PermitType.Permit,
+                        identifier: itemOffered.programMembershipUsed.identifier,
+                        issuedThrough: { typeOf: issuedThroughTypeOf, id: itemOffered.programMembershipUsed.issuedThrough.id }
+                    });
+                }
+            }
+        }
+    });
+    return programMembershipUsed;
+}
+function createAuthorizeOfferResultsExpected(params) {
+    return params.authorizeEventServiceOfferActions.map((a) => {
+        return {
+            id: a.id,
+            result: a.result
+        };
+    });
+}
+function prepareUnitPriceOfferConditions(params) {
+    return async (repos) => {
+        // COAの場合は単価オファーを参照せずにそのまま返す
+        const isCOA = params.authorizeEventServiceOfferActions.some((action) => action.instrument.typeOf === factory_1.factory.assetTransactionType.COAReserveTransaction);
+        if (isCOA) {
+            return params.authorizeEventServiceOfferActions.map(({ id, result }) => ({ id, result }));
+        }
+        const conditions = [];
+        const offerIds = [...new Set(params.acceptedOffers.map((o) => String(o.id)))];
+        const unitPriceOffers = await repos.offer.search({
+            id: { $in: offerIds }
+        }, {
+            acceptedPaymentMethod: 1,
+            priceSpecification: 1,
+        });
+        debug('unitPriceOffers:', unitPriceOffers);
+        for (const authorizeEventServiceOfferAction of params.authorizeEventServiceOfferActions) {
+            if (authorizeEventServiceOfferAction.result === undefined) {
+                throw new Error('authorizeEventServiceOfferAction.result should exist');
+            }
+            const acceptedOffers4action = params.acceptedOffers.filter(((offer) => {
+                return offer.serialNumber === authorizeEventServiceOfferAction.instrument.transactionNumber;
+            }));
+            conditions.push({
+                id: authorizeEventServiceOfferAction.id,
+                result: {
+                    typeOf: authorizeEventServiceOfferAction.result.typeOf,
+                    // priceCurrency: authorizeEventServiceOfferAction.result.priceCurrency,
+                    price: authorizeEventServiceOfferAction.result.price,
+                    ...acceptedOffers2authorizeResult({
+                        acceptedOffers4result: acceptedOffers4action,
+                        unitPriceOffers
+                    })
+                }
+            });
+        }
+        return conditions;
+    };
+}

package/lib/chevre/service/transaction/placeOrder/confirm/validation/factory.d.ts

@@ -1,6 +1,10 @@
 import { factory } from '../../../../../factory';
 export type IAcceptPayAction = Pick<factory.action.accept.pay.IAction, 'object' | 'result' | 'endDate'>;
-export type IAuthorizeEventServiceOffer = factory.action.authorize.offer.eventService.IAction;
+export type IAuthorizeEventServiceOffer = factory.action.authorize.offer.eventService.IAction & {
+    result?: factory.action.authorize.offer.eventService.IResult & {
+        onlyPrice?: boolean;
+    };
+};
 export type IAuthorizePaymentAction = Pick<factory.action.authorize.paymentMethod.any.IAction, 'id' | 'result' | 'endDate'> & {
     object: Pick<factory.action.authorize.paymentMethod.any.IObject, 'typeOf' | 'paymentMethodId'>;
     instrument?: never;

package/lib/chevre/service/transaction/placeOrder/confirm/validation.d.ts

@@ -1,11 +1,16 @@
 import { factory } from '../../../../factory';
 import { PlaceOrderFactory } from '../../../../factory/transaction';
+import { IPreparedUnitPriceOfferConditions } from './prepareUnitPriceOfferConditions';
 import { IAcceptPayAction, IAuthorizeEventServiceOffer, IAuthorizePaymentAction, IPayTransaction } from './validation/factory';
 export { IAcceptPayAction, IAuthorizeEventServiceOffer, IAuthorizePaymentAction, IPayTransaction };
 /**
  * 取引が確定可能な状態かどうかをチェックする
  */
-export declare function validateTransaction(transaction: Pick<factory.transaction.placeOrder.ITransaction, 'id' | 'object'>, acceptPayActions: IAcceptPayAction[], authorizePaymentActions: IAuthorizePaymentAction[], authorizeEventServiceOfferActions: Pick<IAuthorizeEventServiceOffer, 'id' | 'result'>[], eventReservationAcceptedOffers: Pick<factory.order.IAcceptedOffer, 'itemOffered' | 'priceSpecification'>[], payTransactions: IPayTransaction[], customer: factory.order.ICustomer): void;
+export declare function validateTransaction(transaction: {
+    id: string;
+}, acceptPayActions: IAcceptPayAction[], authorizePaymentActions: IAuthorizePaymentAction[], authorizeEventServiceOfferActions: Pick<IAuthorizeEventServiceOffer, 'id' | 'result'>[], eventReservationAcceptedOffers: Pick<factory.order.IAcceptedOffer, 'itemOffered' | 'priceSpecification'>[], payTransactions: IPayTransaction[], customer: factory.order.ICustomer, options: {
+    paymentMethodIdByTransaction?: string;
+}): void;
 /**
  * 注文オファー数検証
  */
@@ -35,9 +40,16 @@ export declare function validatePaymentMethods(params: {
  * 興行オファー適用条件確認
  */
 export declare function validateEventOffers(params: {
+    project: {
+        id: string;
+    };
     order: {
         price: number;
     };
     paymentMethods: factory.order.IReferencedInvoice[];
-    authorizeEventServiceOfferActions: Pick<IAuthorizeEventServiceOffer, 'id' | 'instrument' | 'object' | 'result'>[];
+    /**
+     * 承認アクションのresultに条件が保管されているはず(2026-07-06時点で)
+     */
+    authorizeOfferActions: Pick<IAuthorizeEventServiceOffer, 'id' | 'result'>[];
+    unitPriceOfferConditions?: IPreparedUnitPriceOfferConditions[];
 }): void;