@chevre/domain 24.0.0-alpha.12 → 24.0.0-alpha.14

package/lib/chevre/service/notification/triggerWebhook.d.ts

@@ -2,13 +2,14 @@ import * as factory from '../../factory';
 import type { ActionRepo } from '../../repo/action';
 import type { PotentialActionRepo } from '../../repo/potentialAction';
 import type { SettingRepo } from '../../repo/setting';
+interface ITriggerWebhookRepos {
+    action: ActionRepo;
+    potentialAction: PotentialActionRepo;
+    setting: SettingRepo;
+}
 declare function triggerWebhook(params: factory.task.IData<factory.taskName.TriggerWebhook> & {
     project: {
         id: string;
     };
-}): (repos: {
-    action: ActionRepo;
-    potentialAction: PotentialActionRepo;
-    setting: SettingRepo;
-}) => Promise<void>;
-export { triggerWebhook };
+}): (repos: ITriggerWebhookRepos) => Promise<void>;
+export { ITriggerWebhookRepos, triggerWebhook };

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

@@ -40,4 +40,4 @@ declare function voidTransactionByActionId(params: factory.task.IData<factory.ta
         id: string;
     };
 }): (repos: IVoidTransactionByActionIdRepos, settings: Settings) => Promise<void>;
-export { voidTransactionByActionId };
+export { IVoidTransactionByActionIdRepos, voidTransactionByActionId };

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, };

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

@@ -0,0 +1,74 @@
+"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.onReserveTransactionConfirmed = onReserveTransactionConfirmed;
+const isDeliverable_1 = require("./isDeliverable");
+const processing2inTransit_1 = require("./processing2inTransit");
+const factory = __importStar(require("../../../factory"));
+function onReserveTransactionConfirmed(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;
+        switch (params.object.typeOf) {
+            case factory.assetTransactionType.COAReserveTransaction:
+                if (typeof orderNumber === 'string' && typeof confirmationNumber === 'string') {
+                    // 基本的に1注文に1予約番号なのでdeliverable = true
+                    const deliverable = true;
+                    if (deliverable) {
+                        await (0, processing2inTransit_1.processing2inTransit)({
+                            project: { id: params.project.id },
+                            // confirmationNumber,
+                            orderNumber,
+                            useOnOrderStatusChanged: params.useOnOrderStatusChanged
+                        })(repos, settings);
+                    }
+                }
+                break;
+            case factory.assetTransactionType.Reserve:
+                if (typeof orderNumber === 'string' && typeof confirmationNumber === 'string') {
+                    // ReserveTransactionのステータス検証
+                    const deliverable = await (0, isDeliverable_1.isDeliverable)({
+                        project: { id: params.project.id },
+                        orderNumber,
+                        assetTransactionType: params.object.typeOf
+                    })(repos);
+                    if (deliverable) {
+                        await (0, processing2inTransit_1.processing2inTransit)({
+                            project: { id: params.project.id },
+                            // confirmationNumber,
+                            orderNumber,
+                            useOnOrderStatusChanged: params.useOnOrderStatusChanged
+                        })(repos, settings);
+                    }
+                }
+                break;
+            default:
+            // no op
+        }
+    };
+}

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

@@ -4,6 +4,16 @@ import type { SettingRepo } from '../../../repo/setting';
 import type { TaskRepo } from '../../../repo/task';
 import type { PlaceOrderRepo } from '../../../repo/transaction/placeOrder';
 import { Settings } from '../../../settings';
