@chevre/domain 24.0.0-alpha.3 → 24.0.0-alpha.30

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

@@ -1,9 +1,10 @@
 import * as factory from '../../../factory';
-import type { ActionRepo } from '../../../repo/action';
+import type { AuthorizeMoneyTransferOfferActionRepo } from '../../../repo/action/authorizeMoneyTransferOffer';
 import type { AssetTransactionRepo } from '../../../repo/assetTransaction';
-import type { TransactionRepo } from '../../../repo/transaction';
+import type { PlaceOrderRepo } from '../../../repo/transaction/placeOrder';
 export declare function voidTransaction(params: factory.task.IData<factory.taskName.VoidMoneyTransferTransaction>): (repos: {
-    action: ActionRepo;
+    action?: never;
+    authorizeMoneyTransferOfferAction: AuthorizeMoneyTransferOfferActionRepo;
     assetTransaction: AssetTransactionRepo;
-    transaction: TransactionRepo;
+    placeOrder: PlaceOrderRepo;
 }) => Promise<void>;

package/lib/chevre/service/offer/moneyTransfer/voidTransaction.js

@@ -28,16 +28,19 @@ const factory = __importStar(require("../../../factory"));
 const MoneyTransferAssetTransactionService = __importStar(require("../../assetTransaction/moneyTransfer"));
 function voidTransaction(params) {
     return async (repos) => {
+        if (params.purpose.typeOf !== factory.transactionType.PlaceOrder) {
+            throw new factory.errors.NotImplemented(`purpose.typeOf: ${params.purpose.typeOf} not implemented`);
+        }
         let transaction;
         if (params.agent !== undefined && params.agent !== null && typeof params.agent.id === 'string') {
-            transaction = await repos.transaction.projectFieldsInProgressById({
+            transaction = await repos.placeOrder.findPlaceOrderInProgressById({
                 typeOf: params.purpose.typeOf,
                 id: params.purpose.id
             }, ['typeOf']);
         }
         let authorizeActions;
         if (typeof params.id === 'string') {
-            const authorizeAction = await repos.action.findById({ typeOf: factory.actionType.AuthorizeAction, id: params.id });
+            const authorizeAction = await repos.authorizeMoneyTransferOfferAction.findById({ typeOf: factory.actionType.AuthorizeAction, id: params.id });
             // 取引内のアクションかどうか確認
             if (transaction !== undefined) {
                 if (authorizeAction.purpose.typeOf !== transaction.typeOf || authorizeAction.purpose.id !== transaction.id) {
@@ -47,8 +50,8 @@ function voidTransaction(params) {
             authorizeActions = [authorizeAction];
         }
         else {
-            authorizeActions = await repos.action.searchByPurpose({
-                typeOf: factory.actionType.AuthorizeAction,
+            authorizeActions = await repos.authorizeMoneyTransferOfferAction.findAuthorizeMoneyTransferOfferActionsByPurpose({
+                // typeOf: factory.actionType.AuthorizeAction,
                 purpose: {
                     typeOf: params.purpose.typeOf,
                     id: params.purpose.id
@@ -58,7 +61,7 @@ function voidTransaction(params) {
                 .filter((a) => a.object.itemOffered?.typeOf === factory.actionType.MoneyTransfer);
         }
         await Promise.all(authorizeActions.map(async (action) => {
-            await repos.action.cancelWithVoid({ typeOf: action.typeOf, id: action.id });
+            await repos.authorizeMoneyTransferOfferAction.cancelWithVoid({ typeOf: action.typeOf, id: action.id });
             const pendingTransactionTransactionNumber = action.object.itemOffered.object?.pendingTransaction?.transactionNumber;
             if (typeof pendingTransactionTransactionNumber === 'string') {
                 // 取引が存在すれば中止

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

@@ -1,6 +1,6 @@
 import * as factory from '../../factory';
 import type { AccountRepo } from '../../repo/account';
-import type { ActionRepo } from '../../repo/action';
+import type { AuthorizeProductOfferActionRepo } from '../../repo/action/authorizeProductOffer';
 import type { AssetTransactionRepo } from '../../repo/assetTransaction';
 import type { OfferRepo } from '../../repo/offer/unitPriceInCatalog';
 import type { OfferCatalogRepo } from '../../repo/offerCatalog';
@@ -11,11 +11,12 @@ import type { ProductRepo } from '../../repo/product';
 import type { ProjectRepo } from '../../repo/project';
 import type { ServiceOutputRepo } from '../../repo/serviceOutput';
 import type { ServiceOutputIdentifierRepo } from '../../repo/serviceOutputIdentifier';
-import type { TransactionRepo } from '../../repo/transaction';
+import type { PlaceOrderRepo } from '../../repo/transaction/placeOrder';
 import type { TransactionNumberRepo } from '../../repo/transactionNumber';
 export interface IAuthorizeOperationRepos {
     account: AccountRepo;
-    action: ActionRepo;
+    action?: never;
+    authorizeProductOfferAction: AuthorizeProductOfferActionRepo;
     assetTransaction: AssetTransactionRepo;
     offer: OfferRepo;
     offerCatalog: OfferCatalogRepo;
@@ -26,7 +27,7 @@ export interface IAuthorizeOperationRepos {
     project: ProjectRepo;
     serviceOutput: ServiceOutputRepo;
     serviceOutputIdentifier: ServiceOutputIdentifierRepo;
-    transaction: TransactionRepo;
+    placeOrder: PlaceOrderRepo;
     transactionNumber: TransactionNumberRepo;
 }
 export type IAuthorizeOperation<T> = (repos: IAuthorizeOperationRepos) => Promise<T>;
@@ -94,7 +95,8 @@ export declare function authorize(params: {
     result: IAuthorizeOfferAction['result'];
 }>;
 export declare function voidTransaction(params: factory.task.IData<factory.taskName.VoidRegisterServiceTransaction>): (repos: {
-    action: ActionRepo;
+    action?: never;
+    authorizeProductOfferAction: AuthorizeProductOfferActionRepo;
     assetTransaction: AssetTransactionRepo;
-    transaction: TransactionRepo;
+    placeOrder: PlaceOrderRepo;
 }) => Promise<void>;

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

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

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

@@ -7,7 +7,6 @@ import type { EventRepo } from '../../repo/event';
 import type { OrderRepo } from '../../repo/order';
 import type { ProjectRepo } from '../../repo/project';
 import type { TaskRepo } from '../../repo/task';
-import type { TransactionRepo } from '../../repo/transaction';
 declare function confirmPayTransaction(data: factory.task.IData<factory.taskName.ConfirmPayTransaction> & {
     project: {
         id: string;
@@ -22,6 +21,5 @@ declare function confirmPayTransaction(data: factory.task.IData<factory.taskName
     event: EventRepo;
     project: ProjectRepo;
     task: TaskRepo;
-    transaction: TransactionRepo;
 }) => Promise<void>;
 export { confirmPayTransaction };

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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