@chevre/domain 25.2.0-alpha.4 → 25.2.0-alpha.40

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/potentialActions/sendEmailMessage.d.ts

@@ -1,6 +1,32 @@
 import { factory } from '../../../../../factory';
 import type { ISetting } from '../../../../../repo/setting';
 import type { IOrderAsResult } from '../factory/result';
+/**
+ * Eメール送信パラメータ
+ */
+interface ISendEmailMessageParams {
+    /**
+     * Eメールカスタマイズ
+     * メール本文をカスタマイズしたい場合、PUGテンプレートを指定
+     * 挿入変数として`order`を使用できます
+     * {@link https://pugjs.org/api/getting-started.html}
+     */
+    object?: factory.creativeWork.message.email.ICustomization;
+}
+/**
+ * 取引確定後アクションパラメータ
+ */
+export interface IPotentialActionsParams {
+    order?: {
+        potentialActions?: {
+            sendOrder?: {
+                potentialActions?: {
+                    sendEmailMessage?: ISendEmailMessageParams[];
+                };
+            };
+        };
+    };
+}
 export declare function createSendEmailMessageActions(params: {
     order: IOrderAsResult & {
         confirmationNumber: string;
@@ -12,8 +38,8 @@ export declare function createSendEmailMessageActions(params: {
     customer: factory.order.ICustomer;
     seller: Pick<factory.order.ISeller, 'name' | 'typeOf'>;
     paymentMethods: factory.order.IReferencedInvoice[];
-    potentialActions?: factory.transaction.placeOrder.IPotentialActionsParams;
+    potentialActions?: IPotentialActionsParams;
 }, setting: Pick<ISetting, 'defaultSenderEmail'>): Promise<{
     emailMessages: factory.action.transfer.send.message.email.IObjectAsEmailMessage[];
-    sendEmailMessageActions: factory.transaction.placeOrder.IPotentialSendEmailMessageAction[];
 }>;
+export {};

package/lib/chevre/service/transaction/placeOrder/confirm/potentialActions/sendEmailMessage.js

@@ -2,11 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createSendEmailMessageActions = createSendEmailMessageActions;
 const emailMessageBuilder_1 = require("../../../../../emailMessageBuilder");
-const factory_1 = require("../../../../../factory");
 async function createSendEmailMessageActions(params, setting) {
     // 注文配送メール送信設定
     const emailMessages = [];
-    const sendEmailMessageActions = [];
+    // const sendEmailMessageActions: factory.transaction.placeOrder.IPotentialSendEmailMessageAction[] = [];
     const sendEmailMessageOnOrderSentParams = params.potentialActions?.order?.potentialActions?.sendOrder?.potentialActions?.sendEmailMessage;
     if (Array.isArray(sendEmailMessageOnOrderSentParams)) {
         // pugテンプレートに渡す変数を最小化(2026-06-19~)
@@ -27,16 +26,16 @@ async function createSendEmailMessageActions(params, setting) {
                 // ...(params.emailMessage !== undefined) ? { emailMessage: params.emailMessage } : undefined
             }, setting);
             emailMessages.push(emailMessage);
-            // 送信アクション最適化に対応(2024-04-29~)
-            const sendEmailMessageActionObject = {
-                identifier: emailMessage.identifier,
-                typeOf: factory_1.factory.creativeWorkType.EmailMessage
-            };
-            // optimize(2024-05-07~)
-            sendEmailMessageActions.push({
-                object: sendEmailMessageActionObject
-            });
+            // // 送信アクション最適化に対応(2024-04-29~)
+            // const sendEmailMessageActionObject: factory.action.transfer.send.message.email.IObject = {
+            //     identifier: emailMessage.identifier,
+            //     typeOf: factory.creativeWorkType.EmailMessage
+            // };
+            // // optimize(2024-05-07~)
+            // sendEmailMessageActions.push({
+            //     object: sendEmailMessageActionObject
+            // });
         }));
     }
-    return { sendEmailMessageActions, emailMessages };
+    return { emailMessages };
 }

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

@@ -1,6 +1,8 @@
 import { factory } from '../../../../factory';
 import type { ISetting } from '../../../../repo/setting';
+import { IPotentialActionsParams } from './potentialActions/sendEmailMessage';
 import { IOrderAsResult } from './factory/result';
+export { IPotentialActionsParams };
 /**
  * 取引のポストアクションを作成する
  */
@@ -15,8 +17,8 @@ export declare function createPotentialActions(params: {
     customer: factory.order.ICustomer;
     seller: Pick<factory.order.ISeller, 'name' | 'typeOf'>;
     paymentMethods: factory.order.IReferencedInvoice[];
-    potentialActions?: factory.transaction.placeOrder.IPotentialActionsParams;
+    potentialActions?: IPotentialActionsParams;
 }, setting: Pick<ISetting, 'defaultSenderEmail'>): Promise<{
-    potentialActions: factory.transaction.placeOrder.IPotentialActions;
+    potentialActions?: never;
     emailMessages: factory.creativeWork.message.email.ICreativeWork[];
 }>;

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

@@ -7,14 +7,13 @@ const sendEmailMessage_1 = require("./potentialActions/sendEmailMessage");
  */
 async function createPotentialActions(params, setting) {
     // 注文処理開始メール送信設定
-    const { emailMessages, sendEmailMessageActions } = await (0, sendEmailMessage_1.createSendEmailMessageActions)(params, setting);
+    const { emailMessages } = await (0, sendEmailMessage_1.createSendEmailMessageActions)(params, setting);
     return {
         emailMessages,
-        potentialActions: {
-            order: {
-                onOrderProcessing: { sendEmailMessage: sendEmailMessageActions } // optimize(2024-06-29~)
-                // potentialActions: { sendOrder: sendOrderActionAttributes }
-            }
-        }
+        // potentialActions: {
+        //     order: {
+        //         onOrderProcessing: { sendEmailMessage: sendEmailMessageActions } // optimize(2024-06-29~)
+        //     }
+        // }
     };
 }

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