+interface IPaymentDue2ProcessingRepos {
+    acceptedOffer: AcceptedOfferRepo;
+    order: OrderRepo;
+    setting: SettingRepo;
+    task: TaskRepo;
+    placeOrder: PlaceOrderRepo;
+}
+/**
+ * 全決済取引確定を完了した注文に関して、アイテムを処理する
+ */
 declare function paymentDue2Processing(params: {
     project: {
         id: string;
@@ -11,11 +21,5 @@ declare function paymentDue2Processing(params: {
     confirmationNumber: string;
     orderNumber: string;
     useOnOrderStatusChanged: boolean;
-}): (repos: {
-    acceptedOffer: AcceptedOfferRepo;
-    order: OrderRepo;
-    setting: SettingRepo;
-    task: TaskRepo;
-    placeOrder: PlaceOrderRepo;
-}, settings: Settings) => Promise<void>;
-export { paymentDue2Processing, };
+}): (repos: IPaymentDue2ProcessingRepos, settings: Settings) => Promise<void>;
+export { IPaymentDue2ProcessingRepos, paymentDue2Processing, };

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

@@ -32,6 +32,9 @@ const findPlaceOrderTransaction_1 = require("../findPlaceOrderTransaction");
 const onOrderStatusChanged_1 = require("../onOrderStatusChanged");
 const factory = __importStar(require("../../../factory"));
 const debug = (0, debug_1.default)('chevre-domain:service:order');
+/**
+ * 全決済取引確定を完了した注文に関して、アイテムを処理する
+ */
 function paymentDue2Processing(params) {
     return async (repos, settings) => {
         const placeOrderTransaction = await (0, findPlaceOrderTransaction_1.findPlaceOrderTransaction)({

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

@@ -0,0 +1,16 @@
+import type { OrderRepo } from '../../../repo/order';
+import type { TaskRepo } from '../../../repo/task';
+import type { PlaceOrderRepo } from '../../../repo/transaction/placeOrder';
+import { Settings } from '../../../settings';
+declare function processing2inTransit(params: {
+    project: {
+        id: string;
+    };
+    orderNumber: string;
+    useOnOrderStatusChanged: boolean;
+}): (repos: {
+    order: OrderRepo;
+    task: TaskRepo;
+    placeOrder: PlaceOrderRepo;
+}, settings: Settings) => Promise<void>;
+export { processing2inTransit };

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

@@ -0,0 +1,74 @@
+"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.processing2inTransit = processing2inTransit;
+const onOrderStatusChanged_1 = require("../onOrderStatusChanged");
+const factory = __importStar(require("../../../factory"));
+function processing2inTransit(params) {
+    return async (repos, settings) => {
+        // const existingOrder: Pick<factory.order.IOrder, 'project'> = await repos.order.projectFieldsByOrderNumber({
+        //     orderNumber: params.orderNumber,
+        //     project: { id: params.project.id },
+        //     inclusion: ['project']
+        // });
+        let order;
+        try {
+            order = await repos.order.changeStatus({
+                project: { id: params.project.id },
+                orderNumber: params.orderNumber,
+                orderStatus: factory.orderStatus.OrderInTransit,
+                previousOrderStatus: factory.orderStatus.OrderProcessing
+            });
+        }
+        catch (error) {
+            let throwsError = true;
+            // すでにステータスが進行していた場合、OrderProcessing->OrderInTransitの処理自体は成功しているので、後処理を続行する
+            order = await repos.order.projectFieldsByOrderNumber({
+                orderNumber: params.orderNumber,
+                project: { id: params.project.id },
+                inclusion: [
+                    'orderNumber', 'broker', 'confirmationNumber', 'customer', 'dateReturned',
+                    'name', 'orderDate', 'orderStatus', 'orderedItem', 'paymentMethods',
+                    'previousOrderStatus', 'price', 'priceCurrency', 'project', 'returner', 'seller', 'typeOf'
+                ] // explicit projection(2024-07-25~)
+            });
+            if (order.orderStatus === factory.orderStatus.OrderDelivered
+                || order.orderStatus === factory.orderStatus.OrderReturned) {
+                throwsError = false;
+            }
+            if (throwsError) {
+                throw error;
+            }
+        }
+        if (params.useOnOrderStatusChanged) {
+            await (0, onOrderStatusChanged_1.onOrderInTransit)({
+                order: {
+                    ...order,
+                    orderStatus: factory.orderStatus.OrderInTransit
+                }
+            })(repos, settings);
+        }
+    };
+}

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

@@ -5,6 +5,7 @@ import type { SettingRepo } from '../../repo/setting';
 import type { TaskRepo } from '../../repo/task';
 import type { PlaceOrderRepo } from '../../repo/transaction/placeOrder';
 import { paymentDue2Processing } from './onAssetTransactionStatusChanged/paymentDue2Processing';
+import { processing2inTransit } from './onAssetTransactionStatusChanged/processing2inTransit';
 import * as factory from '../../factory';
 import { Settings } from '../../settings';
 interface IOnAssetTransactionStatusChangedRepos {
@@ -16,15 +17,4 @@ interface IOnAssetTransactionStatusChangedRepos {
     placeOrder: PlaceOrderRepo;
 }
 declare function onAssetTransactionStatusChanged(params: factory.task.IData<factory.taskName.OnAssetTransactionStatusChanged>): (repos: IOnAssetTransactionStatusChangedRepos, settings: Settings) => Promise<void>;
-declare function processing2inTransit(params: {
-    project: {
-        id: string;
-    };
-    orderNumber: string;
-    useOnOrderStatusChanged: boolean;
-}): (repos: {
-    order: OrderRepo;
-    task: TaskRepo;
-    placeOrder: PlaceOrderRepo;
-}, settings: Settings) => Promise<void>;
 export { IOnAssetTransactionStatusChangedRepos, onAssetTransactionStatusChanged, paymentDue2Processing, processing2inTransit };

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

@@ -22,20 +22,18 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __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.paymentDue2Processing = void 0;
+exports.processing2inTransit = exports.paymentDue2Processing = void 0;
 exports.onAssetTransactionStatusChanged = onAssetTransactionStatusChanged;
-exports.processing2inTransit = processing2inTransit;
-const debug_1 = __importDefault(require("debug"));
-const findPlaceOrderTransaction_1 = require("./findPlaceOrderTransaction");
-const onOrderStatusChanged_1 = require("./onOrderStatusChanged");
+const isDeliverable_1 = require("./onAssetTransactionStatusChanged/isDeliverable");
+const onPayTransactionCanceled_1 = require("./onAssetTransactionStatusChanged/onPayTransactionCanceled");
+const onPayTransactionConfirmed_1 = require("./onAssetTransactionStatusChanged/onPayTransactionConfirmed");
+const onReserveTransactionConfirmed_1 = require("./onAssetTransactionStatusChanged/onReserveTransactionConfirmed");
 const paymentDue2Processing_1 = require("./onAssetTransactionStatusChanged/paymentDue2Processing");
 Object.defineProperty(exports, "paymentDue2Processing", { enumerable: true, get: function () { return paymentDue2Processing_1.paymentDue2Processing; } });
+const processing2inTransit_1 = require("./onAssetTransactionStatusChanged/processing2inTransit");
+Object.defineProperty(exports, "processing2inTransit", { enumerable: true, get: function () { return processing2inTransit_1.processing2inTransit; } });
 const factory = __importStar(require("../../factory"));
-const debug = (0, debug_1.default)('chevre-domain:service:order');
 function onAssetTransactionStatusChanged(params) {
     return async (repos, settings) => {
         if (typeof params.useOnOrderStatusChanged !== 'boolean') {
@@ -47,70 +45,41 @@ function onAssetTransactionStatusChanged(params) {
                 const confirmationNumber = params.purpose?.confirmationNumber;
                 switch (params.object.typeOf) {
                     case factory.assetTransactionType.Pay:
-                        // 確定時の決済方法区分指定(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);
+                        await (0, onPayTransactionConfirmed_1.onPayTransactionConfirmed)({
+                            ...params,
+                            object: {
+                                ...params.object,
+                                status: params.object.status
                             }
-                        }
+                        })(repos, settings);
                         break;
                     case factory.assetTransactionType.COAReserveTransaction:
-                        if (typeof orderNumber === 'string' && typeof confirmationNumber === 'string') {
-                            // 基本的に1注文に1予約番号なのでdeliverable = true
-                            const deliverable = true;
-                            if (deliverable) {
-                                await processing2inTransit({
-                                    project: { id: params.project.id },
-                                    // confirmationNumber,
-                                    orderNumber,
-                                    useOnOrderStatusChanged: params.useOnOrderStatusChanged
-                                })(repos, settings);
+                        await (0, onReserveTransactionConfirmed_1.onReserveTransactionConfirmed)({
+                            ...params,
+                            object: {
+                                ...params.object,
+                                status: params.object.status
                             }
-                        }
+                        })(repos, settings);
                         break;
                     case factory.assetTransactionType.Reserve:
-                        if (typeof orderNumber === 'string' && typeof confirmationNumber === 'string') {
-                            // ReserveTransactionのステータス検証
-                            const deliverable = await isDeliverable({
-                                project: { id: params.project.id },
-                                orderNumber,
-                                assetTransactionType: params.object.typeOf
-                            })(repos);
-                            if (deliverable) {
-                                await processing2inTransit({
-                                    project: { id: params.project.id },
-                                    // confirmationNumber,
-                                    orderNumber,
-                                    useOnOrderStatusChanged: params.useOnOrderStatusChanged
-                                })(repos, settings);
+                        await (0, onReserveTransactionConfirmed_1.onReserveTransactionConfirmed)({
+                            ...params,
+                            object: {
+                                ...params.object,
+                                status: params.object.status
                             }
-                        }
+                        })(repos, settings);
                         break;
                     case factory.assetTransactionType.MoneyTransfer:
                         if (typeof orderNumber === 'string' && typeof confirmationNumber === 'string') {
-                            const deliverable = await isDeliverable({
+                            const deliverable = await (0, isDeliverable_1.isDeliverable)({
                                 project: { id: params.project.id },
                                 orderNumber,
                                 assetTransactionType: params.object.typeOf
                             })(repos);
                             if (deliverable) {
-                                await processing2inTransit({
+                                await (0, processing2inTransit_1.processing2inTransit)({
                                     project: { id: params.project.id },
                                     // confirmationNumber,
                                     orderNumber,
@@ -121,13 +90,13 @@ function onAssetTransactionStatusChanged(params) {
                         break;
                     case factory.assetTransactionType.RegisterService:
                         if (typeof orderNumber === 'string' && typeof confirmationNumber === 'string') {
-                            const deliverable = await isDeliverable({
+                            const deliverable = await (0, isDeliverable_1.isDeliverable)({
                                 project: { id: params.project.id },
                                 orderNumber,
                                 assetTransactionType: params.object.typeOf
                             })(repos);
                             if (deliverable) {
-                                await processing2inTransit({
+                                await (0, processing2inTransit_1.processing2inTransit)({
                                     project: { id: params.project.id },
                                     // confirmationNumber,
                                     orderNumber,
@@ -144,11 +113,12 @@ function onAssetTransactionStatusChanged(params) {
             case factory.transactionStatusType.Expired:
                 switch (params.object.typeOf) {
                     case factory.assetTransactionType.Pay:
-                        // 注文が存在すればキャンセル(2023-08-30~)
-                        await cancelOrderIfExist({
-                            project: { id: params.project.id },
-                            paymentMethodId: params.object.transactionNumber,
-                            useOnOrderStatusChanged: params.useOnOrderStatusChanged
+                        await (0, onPayTransactionCanceled_1.onPayTransactionCanceled)({
+                            ...params,
+                            object: {
+                                ...params.object,
+                                status: params.object.status
+                            }
                         })(repos);
                         break;
                     default:
@@ -160,209 +130,3 @@ function onAssetTransactionStatusChanged(params) {
         }
     };
 }
-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;
-    };
-}
-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
-                });
-            }
-        }
-    };
-}
-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;
-    };
-}
-function processing2inTransit(params) {
-    return async (repos, settings) => {
-        // const existingOrder: Pick<factory.order.IOrder, 'project'> = await repos.order.projectFieldsByOrderNumber({
-        //     orderNumber: params.orderNumber,
-        //     project: { id: params.project.id },
-        //     inclusion: ['project']
-        // });
-        let order;
-        try {
-            order = await repos.order.changeStatus({
-                project: { id: params.project.id },
-                orderNumber: params.orderNumber,
-                orderStatus: factory.orderStatus.OrderInTransit,
-                previousOrderStatus: factory.orderStatus.OrderProcessing
-            });
-        }
-        catch (error) {
-            let throwsError = true;
-            // すでにステータスが進行していた場合、OrderProcessing->OrderInTransitの処理自体は成功しているので、後処理を続行する
-            order = await repos.order.projectFieldsByOrderNumber({
-                orderNumber: params.orderNumber,
-                project: { id: params.project.id },
-                inclusion: [
-                    'orderNumber', 'broker', 'confirmationNumber', 'customer', 'dateReturned',
-                    'name', 'orderDate', 'orderStatus', 'orderedItem', 'paymentMethods',
-                    'previousOrderStatus', 'price', 'priceCurrency', 'project', 'returner', 'seller', 'typeOf'
-                ] // explicit projection(2024-07-25~)
-            });
-            if (order.orderStatus === factory.orderStatus.OrderDelivered
-                || order.orderStatus === factory.orderStatus.OrderReturned) {
-                throwsError = false;
-            }
-            if (throwsError) {
-                throw error;
-            }
-        }
-        if (params.useOnOrderStatusChanged) {
-            await (0, onOrderStatusChanged_1.onOrderInTransit)({
-                order: {
-                    ...order,
-                    orderStatus: factory.orderStatus.OrderInTransit
-                }
-            })(repos, settings);
-        }
-    };
-}

package/lib/chevre/service/order/onOrderStatusChanged/onOrderDelivered.d.ts

@@ -1,14 +1,13 @@
 import * as factory from '../../../factory';
 import type { SettingRepo } from '../../../repo/setting';
 import type { TaskRepo } from '../../../repo/task';
-type IPlaceOrderTransaction = Pick<factory.transaction.placeOrder.ITransaction, 'id' | 'project' | 'typeOf' | 'potentialActions'>;
+interface IOnOrderDeliveredRepos {
+    setting: SettingRepo;
+    task: TaskRepo;
+}
 declare function onOrderDelivered(params: {
     order: Pick<factory.order.IOrder, 'id' | 'customer' | 'orderDate' | 'orderNumber' | 'project' | 'typeOf' | 'price' | 'priceCurrency'> & {
         orderStatus: factory.orderStatus.OrderDelivered;
     };
-    placeOrderTransaction?: IPlaceOrderTransaction;
-}): (repos: {
-    setting: SettingRepo;
-    task: TaskRepo;
-}) => Promise<void>;
-export { onOrderDelivered };
+}): (repos: IOnOrderDeliveredRepos) => Promise<void>;
+export { IOnOrderDeliveredRepos, onOrderDelivered };

package/lib/chevre/service/order/onOrderStatusChanged/onOrderDeliveredPartially.d.ts

@@ -1,10 +1,11 @@
 import type { SettingRepo } from '../../../repo/setting';
 import type { TaskRepo } from '../../../repo/task';
 import { IInTransitOrder } from './onOrderDeliveredPartially/factory';
-declare function onOrderDeliveredPartially(params: {
-    order: IInTransitOrder;
-}): (repos: {
+interface IOnOrderDeliveredPartiallyRepos {
     setting: SettingRepo;
     task: TaskRepo;
-}) => Promise<void>;
-export { onOrderDeliveredPartially };
+}
+declare function onOrderDeliveredPartially(params: {
+    order: IInTransitOrder;
+}): (repos: IOnOrderDeliveredPartiallyRepos) => Promise<void>;
+export { IOnOrderDeliveredPartiallyRepos, onOrderDeliveredPartially };

package/lib/chevre/service/order/onOrderStatusChanged/onOrderInTransit.d.ts

@@ -2,12 +2,13 @@ import type { TaskRepo } from '../../../repo/task';
 import type { PlaceOrderRepo } from '../../../repo/transaction/placeOrder';
 import * as factory from '../../../factory';
 import { Settings } from '../../../settings';
+interface IOnOrderInTransitRepos {
+    task: TaskRepo;
+    placeOrder: PlaceOrderRepo;
+}
 declare function onOrderInTransit(params: {
     order: Pick<factory.order.IOrder, 'id' | 'orderNumber' | 'broker' | 'confirmationNumber' | 'customer' | 'dateReturned' | 'name' | 'orderDate' | 'orderedItem' | 'paymentMethods' | 'previousOrderStatus' | 'price' | 'priceCurrency' | 'project' | 'returner' | 'seller' | 'typeOf'> & {
         orderStatus: factory.orderStatus.OrderInTransit;
     };
-}): (repos: {
-    task: TaskRepo;
-    placeOrder: PlaceOrderRepo;
-}, settings: Settings) => Promise<void>;
-export { onOrderInTransit };
+}): (repos: IOnOrderInTransitRepos, settings: Settings) => Promise<void>;
+export { IOnOrderInTransitRepos, onOrderInTransit };

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

@@ -6,8 +6,7 @@ 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';
-type ISendOperation<T> = (repos: {
+interface ISendOrderRepos {
     acceptedOffer: AcceptedOfferRepo;
     action: ActionRepo;
     order: OrderRepo;
@@ -15,7 +14,8 @@ type ISendOperation<T> = (repos: {
     setting: SettingRepo;
     task: TaskRepo;
     placeOrder: PlaceOrderRepo;
-}, settings: Settings) => Promise<T>;
+}
+type ISendOperation<T> = (repos: ISendOrderRepos) => Promise<T>;
 /**
  * 注文を配送する
  */
@@ -35,4 +35,4 @@ declare function sendOrder(params: {
     };
     useOnOrderStatusChanged: boolean;
 }): ISendOperation<void>;
-export { sendOrder };
+export { ISendOrderRepos, sendOrder };

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

@@ -30,9 +30,10 @@ exports.sendOrder = sendOrder;
 const debug_1 = __importDefault(require("debug"));
 // import { createMaskedCustomer } from '../../factory/order';
 const factory_1 = require("../delivery/factory");
-const findPlaceOrderTransaction_1 = require("./findPlaceOrderTransaction");
+// import { findPlaceOrderTransaction } from './findPlaceOrderTransaction';
 const onOrderStatusChanged_1 = require("./onOrderStatusChanged");
 const factory = __importStar(require("../../factory"));
+// import { Settings } from '../../settings';
 const debug = (0, debug_1.default)('chevre-domain:service:order');
 /**
  * 注文を配送する
@@ -59,11 +60,11 @@ function sendOrder(params) {
         try {
             const orderNumber = params.object.orderNumber;
             const confirmationNumber = params.object.confirmationNumber;
-            const placeOrderTransaction = await (0, findPlaceOrderTransaction_1.findPlaceOrderTransaction)({
-                project: { id: params.project.id },
-                confirmationNumber,
-                orderNumber
-            })(repos);
+            // const placeOrderTransaction = await findPlaceOrderTransaction({
+            //     project: { id: params.project.id },
+            //     confirmationNumber,
+            //     orderNumber
+            // })(repos);
             // 注文取得
             let order = await repos.order.projectFieldsByOrderNumber({
                 orderNumber,
@@ -127,6 +128,7 @@ function sendOrder(params) {
                 });
                 acceptedOffers = searchSlicedAcceptedOffersResult.acceptedOffers;
                 debug('delivering...', order.orderNumber, acceptedOffers.map((offer) => `${offer.itemOffered.id}`), params.object.acceptedOffers, 'offerIndexBase:', offerIndexBase);
+                console.log('createOwnerships:', createOwnerships);
                 // 所有権作成
                 if (createOwnerships) {
                     creatingOwnershipInfos = (0, factory_1.createOwnershipInfosFromOrder)({
@@ -180,8 +182,8 @@ function sendOrder(params) {
                             orderStatus: factory.orderStatus.OrderDelivered,
                             price: order.price,
                             priceCurrency: order.priceCurrency
-                        },
-                        placeOrderTransaction
+                        }
+                        // placeOrderTransaction
                     })(repos);
                 }
                 else {

package/lib/chevre/service/payment/any/onPayActionCompleted.d.ts

@@ -5,9 +5,13 @@ import * as factory from '../../../factory';
 import type { AccountingReportRepo } from '../../../repo/accountingReport';
 import type { ActionRepo } from '../../../repo/action';
 import type { TaskRepo } from '../../../repo/task';
-declare function onPayActionCompleted(payAction: Pick<factory.action.trade.pay.IAction, 'id' | 'object' | 'potentialActions' | 'project' | 'purpose' | 'typeOf'>): (repos: {
+interface IOnPayActionCompletedRepos {
     action: ActionRepo;
     accountingReport: AccountingReportRepo;
     task: TaskRepo;
-}) => Promise<void>;
-export { onPayActionCompleted };
+}
+/**
+ * 決済アクション完了時処理
+ */
+declare function onPayActionCompleted(payAction: Pick<factory.action.trade.pay.IAction, 'id' | 'object' | 'potentialActions' | 'project' | 'purpose' | 'typeOf'>): (repos: IOnPayActionCompletedRepos) => Promise<void>;
+export { IOnPayActionCompletedRepos, onPayActionCompleted };

package/lib/chevre/service/payment/any/onPayActionCompleted.js

@@ -30,6 +30,9 @@ exports.onPayActionCompleted = onPayActionCompleted;
 const factory = __importStar(require("../../../factory"));
 const factory_1 = require("./factory");
 const onPaymentStatusChanged_1 = require("./onPaymentStatusChanged");
+/**
+ * 決済アクション完了時処理
+ */
 function onPayActionCompleted(payAction) {
     return async (repos) => {
         const aciton4inform = (0, factory_1.optimizeAction4inform)(payAction);

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

@@ -37,7 +37,7 @@ const sendOrder_1 = require("../order/sendOrder");
  * タスク実行関数
  */
 function call(data) {
-    return async ({ connection, settings }) => {
+    return async ({ connection }) => {
         await (0, sendOrder_1.sendOrder)({
             ...data,
             object: {
@@ -58,6 +58,6 @@ function call(data) {
             setting: new setting_1.SettingRepo(connection),
             task: new task_1.TaskRepo(connection),
             placeOrder: new placeOrder_1.PlaceOrderRepo(connection)
-        }, settings);
+        });
     };
 }

package/package.json

@@ -11,8 +11,8 @@
   "dependencies": {
     "@aws-sdk/client-cognito-identity-provider": "3.600.0",
     "@aws-sdk/credential-providers": "3.600.0",
-    "@chevre/factory": "5.4.0-alpha.31",
-    "@cinerino/sdk": "13.0.0",
+    "@chevre/factory": "5.4.0-alpha.32",
+    "@cinerino/sdk": "13.1.0",
     "@motionpicture/coa-service": "9.6.0",
     "@motionpicture/gmo-service": "5.4.0-alpha.1",
     "@sendgrid/client": "8.1.4",
@@ -99,5 +99,5 @@
     "postversion": "git push origin --tags",
     "prepublishOnly": "npm run clean && npm run build"
   },
-  "version": "24.0.0-alpha.12"
+  "version": "24.0.0-alpha.14"
 }