@chevre/domain 25.0.0-alpha.9 → 25.0.0

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

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.call = call;
 const factory_1 = require("../../factory");
-// import { ActionRepo } from '../../repo/action';
 const acceptPay_1 = require("../../repo/action/acceptPay");
 const authorizeInvoice_1 = require("../../repo/action/authorizeInvoice");
 const assetTransaction_1 = require("../../repo/assetTransaction");
@@ -10,17 +9,16 @@ const authorization_1 = require("../../repo/authorization");
 const event_1 = require("../../repo/event");
 const eventSeries_1 = require("../../repo/eventSeries");
 const issuer_1 = require("../../repo/issuer");
-const orderNumber_1 = require("../../repo/orderNumber");
+// import { OrderInTransactionRepo } from '../../repo/orderInTransaction';
+// import { OrderNumberRepo } from '../../repo/orderNumber';
 const paymentService_1 = require("../../repo/paymentService");
 const paymentServiceProvider_1 = require("../../repo/paymentServiceProvider");
-const project_1 = require("../../repo/project");
+// import { ProjectRepo } from '../../repo/project';
 const sellerPaymentAccepted_1 = require("../../repo/sellerPaymentAccepted");
 const integration_1 = require("../../repo/setting/integration");
 const ticket_1 = require("../../repo/ticket");
-// import { TransactionRepo } from '../../repo/transaction';
 const placeOrder_1 = require("../../repo/transaction/placeOrder");
 const transactionNumber_1 = require("../../repo/transactionNumber");
-// import { TransactionProcessRepo } from '../../repo/transactionProcess';
 const any_1 = require("../payment/any");
 /**
  * タスク実行関数
@@ -43,7 +41,6 @@ function call(params) {
                 instrument: (Array.isArray(params.data.instrument)) ? params.data.instrument : [],
                 sameAs: { id: params.id }
             })({
-                // action: new ActionRepo(connection),
                 acceptPayAction: actionRepo,
                 authorizeInvoiceAction: new authorizeInvoice_1.AuthorizeInvoiceActionRepo(connection),
                 assetTransaction: new assetTransaction_1.AssetTransactionRepo(connection),
@@ -51,14 +48,14 @@ function call(params) {
                 event: new event_1.EventRepo(connection),
                 eventSeries: new eventSeries_1.EventSeriesRepo(connection),
                 issuer: new issuer_1.IssuerRepo(connection),
-                orderNumber: new orderNumber_1.OrderNumberRepo({ connection }),
+                // orderInTransaction: new OrderInTransactionRepo(connection),
+                // orderNumber: new OrderNumberRepo({ connection }),
                 paymentAccepted: new sellerPaymentAccepted_1.SellerPaymentAcceptedRepo(connection),
                 paymentService: new paymentService_1.PaymentServiceRepo(connection),
                 paymentServiceProvider: new paymentServiceProvider_1.PaymentServiceProviderRepo(connection),
-                project: new project_1.ProjectRepo(connection),
+                // project: new ProjectRepo(connection),
                 ticket: new ticket_1.TicketRepo(connection),
                 placeOrder: new placeOrder_1.PlaceOrderRepo(connection),
-                // transaction: new TransactionRepo(connection),
                 transactionNumber: new transactionNumber_1.TransactionNumberRepo({ connection })
             }, settings);
         }

package/lib/chevre/service/taskHandler.js

@@ -54,7 +54,6 @@ function executeTask(task, next) {
                 case factory_1.factory.taskName.CheckMovieTicket:
                 case factory_1.factory.taskName.CheckResource:
                 case factory_1.factory.taskName.CreateAccountingReport:
-                case factory_1.factory.taskName.DeletePerson:
                 case factory_1.factory.taskName.HandleNotification:
                 case factory_1.factory.taskName.ImportEventCapacitiesFromCOA:
                 case factory_1.factory.taskName.ImportEventsFromCOA:

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

@@ -3,35 +3,27 @@ import type { AcceptedOfferRepo } from '../../repo/acceptedOffer';
 import type { AccountingReportRepo } from '../../repo/accountingReport';
 import type { ActionRepo } from '../../repo/action';
 import type { AssetTransactionRepo } from '../../repo/assetTransaction';
-import type { EventRepo } from '../../repo/event';
-import type { MessageRepo } from '../../repo/message';
 import type { NoteRepo } from '../../repo/note';
 import type { OrderRepo } from '../../repo/order';
-import type { OwnershipInfoRepo } from '../../repo/ownershipInfo';
 import type { ReservationRepo } from '../../repo/reservation';
-import type { SettingRepo } from '../../repo/setting';
-import type { TaskRepo } from '../../repo/task';
 import type { TransactionRepo } from '../../repo/transaction';
 import type { PlaceOrderRepo } from '../../repo/transaction/placeOrder';
 import type { ReturnOrderRepo } from '../../repo/transaction/returnOrder';
-/**
- * 取引に関わるリソースを削除する
- * 冪等性を確保すること
- */
-export declare function deleteTransaction(params: factory.task.IData<factory.taskName.DeleteTransaction>): (repos: {
+interface IDeleteTransactionRepos {
     acceptedOffer: AcceptedOfferRepo;
     accountingReport: AccountingReportRepo;
     action: ActionRepo;
     assetTransaction: AssetTransactionRepo;
-    event: EventRepo;
-    message: MessageRepo;
     note: NoteRepo;
     order: OrderRepo;
-    ownershipInfo: OwnershipInfoRepo;
     reservation: ReservationRepo;
-    setting: SettingRepo;
-    task: TaskRepo;
     transaction: TransactionRepo;
     placeOrder: PlaceOrderRepo;
     returnOrder: ReturnOrderRepo;
-}) => Promise<void>;
+}
+/**
+ * 取引に関わるリソースを削除する
+ * 冪等性を確保すること
+ */
+export declare function deleteTransaction(params: factory.task.IData<factory.taskName.DeleteTransaction>): (repos: IDeleteTransactionRepos) => Promise<void>;
+export {};

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

