@chevre/domain 24.0.0-alpha.11 → 24.0.0-alpha.13

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

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

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

@@ -0,0 +1,111 @@
+"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.paymentDue2Processing = paymentDue2Processing;
+const debug_1 = __importDefault(require("debug"));
+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)({
+            project: { id: params.project.id },
+            confirmationNumber: params.confirmationNumber,
+            orderNumber: params.orderNumber
+        })(repos);
+        // 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.OrderProcessing,
+                previousOrderStatus: factory.orderStatus.OrderPaymentDue
+            });
+        }
+        catch (error) {
+            let throwsError = true;
+            // すでにステータスが進行していた場合、OrderPaymentDue->OrderProcessingの処理自体は成功しているので、後処理を続行する
+            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.OrderInTransit
+                || order.orderStatus === factory.orderStatus.OrderDelivered
+                || order.orderStatus === factory.orderStatus.OrderReturned) {
+                throwsError = false;
+            }
+            if (throwsError) {
+                throw error;
+            }
+        }
+        if (params.useOnOrderStatusChanged) {
+            // 全acceptedOffersを検索(2023-12-08~)
+            // const acceptedOffers = await repos.acceptedOffer.searchAcceptedOffersByOrderNumber(
+            //     {
+            //         orderNumber: { $eq: order.orderNumber },
+            //         project: { id: { $eq: params.project.id } }
+            //     },
+            //     ['itemOffered', 'offeredThrough']
+            // );
+            const { numAcceptedOffers } = await repos.acceptedOffer.countByOrderNumber({
+                orderNumber: { $eq: order.orderNumber },
+                project: { id: { $eq: params.project.id } }
+            });
+            const itemOfferedTypeOfs = await repos.acceptedOffer.distinctValues({ orderNumber: { $in: [params.orderNumber] } }, 'acceptedOffers.itemOffered.typeOf');
+            const serialNumbers = await repos.acceptedOffer.distinctValues({ orderNumber: { $in: [params.orderNumber] } }, 'acceptedOffers.serialNumber');
+            const offeredThroughIdentifier = (await repos.acceptedOffer.distinctValues({ orderNumber: { $in: [params.orderNumber] } }, 'acceptedOffers.offeredThrough.identifier')).shift();
+            debug('onAssetTransactionStatusChanged paymentDue2Processing: calling onOrderProcessing...', 'numAcceptedOffers:', numAcceptedOffers, 'itemOfferedTypeOfs:', itemOfferedTypeOfs, 'serialNumbers:', serialNumbers, 'offeredThroughIdentifier:', offeredThroughIdentifier);
+            await (0, onOrderStatusChanged_1.onOrderProcessing)({
+                order: {
+                    ...order,
+                    // acceptedOffers,
+                    numAcceptedOffers,
+                    itemOfferedTypeOf: itemOfferedTypeOfs[0], // 1つしかない前提
+                    serialNumbers,
+                    offeredThroughIdentifier,
+                    orderStatus: factory.orderStatus.OrderProcessing // 強制的にOrderProcessingとして処理する
+                },
+                placeOrderTransaction
+            })(repos, settings);
+        }
+    };
+}

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