@@ -2,6 +2,39 @@ 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'>;
+interface IAcceptedOfferInResult extends Pick<factory.product.ITicketOffer, 'acceptedPaymentMethod' | 'id' | 'typeOf'> {
+    typeOf: factory.offerType.Offer;
+    id: string;
+    includesObject: {
+        amountOfThisGood: number;
+    };
+    /**
+     * 取引確定時の検証に必要な情報のみ保管する
+     */
+    priceSpecification?: Pick<factory.priceSpecification.unitPrice.IPriceSpecification, 'eligibleQuantity'>;
+}
+export type IAggregateProgramMembershipUsed = (factory.assetTransaction.reserve.IPermitIssuedThroughFaceToFace | factory.assetTransaction.reserve.IPermitIssuedThroughMembershipService)[];
+type IPreparedResult = Pick<factory.action.authorize.offer.eventService.IResult, 'price' | 'typeOf'> & {
+    /**
+     * オファーIDごとの集計
+     */
+    offers?: IAcceptedOfferInResult[];
+    itemOffered?: {
+        serviceOutput: {
+            /**
+             * programMembershipUsed required(2024-08-15~)
+             */
+            programMembershipUsed: IAggregateProgramMembershipUsed;
+        };
+    };
+};
+/**
+ * 注文ドキュメントと予約取引ドキュメントを参照することによって生成した、単価オファー検証条件
+ * 元々オファー承認アクションのresultに保管されていた
+ */
+type IPreparedUnitPriceOfferConditions = Pick<IAuthorizeEventServiceOffer, 'id'> & {
+    result?: IPreparedResult;
+};
 export declare function createAuthorizeOfferResultsExpected(params: {
     authorizeEventServiceOfferActions: Pick<IAuthorizeEventServiceOffer, 'id' | 'result'>[];
 }): Pick<IAuthorizeEventServiceOffer, 'id' | 'result'>[];
@@ -13,5 +46,5 @@ declare function prepareUnitPriceOfferConditions(params: {
     authorizeEventServiceOfferActions: IAuthorizeEventServiceOffer[];
 }): (repos: {
     offer: OfferRepo;
-}) => Promise<Pick<IAuthorizeEventServiceOffer, "id" | "result">[]>;
-export { prepareUnitPriceOfferConditions };
+}) => Promise<IPreparedUnitPriceOfferConditions[]>;
+export { IPreparedUnitPriceOfferConditions, prepareUnitPriceOfferConditions };

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

@@ -1,9 +1,13 @@
 "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 util_1 = require("util");
+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 });
@@ -32,7 +36,7 @@ function acceptedOffers2authorizeResult(params) {
         };
     });
     return {
-        amount: [],
+        // amount: [], // discontinue(2026-07-06~)
         itemOffered: {
             serviceOutput: { programMembershipUsed } // add programMembershipUsed required(2024-08-15~)
         },
@@ -77,11 +81,20 @@ function createAuthorizeOfferResultsExpected(params) {
 }
 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');
@@ -93,7 +106,7 @@ function prepareUnitPriceOfferConditions(params) {
                 id: authorizeEventServiceOfferAction.id,
                 result: {
                     typeOf: authorizeEventServiceOfferAction.result.typeOf,
-                    priceCurrency: authorizeEventServiceOfferAction.result.priceCurrency,
+                    // priceCurrency: authorizeEventServiceOfferAction.result.priceCurrency,
                     price: authorizeEventServiceOfferAction.result.price,
                     ...acceptedOffers2authorizeResult({
                         acceptedOffers4result: acceptedOffers4action,
@@ -102,15 +115,6 @@ function prepareUnitPriceOfferConditions(params) {
                 }
             });
         }
-        // 承認アクションと比較する
-        for (const authorizeEventServiceOfferAction of params.authorizeEventServiceOfferActions) {
-            const conditionExpected = conditions.find(({ id }) => id === authorizeEventServiceOfferAction.id);
-            const resultMatched = (0, util_1.isDeepStrictEqual)(conditionExpected?.result, authorizeEventServiceOfferAction.result);
-            console.log('resultMatched?', resultMatched, authorizeEventServiceOfferAction.id, authorizeEventServiceOfferAction.instrument.transactionNumber);
-            if (!resultMatched) {
-                console.log(conditionExpected?.result, authorizeEventServiceOfferAction.result);
-            }
-        }
         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,6 +40,9 @@ export declare function validatePaymentMethods(params: {
  * 興行オファー適用条件確認
  */
 export declare function validateEventOffers(params: {
+    project: {
+        id: string;
+    };
     order: {
         price: number;
     };
@@ -42,5 +50,6 @@ export declare function validateEventOffers(params: {
     /**
      * 承認アクションのresultに条件が保管されているはず(2026-07-06時点で)
      */
-    authorizeEventServiceOfferActions: Pick<IAuthorizeEventServiceOffer, 'id' | 'result'>[];
+    authorizeOfferActions: Pick<IAuthorizeEventServiceOffer, 'id' | 'result'>[];
+    unitPriceOfferConditions: IPreparedUnitPriceOfferConditions[];
 }): void;