@chevre/domain 24.0.0-alpha.6 → 24.0.0-alpha.60

package/lib/chevre/service/offer/product.js

@@ -31,7 +31,7 @@ const factory = __importStar(require("../../factory"));
 const accountTransactionIdentifier_1 = require("../../factory/accountTransactionIdentifier");
 const availableProductTypes_1 = require("../../factory/availableProductTypes");
 const RegisterServiceTransaction = __importStar(require("../assetTransaction/registerService"));
-const publishOrderNumberIfNotExist_1 = require("../transaction/placeOrder/publishOrderNumberIfNotExist");
+const issueOrderNumberIfNotExist_1 = require("../transaction/placeOrder/issueOrderNumberIfNotExist");
 const any_1 = require("./any");
 const factory_1 = require("./product/factory");
 const searchProductOffers_1 = require("./product/searchProductOffers");
@@ -99,7 +99,7 @@ function search(params) {
 function authorize(params) {
     return async (repos) => {
         const now = new Date();
-        const transaction = await repos.transaction.projectFieldsInProgressById({
+        const transaction = await repos.placeOrder.findPlaceOrderInProgressById({
             typeOf: factory.transactionType.PlaceOrder,
             id: params.transaction.id
         }, ['agent', 'project', 'seller', 'typeOf', 'expires']);
@@ -117,7 +117,7 @@ function authorize(params) {
             })(repos);
         }
         // ポイント特典の識別子に利用するため注文番号を先に発行
-        const orderNumber = await (0, publishOrderNumberIfNotExist_1.publishOrderNumberIfNotExist)({
+        const orderNumber = await (0, issueOrderNumberIfNotExist_1.issueOrderNumberIfNotExist)({
             project: { id: transaction.project.id },
             id: transaction.id,
             object: { orderDate: new Date() }
@@ -128,7 +128,7 @@ function authorize(params) {
             availableOffers,
             seller: transaction.seller,
             orderNumber
-        })(repos);
+        })({});
         acceptedOffer = await createServiceOutputIdentifier({ acceptedOffer, product })(repos);
         let requestBody;
         let responseBody;
@@ -142,7 +142,7 @@ function authorize(params) {
             transaction: transaction,
             transactionNumber: transactionNumber
         });
-        const action = await repos.action.start(actionAttributes);
+        const action = await repos.authorizeProductOfferAction.start(actionAttributes);
         try {
             // 会員の場合のみ排他ロック
             // if (params.agent.typeOf === factory.personType.Person) {
@@ -168,14 +168,14 @@ function authorize(params) {
         }
         catch (error) {
             try {
-                await repos.action.giveUp({ typeOf: action.typeOf, id: action.id, error });
+                await repos.authorizeProductOfferAction.giveUp({ typeOf: action.typeOf, id: action.id, error });
             }
             catch (__) {
                 // no op
             }
             throw error;
         }
-        await repos.action.completeWithVoid({ typeOf: action.typeOf, id: action.id, result: result });
+        await repos.authorizeProductOfferAction.completeWithVoid({ typeOf: action.typeOf, id: action.id, result: result });
         return { id: action.id, result };
     };
 }
@@ -214,7 +214,7 @@ function fixProductAndOffers(params) {
 }
 function voidTransaction(params) {
     return async (repos) => {
-        const transaction = await repos.transaction.projectFieldsById({
+        const transaction = await repos.placeOrder.findPlaceOrderById({
             typeOf: params.purpose.typeOf,
             id: params.purpose.id
         }, ['agent', 'status', 'typeOf']);
@@ -230,28 +230,32 @@ function voidTransaction(params) {
         }
         let authorizeActions;
         if (typeof params.id === 'string') {
-            const action = await repos.action.findById({ typeOf: factory.actionType.AuthorizeAction, id: params.id });
+            const action = await repos.authorizeProductOfferAction.findById({ typeOf: factory.actionType.AuthorizeAction, id: params.id });
             if (action.purpose.typeOf !== transaction.typeOf || action.purpose.id !== transaction.id) {
                 throw new factory.errors.Argument('Transaction', 'Action not found in the transaction');
             }
             authorizeActions = [action];
         }
         else {
-            authorizeActions = await repos.action.searchByPurpose({
-                typeOf: factory.actionType.AuthorizeAction,
+            authorizeActions = await repos.authorizeProductOfferAction.findAuthorizeProductOfferActionsByPurpose({
+                // typeOf: factory.actionType.AuthorizeAction,
                 purpose: {
                     typeOf: params.purpose.typeOf,
                     id: params.purpose.id
                 }
             })
                 .then((actions) => actions
-                .filter((a) => Array.isArray(a.object)
-                && a.object.length > 0
-                && a.object[0].typeOf === factory.offerType.Offer
-                && availableProductTypes_1.availableProductTypes.indexOf(a.object[0].itemOffered.typeOf) >= 0));
+                .filter((a) => 
+            // Array.isArray(a.object)
+            // && a.object.length > 0
+            // && a.object[0].typeOf === factory.offerType.Offer
+            // && availableProductTypes.indexOf(a.object[0].itemOffered.typeOf) >= 0
+            a.object.typeOf === factory.action.authorize.offer.product.ObjectType.AggregateOffer
+                && availableProductTypes_1.availableProductTypes.indexOf(a.object.itemOffered.typeOf) >= 0));
         }
         await Promise.all(authorizeActions.map(async (action) => {
-            const productId = action.object[0]?.itemOffered?.id;
+            // const productId = action.object[0]?.itemOffered?.id;
+            const productId = action.object?.itemOffered?.id;
             if (typeof productId === 'string') {
                 // 廃止(2023-12-07~)
                 // await processUnlockRegisterMembershipService({
@@ -260,7 +264,7 @@ function voidTransaction(params) {
                 //     purpose: params.purpose
                 // })(repos);
             }
-            await repos.action.cancelWithVoid({ typeOf: action.typeOf, id: action.id });
+            await repos.authorizeProductOfferAction.cancelWithVoid({ typeOf: action.typeOf, id: action.id });
             await processVoidRegisterServiceTransaction({
                 action,
                 project: params.project

package/lib/chevre/service/offer.d.ts

@@ -5,9 +5,8 @@ import type { StockHolderRepo } from '../repo/stockHolder';
 import * as factory from '../factory';
 import * as EventOfferService from './offer/event';
 import * as EventServiceByCOAOfferService from './offer/eventServiceByCOA';
-import * as MoneyTransferOfferService from './offer/moneyTransfer';
 import * as ProductOfferService from './offer/product';
-export { EventOfferService as event, EventServiceByCOAOfferService as eventServiceByCOA, MoneyTransferOfferService as moneyTransfer, ProductOfferService as product };
+export { EventOfferService as event, EventServiceByCOAOfferService as eventServiceByCOA, ProductOfferService as product };
 type ISeatAsEventOffer = Pick<factory.place.seat.IPlaceWithOffer, 'branchCode' | 'name' | 'seatingType'> & {
     containedInPlace?: {
         branchCode?: string;

package/lib/chevre/service/offer.js

@@ -26,7 +26,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.product = exports.moneyTransfer = exports.eventServiceByCOA = exports.event = void 0;
+exports.product = exports.eventServiceByCOA = exports.event = void 0;
 exports.searchEventSeatOffersWithPaging = searchEventSeatOffersWithPaging;
 exports.findEventSeatOffersBySection = findEventSeatOffersBySection;
 const moment_1 = __importDefault(require("moment"));
@@ -35,8 +35,6 @@ const EventOfferService = __importStar(require("./offer/event"));
 exports.event = EventOfferService;
 const EventServiceByCOAOfferService = __importStar(require("./offer/eventServiceByCOA"));
 exports.eventServiceByCOA = EventServiceByCOAOfferService;
-const MoneyTransferOfferService = __importStar(require("./offer/moneyTransfer"));
-exports.moneyTransfer = MoneyTransferOfferService;
 const ProductOfferService = __importStar(require("./offer/product"));
 exports.product = ProductOfferService;
 /**
@@ -47,13 +45,15 @@ function searchEventSeatOffersWithPaging(params) {
         const { includeSectionCodeOnlyFirstElement, useDefaultSection } = params.options;
         let offers = [];
         // optimize(2024-07-18~)
-        const event = await repos.event.projectEventFieldsById({ id: params.event.id }, ['project', 'startDate', 'offers.itemOffered', 'organizer']);
+        const event = await repos.event.projectEventFieldsById({ id: params.event.id }, ['project', 'startDate', 'offers.itemOffered', 'organizer', 'location', 'superEvent']);
         // 座席指定利用可能かどうか
         const eventOffers = event.offers;
         const reservedSeatsAvailable = eventOffers?.itemOffered.serviceOutput?.reservedTicket?.ticketedSeat !== undefined;
         if (reservedSeatsAvailable) {
-            const roomBranchCode = String(eventOffers.itemOffered?.availableChannel?.serviceLocation.branchCode);
-            const movieTheaterBranchCode = String(eventOffers.itemOffered?.availableChannel?.serviceLocation.containedInPlace.branchCode);
+            // const roomBranchCode = String(eventOffers.itemOffered?.availableChannel?.serviceLocation.branchCode);
+            // const movieTheaterBranchCode = String(eventOffers.itemOffered?.availableChannel?.serviceLocation.containedInPlace.branchCode);
+            const roomBranchCode = event.location.branchCode;
+            const movieTheaterBranchCode = event.superEvent.location.branchCode;
             let defaultSectionCode;
             if (useDefaultSection) {
                 const defaultSection = (await repos.section.findSectionsByRoom({
@@ -161,7 +161,7 @@ function findEventSeatOffersBySection(params) {
             organizer: { id: { $eq: sellerId } },
             id: { $eq: eventId },
             typeOf: factory.eventType.ScreeningEvent
-        }, ['startDate', 'offers.itemOffered'])).shift();
+        }, ['startDate', 'offers.itemOffered', 'location', 'superEvent'])).shift();
         if (event === undefined) {
             throw new factory.errors.NotFound(factory.eventType.ScreeningEvent);
         }
@@ -169,8 +169,10 @@ function findEventSeatOffersBySection(params) {
         const eventOffers = event.offers;
         const reservedSeatsAvailable = eventOffers?.itemOffered.serviceOutput?.reservedTicket?.ticketedSeat !== undefined;
         if (reservedSeatsAvailable) {
-            const roomBranchCode = String(eventOffers.itemOffered?.availableChannel?.serviceLocation.branchCode);
-            const movieTheaterBranchCode = String(eventOffers.itemOffered?.availableChannel?.serviceLocation.containedInPlace.branchCode);
+            // const roomBranchCode = String(eventOffers.itemOffered?.availableChannel?.serviceLocation.branchCode);
+            // const movieTheaterBranchCode = String(eventOffers.itemOffered?.availableChannel?.serviceLocation.containedInPlace.branchCode);
+            const roomBranchCode = event.location.branchCode;
+            const movieTheaterBranchCode = event.superEvent.location.branchCode;
             const seats = await repos.seat.projectSeatsByScreeningRoom({
                 limit,
                 page,

package/lib/chevre/service/order/confirmPayTransaction.d.ts

@@ -7,13 +7,12 @@ import type { EventRepo } from '../../repo/event';
 import type { OrderRepo } from '../../repo/order';
 import type { ProjectRepo } from '../../repo/project';
 import type { TaskRepo } from '../../repo/task';
-import type { TransactionRepo } from '../../repo/transaction';
 declare function confirmPayTransaction(data: factory.task.IData<factory.taskName.ConfirmPayTransaction> & {
     project: {
         id: string;
         typeOf: factory.organizationType.Project;
     };
-}, options: {}): (repos: {
+}, options: Record<string, never>): (repos: {
     acceptedOffer: AcceptedOfferRepo;
     action: ActionRepo;
     assetTransaction: AssetTransactionRepo;
@@ -22,6 +21,5 @@ declare function confirmPayTransaction(data: factory.task.IData<factory.taskName
     event: EventRepo;
     project: ProjectRepo;
     task: TaskRepo;
-    transaction: TransactionRepo;
 }) => Promise<void>;
 export { confirmPayTransaction };

package/lib/chevre/service/order/confirmPayTransaction.js

@@ -25,6 +25,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.confirmPayTransaction = confirmPayTransaction;
 const factory = __importStar(require("../../factory"));
+// import type { TransactionRepo } from '../../repo/transaction';
 const PayTransactionService = __importStar(require("../assetTransaction/pay"));
 function confirmPayTransaction(data, options) {
     return async (repos) => {

package/lib/chevre/service/order/deleteOrder.js

@@ -119,7 +119,7 @@ function deleteReservationsByOrder(order) {
             orderNumber: { $eq: order.orderNumber },
             project: { id: { $eq: order.project.id } },
             acceptedOffers: {
-                itemOffered: { typeOf: { $in: [factory.reservationType.BusReservation, factory.reservationType.EventReservation] } }
+                itemOffered: { typeOf: { $in: [factory.reservationType.EventReservation] } }
             }
         });
         const reservationIds = acceptedOffers.map((o) => String(o.itemOffered.id));
@@ -147,7 +147,7 @@ function deleteOwnershipInfosByOrder(order) {
                 project: { id: order.project.id },
                 identifiers: ownershipIdentifiers,
                 // 所有期限切れのもの(ownedThroughの存在しないものは削除してはいけない)
-                ownedThrough: { $lt: now }
+                ownedThrough: { $lte: now }
             });
         }
     };

package/lib/chevre/service/order/findPlaceOrderTransaction.d.ts

@@ -1,4 +1,4 @@
-import type { TransactionRepo } from '../../repo/transaction';
+import type { PlaceOrderRepo } from '../../repo/transaction/placeOrder';
 import * as factory from '../../factory';
 type ITransaction = Pick<factory.transaction.placeOrder.ITransaction, 'id' | 'potentialActions' | 'project' | 'typeOf'>;
 export declare function findPlaceOrderTransaction(params: {
@@ -8,6 +8,6 @@ export declare function findPlaceOrderTransaction(params: {
     confirmationNumber: string;
     orderNumber: string;
 }): (repos: {
-    transaction: TransactionRepo;
+    placeOrder: PlaceOrderRepo;
 }) => Promise<ITransaction>;
 export {};

package/lib/chevre/service/order/findPlaceOrderTransaction.js

@@ -27,7 +27,7 @@ exports.findPlaceOrderTransaction = findPlaceOrderTransaction;
 const factory = __importStar(require("../../factory"));
 function findPlaceOrderTransaction(params) {
     return async (repos) => {
-        const placeOrderTransactions = await repos.transaction.projectFields({
+        const placeOrderTransactions = await repos.placeOrder.findPlaceOrderTransactions({
             limit: 1,
             page: 1,
             project: { id: { $eq: params.project.id } },

package/lib/chevre/service/order/onAssetTransactionStatusChanged/isDeliverable.d.ts

@@ -0,0 +1,16 @@
+import type { AcceptedOfferRepo } from '../../../repo/acceptedOffer';
+import type { AssetTransactionRepo } from '../../../repo/assetTransaction';
+import type { OrderRepo } from '../../../repo/order';
+import * as factory from '../../../factory';
+declare function isDeliverable(params: {
+    project: {
+        id: string;
+    };
+    orderNumber: string;
+    assetTransactionType: factory.assetTransactionType.Reserve | factory.assetTransactionType.MoneyTransfer | factory.assetTransactionType.RegisterService;
+}): (repos: {
+    acceptedOffer: AcceptedOfferRepo;
+    assetTransaction: AssetTransactionRepo;
+    order: OrderRepo;
+}) => Promise<boolean>;
+export { isDeliverable };

package/lib/chevre/service/order/onAssetTransactionStatusChanged/isDeliverable.js

@@ -0,0 +1,97 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDeliverable = isDeliverable;
+const debug_1 = __importDefault(require("debug"));
+const factory = __importStar(require("../../../factory"));
+const debug = (0, debug_1.default)('chevre-domain:service:order');
+function isDeliverable(params) {
+    return async (repos) => {
+        let allReserveTransactionConfirmed = false;
+        let allMoneyTransferTransactionConfirmed = false;
+        let allRegisterServiceTransactionConfirmed = false;
+        if (params.assetTransactionType === factory.assetTransactionType.Reserve) {
+            allMoneyTransferTransactionConfirmed = true;
+            allRegisterServiceTransactionConfirmed = true;
+            // 注文のreservationNumberを取得
+            const reservationNumbers = await repos.acceptedOffer.distinctValues({ orderNumber: { $in: [params.orderNumber] } }, 'acceptedOffers.itemOffered.reservationNumber');
+            if (reservationNumbers.length > 0) {
+                const referencedReserveTransactions = await repos.assetTransaction.search({
+                    project: { id: { $eq: params.project.id } },
+                    typeOf: factory.assetTransactionType.Reserve,
+                    transactionNumber: { $in: reservationNumbers }
+                }, ['status']);
+                allReserveTransactionConfirmed =
+                    referencedReserveTransactions.length === reservationNumbers.length
+                        && referencedReserveTransactions.every(({ status }) => status === factory.transactionStatusType.Confirmed);
+            }
+            else {
+                allReserveTransactionConfirmed = true;
+            }
+        }
+        else if (params.assetTransactionType === factory.assetTransactionType.MoneyTransfer) {
+            allReserveTransactionConfirmed = true;
+            allRegisterServiceTransactionConfirmed = true;
+            // 注文のMoneyTransferTransaction.transactionNumberを取得
+            const moneyTransferTransactionNumbers = await repos.acceptedOffer.distinctValues({ orderNumber: { $in: [params.orderNumber] } }, 'acceptedOffers.serialNumber');
+            if (moneyTransferTransactionNumbers.length > 0) {
+                debug('is deliverable?...', params.orderNumber, 'moneyTransferTransactionNumbers:', moneyTransferTransactionNumbers);
+                const referencedMoneyTransferTransactions = await repos.assetTransaction.search({
+                    project: { id: { $eq: params.project.id } },
+                    typeOf: factory.assetTransactionType.MoneyTransfer,
+                    transactionNumber: { $in: moneyTransferTransactionNumbers }
+                }, ['status']);
+                allMoneyTransferTransactionConfirmed =
+                    referencedMoneyTransferTransactions.length === moneyTransferTransactionNumbers.length
+                        && referencedMoneyTransferTransactions.every(({ status }) => status === factory.transactionStatusType.Confirmed);
+            }
+            else {
+                allMoneyTransferTransactionConfirmed = true;
+            }
+        }
+        else if (params.assetTransactionType === factory.assetTransactionType.RegisterService) {
+            allReserveTransactionConfirmed = true;
+            allMoneyTransferTransactionConfirmed = true;
+            const registerServiceTransactionNumbers = await repos.acceptedOffer.distinctValues({ orderNumber: { $in: [params.orderNumber] } }, 'acceptedOffers.serialNumber');
+            if (registerServiceTransactionNumbers.length > 0) {
+                const referencedRegisterServiceTransactions = await repos.assetTransaction.search({
+                    project: { id: { $eq: params.project.id } },
+                    typeOf: factory.assetTransactionType.RegisterService,
+                    transactionNumber: { $in: registerServiceTransactionNumbers }
+                }, ['status']);
+                allRegisterServiceTransactionConfirmed =
+                    referencedRegisterServiceTransactions.length === registerServiceTransactionNumbers.length
+                        && referencedRegisterServiceTransactions.every(({ status }) => status === factory.transactionStatusType.Confirmed);
+            }
+            else {
+                allRegisterServiceTransactionConfirmed = true;
+            }
+        }
+        return allReserveTransactionConfirmed && allMoneyTransferTransactionConfirmed && allRegisterServiceTransactionConfirmed;
+    };
+}

package/lib/chevre/service/order/onAssetTransactionStatusChanged/onPayTransactionCanceled.d.ts

@@ -0,0 +1,21 @@
+import type { AcceptedOfferRepo } from '../../../repo/acceptedOffer';
+import type { AssetTransactionRepo } from '../../../repo/assetTransaction';
+import type { OrderRepo } from '../../../repo/order';
+import type { SettingRepo } from '../../../repo/setting';
+import type { TaskRepo } from '../../../repo/task';
+import type { PlaceOrderRepo } from '../../../repo/transaction/placeOrder';
+import * as factory from '../../../factory';
+interface IOnPayTransactionCanceledRepos {
+    acceptedOffer: AcceptedOfferRepo;
+    assetTransaction: AssetTransactionRepo;
+    order: OrderRepo;
+    setting: SettingRepo;
+    task: TaskRepo;
+    placeOrder: PlaceOrderRepo;
+}
+declare function onPayTransactionCanceled(params: factory.task.onAssetTransactionStatusChanged.IData & {
+    object: factory.task.onAssetTransactionStatusChanged.IObjectAsPayTransaction & {
+        status: factory.transactionStatusType.Canceled | factory.transactionStatusType.Expired;
+    };
+}): (repos: IOnPayTransactionCanceledRepos) => Promise<void>;
+export { IOnPayTransactionCanceledRepos, onPayTransactionCanceled, };

package/lib/chevre/service/order/onAssetTransactionStatusChanged/onPayTransactionCanceled.js

@@ -0,0 +1,86 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onPayTransactionCanceled = onPayTransactionCanceled;
+const findPlaceOrderTransaction_1 = require("../findPlaceOrderTransaction");
+const onOrderStatusChanged_1 = require("../onOrderStatusChanged");
+const factory = __importStar(require("../../../factory"));
+function onPayTransactionCanceled(params) {
+    return async (repos
+    // settings: Settings
+    ) => {
+        if (typeof params.useOnOrderStatusChanged !== 'boolean') {
+            throw new factory.errors.Argument('useOnOrderStatusChanged', 'must be boolean');
+        }
+        // 注文が存在すればキャンセル(2023-08-30~)
+        await cancelOrderIfExist({
+            project: { id: params.project.id },
+            paymentMethodId: params.object.transactionNumber,
+            useOnOrderStatusChanged: params.useOnOrderStatusChanged
+        })(repos);
+    };
+}
+function cancelOrderIfExist(params) {
+    return async (repos) => {
+        if (params.paymentMethodId.length === 0) {
+            return;
+        }
+        // 注文のpaymentMethodIdを取得
+        const ordersByPaymentMethodId = await repos.order.projectFields({
+            limit: 1,
+            page: 1,
+            paymentMethods: {
+                paymentMethodIds: [params.paymentMethodId]
+            },
+            project: { id: { $eq: params.project.id } }
+        }, { inclusion: ['confirmationNumber', 'orderNumber'] });
+        const orderByPaymentMethodId = ordersByPaymentMethodId.shift();
+        if (orderByPaymentMethodId !== undefined) {
+            const placeOrderTransaction = await (0, findPlaceOrderTransaction_1.findPlaceOrderTransaction)({
+                project: { id: params.project.id },
+                confirmationNumber: orderByPaymentMethodId.confirmationNumber,
+                orderNumber: orderByPaymentMethodId.orderNumber
+            })(repos);
+            const order = await repos.order.changeStatus({
+                project: { id: params.project.id },
+                orderNumber: orderByPaymentMethodId.orderNumber,
+                orderStatus: factory.orderStatus.OrderCancelled,
+                previousOrderStatus: factory.orderStatus.OrderPaymentDue
+            });
+            if (params.useOnOrderStatusChanged) {
+                await (0, onOrderStatusChanged_1.onOrderCancelled)({
+                    order: {
+                        orderDate: order.orderDate,
+                        orderNumber: order.orderNumber,
+                        orderStatus: factory.orderStatus.OrderCancelled // 強制的にOrderCancelledとして処理する
+                    },
+                    placeOrderTransaction
+                })({
+                    task: repos.task
+                });
+            }
+        }
+    };
+}

package/lib/chevre/service/order/onAssetTransactionStatusChanged/onPayTransactionConfirmed.d.ts

@@ -0,0 +1,22 @@
+import type { AcceptedOfferRepo } from '../../../repo/acceptedOffer';
+import type { AssetTransactionRepo } from '../../../repo/assetTransaction';
+import type { OrderRepo } from '../../../repo/order';
+import type { SettingRepo } from '../../../repo/setting';
+import type { TaskRepo } from '../../../repo/task';
+import type { PlaceOrderRepo } from '../../../repo/transaction/placeOrder';
+import * as factory from '../../../factory';
+import { Settings } from '../../../settings';
+interface IOnPayTransactionConfirmedRepos {
+    acceptedOffer: AcceptedOfferRepo;
+    assetTransaction: AssetTransactionRepo;
+    order: OrderRepo;
+    setting: SettingRepo;
+    task: TaskRepo;
+    placeOrder: PlaceOrderRepo;
+}
+declare function onPayTransactionConfirmed(params: factory.task.onAssetTransactionStatusChanged.IData & {
+    object: factory.task.onAssetTransactionStatusChanged.IObjectAsPayTransaction & {
+        status: factory.transactionStatusType.Confirmed;
+    };
+}): (repos: IOnPayTransactionConfirmedRepos, settings: Settings) => Promise<void>;
+export { IOnPayTransactionConfirmedRepos, onPayTransactionConfirmed };

package/lib/chevre/service/order/onAssetTransactionStatusChanged/onPayTransactionConfirmed.js

@@ -0,0 +1,112 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onPayTransactionConfirmed = onPayTransactionConfirmed;
+const paymentDue2Processing_1 = require("../onAssetTransactionStatusChanged/paymentDue2Processing");
+const factory = __importStar(require("../../../factory"));
+function onPayTransactionConfirmed(params) {
+    return async (repos, settings) => {
+        if (typeof params.useOnOrderStatusChanged !== 'boolean') {
+            throw new factory.errors.Argument('useOnOrderStatusChanged', 'must be boolean');
+        }
+        const orderNumber = params.purpose?.orderNumber;
+        const confirmationNumber = params.purpose?.confirmationNumber;
+        // 確定時の決済方法区分指定(2023-08-29~)
+        const specifiedPaymentMethodIdentifire = params.object?.object?.paymentMethod?.identifier;
+        if (typeof specifiedPaymentMethodIdentifire === 'string' && specifiedPaymentMethodIdentifire.length > 0) {
+            await fixPaymentMethodIdentifierIfPossible({
+                project: { id: params.project.id },
+                paymentMethodId: params.object.transactionNumber,
+                paymentMethod: { identifier: specifiedPaymentMethodIdentifire },
+                referencesOrder: { orderNumber }
+            })(repos);
+        }
+        if (typeof orderNumber === 'string' && typeof confirmationNumber === 'string') {
+            // PayTransactionのステータス検証
+            const processable = await isProcessable({ project: { id: params.project.id }, orderNumber })(repos);
+            if (processable) {
+                await (0, paymentDue2Processing_1.paymentDue2Processing)({
+                    project: { id: params.project.id },
+                    confirmationNumber,
+                    orderNumber,
+                    useOnOrderStatusChanged: params.useOnOrderStatusChanged
+                })(repos, settings);
+            }
+        }
+    };
+}
+function fixPaymentMethodIdentifierIfPossible(params) {
+    return async (repos) => {
+        const referencedPayTransactions = await repos.assetTransaction.search({
+            project: { id: { $eq: params.project.id } },
+            typeOf: factory.assetTransactionType.Pay,
+            statuses: [factory.transactionStatusType.Confirmed],
+            transactionNumber: { $in: [params.paymentMethodId] }
+        }, ['object']);
+        const referencedPayTransaction = referencedPayTransactions.shift();
+        if (referencedPayTransaction === undefined) {
+            throw new factory.errors.NotFound(factory.assetTransactionType.Pay);
+        }
+        // 対面決済かつ決済取引上の決済方法区分と一致すれば、注文を変更
+        if (referencedPayTransaction.object.typeOf === factory.service.paymentService.PaymentServiceType.FaceToFace
+            && referencedPayTransaction.object.paymentMethod.identifier === params.paymentMethod.identifier) {
+            await repos.order.fixPaymentMethodIdentifier({
+                project: { id: params.project.id },
+                orderNumber: params.referencesOrder.orderNumber,
+                invoice: {
+                    paymentMethodId: params.paymentMethodId,
+                    paymentMethod: { identifier: params.paymentMethod.identifier }
+                }
+            });
+        }
+    };
+}
+function isProcessable(params) {
+    return async (repos) => {
+        // 注文のpaymentMethodIdを取得
+        const order = await repos.order.projectFieldsByOrderNumber({
+            orderNumber: params.orderNumber,
+            project: { id: params.project.id },
+            inclusion: ['paymentMethods']
+        });
+        // PayTransactionのステータス検証
+        let allPayTransactionConfirmed;
+        const paymentMethodIds = order.paymentMethods.filter((invoice) => typeof invoice.paymentMethodId === 'string' && invoice.paymentMethodId.length > 0)
+            .map((invoice) => invoice.paymentMethodId);
+        if (paymentMethodIds.length > 0) {
+            const referencedPayTransactions = await repos.assetTransaction.search({
+                project: { id: { $eq: params.project.id } },
+                typeOf: factory.assetTransactionType.Pay,
+                transactionNumber: { $in: paymentMethodIds }
+            }, ['status']);
+            allPayTransactionConfirmed =
+                referencedPayTransactions.every((payTransation) => payTransation.status === factory.transactionStatusType.Confirmed);
+        }
+        else {
+            allPayTransactionConfirmed = true;
+        }
+        return allPayTransactionConfirmed;
+    };
+}

package/lib/chevre/service/order/onAssetTransactionStatusChanged/onReserveTransactionConfirmed.d.ts

@@ -0,0 +1,22 @@
+import type { AcceptedOfferRepo } from '../../../repo/acceptedOffer';
+import type { AssetTransactionRepo } from '../../../repo/assetTransaction';
+import type { OrderRepo } from '../../../repo/order';
+import type { SettingRepo } from '../../../repo/setting';
+import type { TaskRepo } from '../../../repo/task';
+import type { PlaceOrderRepo } from '../../../repo/transaction/placeOrder';
+import * as factory from '../../../factory';
+import { Settings } from '../../../settings';
+interface IOnReserveTransactionConfirmedRepos {
+    acceptedOffer: AcceptedOfferRepo;
+    assetTransaction: AssetTransactionRepo;
+    order: OrderRepo;
+    setting: SettingRepo;
+    task: TaskRepo;
+    placeOrder: PlaceOrderRepo;
+}
+declare function onReserveTransactionConfirmed(params: factory.task.onAssetTransactionStatusChanged.IData & {
+    object: factory.task.onAssetTransactionStatusChanged.IObjectAsReserveTransaction & {
+        status: factory.transactionStatusType.Confirmed;
+    };
+}): (repos: IOnReserveTransactionConfirmedRepos, settings: Settings) => Promise<void>;
+export { IOnReserveTransactionConfirmedRepos, onReserveTransactionConfirmed, };