@@ -11,118 +11,15 @@ const deleteOrder_1 = require("../order/deleteOrder");
 function deleteTransaction(params) {
     return async (repos) => {
         if (params.object.specifyingMethod === factory_1.factory.action.update.deleteAction.ObjectAsTransactionSpecifyingMethod.AgentId) {
-            // transaction.agent.id指定による取引削除に対応(2023-06-30~)
-            await createDeleteTransactionTasksByAgentId(params)(repos);
+            throw new factory_1.factory.errors.NotImplemented('deleteTransaction by agentId discontinued'); // discontinue(2026-06-28~)
+            // // transaction.agent.id指定による取引削除に対応(2023-06-30~)
+            // await createDeleteTransactionTasksByAgentId(params)(repos);
         }
         else {
             await deleteTransactionById(params)(repos);
         }
     };
 }
-function createDeleteTransactionTasksByAgentId(params) {
-    return async (repos) => {
-        if (params.object.specifyingMethod !== factory_1.factory.action.update.deleteAction.ObjectAsTransactionSpecifyingMethod.AgentId) {
-            throw new factory_1.factory.errors.Argument('object.specifyingMethod', `must be ${factory_1.factory.action.update.deleteAction.ObjectAsTransactionSpecifyingMethod.AgentId}`);
-        }
-        const agentIdSpecified = params.object.agent.id;
-        // agentIdによる全取引についてDeleteTransactionタスクを作成する
-        if (typeof agentIdSpecified === 'string' && agentIdSpecified.length > 0) {
-            const transactionTypeOf = params.object.typeOf;
-            let transactions;
-            if (transactionTypeOf === factory_1.factory.transactionType.PlaceOrder) {
-                transactions = await repos.placeOrder.findPlaceOrderTransactions({
-                    project: { id: { $eq: params.object.project.id } },
-                    agent: {
-                        ids: [agentIdSpecified],
-                        typeOf: factory_1.factory.personType.Person
-                    },
-                    typeOf: transactionTypeOf,
-                    inclusion: ['typeOf', 'startDate', 'endDate', 'object', 'project']
-                });
-            }
-            else if (transactionTypeOf === factory_1.factory.transactionType.ReturnOrder) {
-                transactions = await repos.returnOrder.findReturnOrderTransactions({
-                    project: { id: { $eq: params.object.project.id } },
-                    agent: {
-                        ids: [agentIdSpecified],
-                        typeOf: factory_1.factory.personType.Person
-                    },
-                    typeOf: transactionTypeOf,
-                    inclusion: ['typeOf', 'startDate', 'endDate', 'object', 'project']
-                });
-            }
-            else {
-                throw new factory_1.factory.errors.NotImplemented(`${transactionTypeOf} not implemented`);
-            }
-            const deleteAt = new Date();
-            let deleteTransactionTasks;
-            switch (transactionTypeOf) {
-                case factory_1.factory.transactionType.PlaceOrder:
-                    deleteTransactionTasks = transactions.map((transaction) => {
-                        return {
-                            project: transaction.project,
-                            name: factory_1.factory.taskName.DeleteTransaction,
-                            status: factory_1.factory.taskStatus.Ready,
-                            runsAt: deleteAt,
-                            remainingNumberOfTries: 3,
-                            numberOfTried: 0,
-                            executionResults: [],
-                            data: {
-                                object: {
-                                    specifyingMethod: factory_1.factory.action.update.deleteAction.ObjectAsTransactionSpecifyingMethod.Id,
-                                    id: transaction.id,
-                                    object: {
-                                        ...(typeof transaction.object.confirmationNumber === 'string')
-                                            ? { confirmationNumber: transaction.object.confirmationNumber }
-                                            : undefined,
-                                        ...(typeof transaction.object.orderNumber === 'string')
-                                            ? { orderNumber: transaction.object.orderNumber }
-                                            : undefined
-                                    },
-                                    project: transaction.project,
-                                    startDate: transaction.startDate,
-                                    typeOf: transaction.typeOf,
-                                    ...(transaction.endDate !== undefined) ? { endDate: transaction.endDate } : undefined
-                                }
-                            }
-                        };
-                    });
-                    break;
-                case factory_1.factory.transactionType.ReturnOrder:
-                    deleteTransactionTasks = transactions.map((transaction) => {
-                        return {
-                            project: transaction.project,
-                            name: factory_1.factory.taskName.DeleteTransaction,
-                            status: factory_1.factory.taskStatus.Ready,
-                            runsAt: deleteAt,
-                            remainingNumberOfTries: 3,
-                            numberOfTried: 0,
-                            executionResults: [],
-                            data: {
-                                object: {
-                                    specifyingMethod: factory_1.factory.action.update.deleteAction.ObjectAsTransactionSpecifyingMethod.Id,
-                                    id: transaction.id,
-                                    object: {
-                                        order: transaction.object.order
-                                    },
-                                    project: transaction.project,
-                                    startDate: transaction.startDate,
-                                    typeOf: transaction.typeOf,
-                                    ...(transaction.endDate !== undefined) ? { endDate: transaction.endDate } : undefined
-                                }
-                            }
-                        };
-                    });
-                    break;
-                default:
-                    throw new factory_1.factory.errors.NotImplemented(`${transactionTypeOf} not implemented`);
-            }
-            if (deleteTransactionTasks.length > 0) {
-                await repos.task.saveMany(deleteTransactionTasks, { emitImmediately: true });
-            }
-        }
-    };
-}
 function deleteTransactionById(params) {
     return async (repos) => {
         if (typeof params.object.specifyingMethod === 'string'
@@ -133,7 +30,7 @@ function deleteTransactionById(params) {
         if (typeof deletingTransactionId !== 'string' || deletingTransactionId.length === 0) {
             throw new factory_1.factory.errors.ArgumentNull('object.id');
         }
-        let deletingOrderNumberByTask;
+        // let deletingOrderNumberByTask: string | undefined;
         let transaction;
         if (params.object.typeOf === factory_1.factory.transactionType.PlaceOrder) {
             transaction = (await repos.placeOrder.findPlaceOrderTransactions({
@@ -141,7 +38,7 @@ function deleteTransactionById(params) {
                 typeOf: params.object.typeOf,
                 inclusion: ['typeOf', 'project', 'status']
             })).shift();
-            deletingOrderNumberByTask = params.object.object.orderNumber;
+            // deletingOrderNumberByTask = params.object.object.orderNumber;
         }
         else if (params.object.typeOf === factory_1.factory.transactionType.ReturnOrder) {
             transaction = (await repos.returnOrder.findReturnOrderTransactions({
@@ -172,7 +69,7 @@ function deleteTransactionById(params) {
         let deleteCancelReservationTransactionResult;
         let deletedReservationNumbers = [];
         let deleteActionResult;
-        let deleteMessagessResult;
+        // let deleteMessagessResult: IDeleteResult | undefined;
         const action = await repos.action.start(actionAttributes);
         try {
             const transactionTypeOf = transaction.typeOf;
@@ -191,18 +88,15 @@ function deleteTransactionById(params) {
                         case factory_1.factory.transactionStatusType.Expired:
                             break;
                         case factory_1.factory.transactionStatusType.Confirmed: {
-                            // 削除対象の注文番号についてはタスクを参照する(2026-06-15~)
-                            // const deletingOrder = transaction.result?.order;
-                            // if (typeof deletingOrder?.orderNumber === 'string') {
+                            // identifierによる削除に変更(2026-06-28~)
+                            // if (typeof deletingOrderNumberByTask === 'string') {
                             //     await deleteOrder({
-                            //         object: deletingOrder
+                            //         object: { orderNumber: deletingOrderNumberByTask }
                             //     })(repos);
                             // }
-                            if (typeof deletingOrderNumberByTask === 'string') {
-                                await (0, deleteOrder_1.deleteOrder)({
-                                    object: { orderNumber: deletingOrderNumberByTask }
-                                })(repos);
-                            }
+                            await (0, deleteOrder_1.deleteOrder)({
+                                object: { identifier: transaction.id }
+                            })(repos);
                             break;
                         }
                         default:
@@ -233,11 +127,12 @@ function deleteTransactionById(params) {
                             ]
                         }
                     });
-                    // messages削除(2024-05-01~)
-                    const deleteMessagesByPlaceOrderResult = await deleteMessagesByPlaceOrder({
-                        transaction: params.object
-                    })(repos);
-                    deleteMessagessResult = deleteMessagesByPlaceOrderResult.deleteResult;
+                    // メッセージはcronで定期削除するため取引削除における連動は廃止(2026-06-29~)
+                    // // messages削除(2024-05-01~)
+                    // const deleteMessagesByPlaceOrderResult = await deleteMessagesByPlaceOrder({
+                    //     transaction: params.object
+                    // })(repos);
+                    // deleteMessagessResult = deleteMessagesByPlaceOrderResult.deleteResult;
                     // 取引削除
                     await repos.transaction.findByIdAndDelete({ id: transaction.id });
                     break;
@@ -270,7 +165,7 @@ function deleteTransactionById(params) {
             deleteCancelReservationTransactionResult,
             deletedReservationNumbers,
             deleteActionResult,
-            ...(deleteMessagessResult !== undefined) ? { deleteMessagessResult } : undefined
+            // ...(deleteMessagessResult !== undefined) ? { deleteMessagessResult } : undefined
         };
         await repos.action.completeWithVoid({ typeOf: action.typeOf, id: action.id, result: actionResult });
     };
@@ -383,24 +278,30 @@ function deletePayTransactionsByPlaceOrder(params) {
         return { deletePayTransactionResult, deleteRefundResult, payTransactionNumbers };
     };
 }
-function deleteMessagesByPlaceOrder(params) {
-    return async (repos) => {
-        let deleteResult;
-        if (params.transaction.typeOf === factory_1.factory.transactionType.PlaceOrder
-            && params.transaction.specifyingMethod === factory_1.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 };
-    };
-}
+// 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/factory/result.d.ts

@@ -1,4 +1,9 @@
 import { factory } from '../../../../../factory';
+type IOrderAsResult = Pick<factory.order.IOrder, 'confirmationNumber' | 'orderDate' | 'orderNumber' | 'price' | 'priceCurrency' | 'typeOf'> & {
+    orderStatus: factory.orderStatus.OrderPaymentDue;
+    identifier?: never;
+    url?: never;
+};
 /**
  * 注文取引結果としての注文を生成する
  */
@@ -6,5 +11,5 @@ declare function createOrderAsResult(params: {
     orderNumber: string;
     orderDate: Date;
     price: number;
-}): factory.transaction.placeOrder.IOrderAsResult;
-export { createOrderAsResult };
+}): IOrderAsResult;
+export { createOrderAsResult, IOrderAsResult };

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

@@ -1,7 +1,8 @@
 import { factory } from '../../../../../factory';
 import type { ISetting } from '../../../../../repo/setting';
+import type { IOrderAsResult } from '../factory/result';
 export declare function createSendEmailMessageActions(params: {
-    order: factory.transaction.placeOrder.IOrderAsResult & {
+    order: IOrderAsResult & {
         confirmationNumber: string;
         orderStatus: factory.orderStatus;
         price: number;
@@ -9,7 +10,7 @@ export declare function createSendEmailMessageActions(params: {
         typeOf: factory.order.OrderType;
     };
     customer: factory.order.ICustomer;
-    seller: factory.order.ISeller;
+    seller: Pick<factory.order.ISeller, 'name' | 'typeOf'>;
     paymentMethods: factory.order.IReferencedInvoice[];
     potentialActions?: factory.transaction.placeOrder.IPotentialActionsParams;
 }, setting: Pick<ISetting, 'defaultSenderEmail'>): Promise<{

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

@@ -1,10 +1,11 @@
 import { factory } from '../../../../factory';
 import type { ISetting } from '../../../../repo/setting';
+import { IOrderAsResult } from './factory/result';
 /**
  * 取引のポストアクションを作成する
  */
 export declare function createPotentialActions(params: {
-    order: factory.transaction.placeOrder.IOrderAsResult & {
+    order: IOrderAsResult & {
         confirmationNumber: string;
         orderStatus: factory.orderStatus.OrderPaymentDue;
         price: number;
@@ -12,7 +13,7 @@ export declare function createPotentialActions(params: {
         typeOf: factory.order.OrderType;
     };
     customer: factory.order.ICustomer;
-    seller: factory.order.ISeller;
+    seller: Pick<factory.order.ISeller, 'name' | 'typeOf'>;
     paymentMethods: factory.order.IReferencedInvoice[];
     potentialActions?: factory.transaction.placeOrder.IPotentialActionsParams;
 }, setting: Pick<ISetting, 'defaultSenderEmail'>): Promise<{

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

@@ -11,6 +11,7 @@ import type { SettingRepo } from '../../../repo/setting';
 import type { PlaceOrderRepo } from '../../../repo/transaction/placeOrder';
 import { factory } from '../../../factory';
 import { PlaceOrderFactory } from '../../../factory/transaction';
+import { IOrderAsResult } from './confirm/factory/result';
 interface IConfirmOperationRepos {
     acceptPayAction: AcceptPayActionRepo;
     authorizePaymentMethodAction: AuthorizePaymentMethodActionRepo;
@@ -38,14 +39,10 @@ interface IConfirmOptions {
      * 注文における最大CreditCardIF決済方法数
      */
     maxNumCreditCardPaymentMethod: number;
-    /**
-     * 取引ドキュメントのresult.order,result,numAcceptedOffersを保管しないオプション(2026-06-15~)
-     */
-    disableResultOrder: boolean;
 }
 type IConfirmParams = PlaceOrderFactory.IConfirmParams;
 interface IConfirmResult {
-    order: Pick<factory.transaction.placeOrder.IOrderAsResult, 'confirmationNumber' | 'orderNumber'>;
+    order: Pick<IOrderAsResult, 'confirmationNumber' | 'orderNumber'>;
     customer: factory.order.ICustomer;
     code?: string;
     /**

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

@@ -19,16 +19,17 @@ const debug = (0, debug_1.default)('chevre-domain:service:transaction');
 /**
  * 進行中でない取引を処理する
  */
-function processTransactionNotInProgress(transaction) {
+function processTransactionNotInProgress(params) {
     return async (repos) => {
+        const { transaction, orderNumber } = params;
         if (transaction.status === factory_1.factory.transactionStatusType.Confirmed) {
-            const resultCustomer = await repos.orderInTransaction.findCustomerByOrderNumber({
-                orderNumber: { $eq: String(transaction.object.orderNumber) }
+            const resultCustomer = await repos.orderInTransaction.findCustomerByOrderIdentifier({
+                identifier: transaction.id
             });
             // if (resultCustomer === undefined) {
             //     throw new factory.errors.Internal('resultCustomer undefined'); // impossible process
             // }
-            const { confirmationNumber, orderNumber } = transaction.object;
+            const { confirmationNumber } = transaction.object;
             // Confirmedの取引であればobjectには必ず存在するはず
             if (typeof confirmationNumber !== 'string' || typeof orderNumber !== 'string'
                 || confirmationNumber === '' || orderNumber === '') {
@@ -62,30 +63,30 @@ function confirm(params, options) {
             object: { orderDate: params.result.order.orderDate }
         })(repos);
         const transaction = await repos.placeOrder.findPlaceOrderById({ typeOf: factory_1.factory.transactionType.PlaceOrder, id: params.id }, ['typeOf', 'project', 'status', 'agent', 'seller', 'object', 'result']);
-        const confirmResult = await processTransactionNotInProgress(transaction)(repos);
+        // 注文ドキュメントから注文番号を参照(取引開始時に発行済の前提)(2026-06-26~)
+        const orderNumber = await repos.orderInTransaction.findOrderNumberByIdentifier({
+            identifier: params.id,
+            project: { id: transaction.project.id }
+        }, { onlyPlaceOrder: false } // すでに取引確定済かもしれないのでfalse
+        );
+        const confirmResult = await processTransactionNotInProgress({ transaction, orderNumber })(repos);
         if (confirmResult !== undefined) {
             return confirmResult;
         }
         if (typeof params.agent?.id === 'string' && transaction.agent.id !== params.agent.id) {
             throw new factory_1.factory.errors.Forbidden('Transaction not yours');
         }
-        // 注文番号は興行オファー承認時に発行済のはず(2026-06-16~)
-        const orderNumber = transaction.object.orderNumber;
-        if (typeof orderNumber !== 'string' || orderNumber === '') {
-            throw new factory_1.factory.errors.Argument('transactionId', 'orderNumber not issued');
-        }
+        // // 注文番号は興行オファー承認時に発行済のはず(2026-06-16~)
+        // const orderNumber = transaction.object.orderNumber;
+        // if (typeof orderNumber !== 'string' || orderNumber === '') {
+        //     throw new factory.errors.Argument('transactionId', 'orderNumber not issued');
+        // }
         // 取引に対する全ての承認アクションをマージ
         const completedAuthorizeActions = await searchAuthorizeActions(params)(repos);
         let acceptPayActions = [];
         if (typeof transaction.object.paymentMethods?.paymentMethodId === 'string') {
             acceptPayActions = await searchAcceptPayActions(params)(repos);
         }
-        // 注文番号は興行オファー承認時に発行済のはずなので、ここは不要(承認オファーなしの注文は存在しえない)(2026-06-16~)
-        // const orderNumber = await issueOrderNumberIfNotExist({
-        //     project: { id: transaction.project.id },
-        //     id: transaction.id,
-        //     object: { orderDate: params.result.order.orderDate }
-        // })(repos);
         // 必要あらば注文コード発行(2024-02-05~)
         let code;
         const publishCodeExpiresInSeconds = options.publishCodeExpiresInSeconds;
@@ -107,8 +108,9 @@ function confirm(params, options) {
         // authorizeProductOfferActions,
         serialNumbers } = dissolveAuthorizeActions(completedAuthorizeActions);
         // orderInTransactionから検索する(2024-03-04~)
-        const acceptedOffers = (await repos.orderInTransaction.findAcceptedOffersWithPriceByOrderNumber({
-            orderNumber,
+        const acceptedOffers = (await repos.orderInTransaction.findAcceptedOffersWithPriceByIdentifier({
+            // orderNumber,
+            identifier: transaction.id,
             project: { id: transaction.project.id }
         }))
             .filter(({ serialNumber }) => typeof serialNumber === 'string' && serialNumbers.includes(serialNumber));
@@ -125,7 +127,7 @@ function confirm(params, options) {
         }
         // retrieve customer from orderInTransaction(2024-06-24~)
         // let customer: factory.order.ICustomer = createCustomer({ transaction });
-        const customer = await repos.orderInTransaction.findCustomerByOrderNumber({ orderNumber: { $eq: orderNumber } });
+        const customer = await repos.orderInTransaction.findCustomerByOrderIdentifier({ identifier: transaction.id });
         const seller = (0, factory_2.createSeller)({ transaction });
         const { paymentMethods, placingOrder, result, eventId, reservationIds } = createResult({
             ...params,
@@ -175,7 +177,10 @@ function confirm(params, options) {
             await repos.placeOrder.confirmPlaceOrder({
                 typeOf: transaction.typeOf,
                 id: transaction.id,
-                object: { orderDate: params.result.order.orderDate },
+                object: {
+                    orderDate: params.result.order.orderDate,
+                    orderNumber
+                },
                 result: result,
                 potentialActions: potentialActions
             });
@@ -374,10 +379,10 @@ function createResult(params, options) {
         result: {
             authorizeActions, // 追加(2024-01-17~)
             ...(typeof params.code === 'string') ? { code: params.code } : undefined,
-            ...((!options.disableResultOrder) && { order: orderAsResult }), // support disableResultOrder(2026-06-15~)
-            ...((!options.disableResultOrder) && {
-                numAcceptedOffers: params.acceptedOffers.length, // 追加(2024-01-17~)
-            }) // support disableResultOrder(2026-06-17~)
+            // ...((!options.disableResultOrder) && { order: orderAsResult }), // 完全廃止(2026-06-26~)
+            // ...((!options.disableResultOrder) && {
+            //     numAcceptedOffers: params.acceptedOffers.length,
+            // }) // 完全廃止(2026-06-26~)
         },
         ...(typeof eventId === 'string') ? { eventId } : undefined,
         ...(Array.isArray(reservationIds)) ? { reservationIds } : undefined

package/lib/chevre/service/transaction/placeOrder/exportTasks/factory.d.ts

@@ -1,12 +1,11 @@
 import { factory } from '../../../../factory';
 import type { ISetting } from '../../../../repo/setting';
-type IPlaceOrderPotentialTask = factory.task.IAttributes<factory.taskName.PlaceOrder> | factory.task.IAttributes<factory.taskName.TriggerWebhook> | factory.task.IAttributes<factory.taskName.DeleteTransaction> | factory.task.IAttributes<factory.taskName.VoidPayTransaction> | factory.task.IAttributes<factory.taskName.VoidReserveTransaction>;
+type IPlaceOrderPotentialTask = factory.task.IAttributes<factory.taskName.PlaceOrder> | factory.task.IAttributes<factory.taskName.DeleteTransaction> | factory.task.IAttributes<factory.taskName.VoidPayTransaction> | factory.task.IAttributes<factory.taskName.VoidReserveTransaction>;
 /**
  * 取引のタスクを作成する
  */
 export declare function createTasks(params: {
     transaction: Pick<factory.transaction.ITransaction<factory.transactionType.PlaceOrder>, 'endDate' | 'id' | 'object' | 'project' | 'seller' | 'startDate' | 'status' | 'typeOf'>;
     runsAt: Date;
-    optimizeRedundantTasks: boolean;
-}, setting: Pick<ISetting, 'onTransactionStatusChanged' | 'storage'> | null): IPlaceOrderPotentialTask[];
+}, setting: Pick<ISetting, 'storage'> | null): IPlaceOrderPotentialTask[];
 export {};