@chevre/domain 24.0.0-alpha.2 → 24.0.0-alpha.21

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

@@ -0,0 +1,125 @@
+"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.processVoidPayTransaction = processVoidPayTransaction;
+const factory = __importStar(require("../../../factory"));
+const PayTransactionService = __importStar(require("../../assetTransaction/pay"));
+/**
+ * 決済承認中止
+ * apiもしくはタスクから決済承認を取り消す
+ */
+function processVoidPayTransaction(params) {
+    return async (repos) => {
+        const cancelAction = {
+            startTime: new Date(),
+            agent: { id: params.project.id, typeOf: factory.organizationType.Project },
+            ...(typeof params.sameAs?.id === 'string') ? { sameAs: { id: params.sameAs.id, typeOf: 'Task' } } : undefined
+        };
+        let transaction;
+        // アクションID指定の場合、進行中取引検証(2023-02-24~)
+        if (typeof params.id === 'string') {
+            transaction = await repos.placeOrder.findPlaceOrderInProgressById({ typeOf: params.purpose.typeOf, id: params.purpose.id }, ['typeOf', 'status']);
+        }
+        else {
+            transaction = await repos.placeOrder.findPlaceOrderById({ typeOf: params.purpose.typeOf, id: params.purpose.id }, ['typeOf', 'status', 'result']);
+        }
+        // 承認アクションを取得
+        let authorizeActions;
+        if (typeof params.id === 'string') {
+            const authorizeAction = await repos.action.findById({ typeOf: factory.actionType.AuthorizeAction, id: params.id });
+            // 取引内のアクションかどうか確認
+            if (authorizeAction.purpose.typeOf !== transaction.typeOf || authorizeAction.purpose.id !== transaction.id) {
+                throw new factory.errors.Argument('Transaction', 'Action not found in the transaction');
+            }
+            authorizeActions = [authorizeAction];
+        }
+        else {
+            authorizeActions = await repos.action.searchByPurpose({
+                typeOf: factory.actionType.AuthorizeAction,
+                purpose: { typeOf: transaction.typeOf, id: transaction.id },
+                object: { typeOf: { $eq: factory.action.authorize.paymentMethod.any.ResultType.Payment } }
+            });
+            switch (transaction.status) {
+                case factory.transactionStatusType.InProgress:
+                    throw new factory.errors.NotImplemented(`${transaction.status} not implemented`);
+                case factory.transactionStatusType.Confirmed:
+                    // OrderCancelledを考慮(2023-08-30~)
+                    const orderCancelled = params.purpose.result?.order?.orderStatus === factory.orderStatus.OrderCancelled;
+                    if (!orderCancelled) {
+                        // 取り消すべきアクションに絞る
+                        authorizeActions = authorizeActions.filter(({ actionStatus }) => actionStatus !== factory.actionStatusType.CompletedActionStatus);
+                        const actionIdsFromTransactionResult = transaction.result?.authorizeActions?.map(({ id }) => id);
+                        if (!Array.isArray(actionIdsFromTransactionResult)) {
+                            throw new factory.errors.Argument('Transaction', `${transaction.id} must have result.authorizeActions`);
+                        }
+                        authorizeActions = authorizeActions.filter(({ id }) => !actionIdsFromTransactionResult.includes(id));
+                        // CreditCardIFでは、事前発行のpaymentMethodIdを承認時に指定するケースがある
+                        // その場合、paymentMethodIdの重複がありうる
+                        // exclude paymentMethodId in the order(2025-02-25~)
+                        let authorizedPaymentMethodIds = [];
+                        authorizedPaymentMethodIds = authorizeActions.filter(({ id }) => actionIdsFromTransactionResult.includes(id))
+                            .map(({ object }) => object.paymentMethodId);
+                        authorizedPaymentMethodIds = [...new Set(authorizedPaymentMethodIds)];
+                        authorizeActions =
+                            authorizeActions.filter(({ object }) => !authorizedPaymentMethodIds.includes(object.paymentMethodId));
+                    }
+                    break;
+                default:
+                // no op
+            }
+        }
+        const errors = [];
+        for (const action of authorizeActions) {
+            // 失敗するケースがあっても、残りが少なくとも処理されるようにエラーハンドリング
+            try {
+                await repos.action.cancelWithVoid({ typeOf: action.typeOf, id: action.id, cancelAction });
+                // 取引が存在すれば中止
+                const transactionNumber = action.object.paymentMethodId;
+                if (typeof transactionNumber === 'string' && transactionNumber.length > 0) {
+                    const payTransaction = (await repos.assetTransaction.search({
+                        limit: 1,
+                        page: 1,
+                        project: { id: { $eq: action.project.id } },
+                        typeOf: factory.assetTransactionType.Pay,
+                        transactionNumber: { $eq: transactionNumber }
+                    }, ['_id', 'status'])).shift();
+                    if (payTransaction !== undefined) {
+                        // ステータス検証(Expiredから実行される可能性がある)
+                        if (payTransaction.status !== factory.transactionStatusType.Canceled
+                            && payTransaction.status !== factory.transactionStatusType.Expired) {
+                            await PayTransactionService.cancel({ transactionNumber })(repos);
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                errors.push(error);
+            }
+        }
+        if (errors.length > 0) {
+            throw errors[0];
+        }
+    };
+}

package/lib/chevre/service/payment/any/publishPaymentUrl/fixTransactionNumberOnPublishPaymentUrl.d.ts

@@ -1,7 +1,7 @@
 import * as factory from '../../../../factory';
 import type { AuthorizationRepo } from '../../../../repo/authorization';
 import type { TicketRepo } from '../../../../repo/ticket';
-import type { ITransactionInProgress } from '../../../../repo/transaction';
+import type { ITransactionInProgress } from '../../../../repo/transaction/placeOrder';
 import type { TransactionNumberRepo } from '../../../../repo/transactionNumber';
 interface IFixTransactionNumberRepos {
     authorization: AuthorizationRepo;
@@ -17,7 +17,7 @@ type IObjectWithoutDetail = factory.action.authorize.paymentMethod.any.IObjectWi
  */
 declare function fixTransactionNumberOnPublishPaymentUrl(params: {
     object: IObjectWithoutDetail;
-    transaction: Pick<ITransactionInProgress<factory.transactionType.PlaceOrder>, 'id' | 'project'>;
+    transaction: Pick<ITransactionInProgress, 'id' | 'project'>;
     paymentServiceType: factory.service.paymentService.PaymentServiceType;
 }): IFixTransactionNumberOperation<{
     transactionNumber: string;

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

@@ -0,0 +1,66 @@
+import * as factory from '../../../factory';
+import { Settings } from '../../../settings';
+import type { AcceptedPaymentMethodRepo } from '../../../repo/acceptedPaymentMethod';
+import type { ActionRepo } from '../../../repo/action';
+import type { AcceptPayActionRepo } from '../../../repo/action/acceptPay';
+import type { AssetTransactionRepo } from '../../../repo/assetTransaction';
+import type { AuthorizationRepo } from '../../../repo/authorization';
+import type { EventRepo } from '../../../repo/event';
+import type { EventSeriesRepo } from '../../../repo/eventSeries';
+import type { OrderNumberRepo } from '../../../repo/orderNumber';
+import type { PaymentServiceRepo } from '../../../repo/paymentService';
+import type { PaymentServiceProviderRepo } from '../../../repo/paymentServiceProvider';
+import type { ProjectRepo } from '../../../repo/project';
+import type { SellerPaymentAcceptedRepo } from '../../../repo/sellerPaymentAccepted';
+import type { TicketRepo } from '../../../repo/ticket';
+import type { PlaceOrderRepo } from '../../../repo/transaction/placeOrder';
+import type { TransactionNumberRepo } from '../../../repo/transactionNumber';
+import * as PayTransactionService from '../../assetTransaction/pay';
+interface IPublishPaymentUrlRepos {
+    acceptedPaymentMethod: AcceptedPaymentMethodRepo;
+    action: ActionRepo;
+    acceptPayAction: AcceptPayActionRepo;
+    assetTransaction: AssetTransactionRepo;
+    authorization: AuthorizationRepo;
+    event: EventRepo;
+    eventSeries: EventSeriesRepo;
+    orderNumber: OrderNumberRepo;
+    paymentAccepted: SellerPaymentAcceptedRepo;
+    paymentService: PaymentServiceRepo;
+    paymentServiceProvider: PaymentServiceProviderRepo;
+    project: ProjectRepo;
+    ticket: TicketRepo;
+    placeOrder: PlaceOrderRepo;
+    transactionNumber: TransactionNumberRepo;
+}
+type IPublishPaymentUrlOperation<T> = (repos: IPublishPaymentUrlRepos, settings: Settings) => Promise<T>;
+type IObjectWithoutDetail = factory.action.authorize.paymentMethod.any.IObjectWithoutDetail & {
+    ticketToken?: string;
+};
+/**
+ * 外部決済ロケーションを発行する
+ */
+declare function publishPaymentUrl(params: {
+    project: {
+        id: string;
+    };
+    agent: {
+        id: string;
+    };
+    object: Pick<IObjectWithoutDetail, 'amount' | 'creditCard' | 'issuedThrough' | 'method' | 'paymentMethod' | 'referencesOrder'>;
+    purpose: factory.action.authorize.paymentMethod.any.IPurpose;
+    paymentServiceType: factory.service.paymentService.PaymentServiceType;
+    location: factory.action.trade.pay.ILocation;
+    sameAs?: {
+        /**
+         * 実行元タスクID
+         */
+        id: string;
+    };
+    /**
+     * add identifier for an unique index(2025-02-25~)
+     */
+    identifier?: string;
+    instrument: factory.action.trade.pay.IAcceptedPaymentMethodOfferAsInstrument[];
+}): IPublishPaymentUrlOperation<Pick<PayTransactionService.IPublishPaymentUrlResult, 'paymentMethodId' | 'paymentUrl'>>;
+export { IPublishPaymentUrlRepos, publishPaymentUrl };

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

@@ -0,0 +1,133 @@
+"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.publishPaymentUrl = publishPaymentUrl;
+const factory = __importStar(require("../../../factory"));
+// import type { TransactionProcessRepo } from '../../repo/transactionProcess';
+const PayTransactionService = __importStar(require("../../assetTransaction/pay"));
+const issueOrderNumberIfNotExist_1 = require("../../transaction/placeOrder/issueOrderNumberIfNotExist");
+const fixTransactionNumberOnPublishPaymentUrl_1 = require("./publishPaymentUrl/fixTransactionNumberOnPublishPaymentUrl");
+const factory_1 = require("./factory");
+/**
+ * 外部決済ロケーションを発行する
+ */
+function publishPaymentUrl(params) {
+    return async (repos, settings) => {
+        const { paymentServiceType, purpose, project } = params;
+        if (purpose.typeOf !== factory.transactionType.PlaceOrder) {
+            throw new factory.errors.NotImplemented(`purpose.typeOf '${purpose.typeOf} not implemented'`);
+        }
+        try {
+            const transaction = await repos.placeOrder.findPlaceOrderInProgressById({ typeOf: purpose.typeOf, id: purpose.id }, ['expires', 'seller', 'project']);
+            if (project.id !== transaction.project.id) {
+                throw new factory.errors.NotFound(factory.transactionType.PlaceOrder);
+            }
+            // issueOrderNumber(2025-03-11~)
+            await (0, issueOrderNumberIfNotExist_1.issueOrderNumberIfNotExist)({
+                project: { id: transaction.project.id },
+                id: transaction.id,
+                object: { orderDate: new Date() }
+            })(repos);
+            // 取引番号生成
+            const { transactionNumber, ticketToken } = await (0, fixTransactionNumberOnPublishPaymentUrl_1.fixTransactionNumberOnPublishPaymentUrl)({
+                object: params.object,
+                transaction,
+                paymentServiceType
+            })(repos);
+            // let transactionNumber: string | undefined;
+            // // support ticketToken(2024-08-21~)
+            // const { permitOrInvoice } =
+            //     await verifyTicketTokenAsNeeded({ project, object: params.object, paymentServiceType, purpose })(repos);
+            // if (permitOrInvoice?.typeOf === factory.permit.PermitType.Permit) {
+            //     const paymentMethodIdByPermit = permitOrInvoice?.identifier;
+            //     if (typeof paymentMethodIdByPermit === 'string') {
+            //         transactionNumber = paymentMethodIdByPermit;
+            //     }
+            // }
+            // if (typeof transactionNumber !== 'string') {
+            //     const publishTransactionNumberResult = await repos.transactionNumber.publishByTimestamp({ startDate: new Date() });
+            //     transactionNumber = publishTransactionNumberResult.transactionNumber;
+            // }
+            // URL発行
+            const authorizeObject = {
+                ...params.object,
+                accountId: '',
+                paymentMethodId: transactionNumber,
+                typeOf: factory.action.authorize.paymentMethod.any.ResultType.Payment,
+                // support referencesOrder(2025-11-24~)
+                referencesOrder: (params.object.referencesOrder?.typeOf === factory.order.OrderType.Order)
+                    ? params.object.referencesOrder
+                    : { typeOf: factory.order.OrderType.Order }
+            };
+            const startParams = (0, factory_1.creatPublishPaymentUrlParams)({
+                object: authorizeObject,
+                paymentServiceType,
+                transaction: transaction,
+                transactionNumber: transactionNumber,
+                location: params.location,
+                instrument: params.instrument,
+                ...(typeof params.identifier === 'string') ? { identifier: params.identifier } : undefined,
+                ...(typeof ticketToken === 'string') ? { ticketToken } : undefined
+            });
+            const taskId = params.sameAs?.id;
+            const result = await PayTransactionService.publishPaymentUrl(startParams, {
+                purposeAsTransaction: { id: transaction.id },
+                executor: (typeof taskId === 'string') ? { id: taskId } : {} // タスク関連付け(2024-05-22~)
+            })(repos, settings);
+            // 取引に保管
+            const paymentMethodByPaymentUrl = {
+                // typeOf: params.object.paymentMethod, // discontinue(2024-06-05~)
+                paymentMethodId: result.paymentMethodId
+                // paymentUrl: result.paymentUrl, // migrate to recipe(2024-06-05~)
+                // issuedThrough: {
+                //     id: (typeof startParams.object.id === 'string') ? startParams.object.id : ''
+                // } // migrate to acceptAction(2024-06-05~)
+                // GMO IFを保管(2024-01-01~)
+                // entryTranArgs: result.entryTranArgs, // migrate to recipe(2024-06-05~)
+                // entryTranResult: result.entryTranResult, // migrate to recipe(2024-06-05~)
+                // execTranArgs: result.execTranArgs, // migrate to recipe(2024-06-05~)
+                // execTranResult: result.execTranResult, // migrate to recipe(2024-06-05~)
+                // paymentMethod: startParams.object.paymentMethod // 拡張(2024-01-04~) // migrate to acceptAction(2024-06-05~)
+            };
+            await repos.placeOrder.findByIdAndUpdateInProgress({
+                id: transaction.id,
+                update: { $set: { 'object.paymentMethods': paymentMethodByPaymentUrl } }
+            });
+            return {
+                paymentMethodId: result.paymentMethodId,
+                paymentUrl: result.paymentUrl
+            };
+        }
+        catch (error) {
+            // 複数対応(2024-03-27~)
+            if (Array.isArray(error)) {
+                throw error[0];
+            }
+            else {
+                throw error;
+            }
+        }
+    };
+}

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

@@ -0,0 +1,31 @@
+import * as factory from '../../../factory';
+import type { AccountingReportRepo } from '../../../repo/accountingReport';
+import type { ActionRepo } from '../../../repo/action';
+import type { AssetTransactionRepo } from '../../../repo/assetTransaction';
+import type { PaymentServiceRepo } from '../../../repo/paymentService';
+import type { PaymentServiceProviderRepo } from '../../../repo/paymentServiceProvider';
+import type { SellerPaymentAcceptedRepo } from '../../../repo/sellerPaymentAccepted';
+import type { TaskRepo } from '../../../repo/task';
+import type { PlaceOrderRepo } from '../../../repo/transaction/placeOrder';
+/**
+ * 決済承認中止
+ * タスクから決済承認を取り消す
+ */
+declare function voidPayTransaction(params: factory.task.IData<factory.taskName.VoidPayTransaction> & {
+    project: {
+        id: string;
+    };
+    sameAs?: {
+        id: string;
+    };
+}): (repos: {
+    accountingReport: AccountingReportRepo;
+    action: ActionRepo;
+    assetTransaction: AssetTransactionRepo;
+    paymentAccepted: SellerPaymentAcceptedRepo;
+    paymentService: PaymentServiceRepo;
+    paymentServiceProvider: PaymentServiceProviderRepo;
+    task: TaskRepo;
+    placeOrder: PlaceOrderRepo;
+}) => Promise<void>;
+export { voidPayTransaction, };

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

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.voidPayTransaction = voidPayTransaction;
+const invalidatePaymentUrl_1 = require("./invalidatePaymentUrl");
+const processVoidPayTransaction_1 = require("./processVoidPayTransaction");
+/**
+ * 決済承認中止
+ * タスクから決済承認を取り消す
+ */
+function voidPayTransaction(params) {
+    return async (repos
+    // settings: Settings
+    ) => {
+        // 決済承認アクション確認不要(2024-03-12~)
+        // 決済承認アクションを検索
+        // let authorizeActions = <factory.action.authorize.paymentMethod.any.IAction[]>
+        //     await repos.action.searchByPurpose({
+        //         typeOf: factory.actionType.AuthorizeAction,
+        //         purpose: {
+        //             typeOf: params.purpose.typeOf,
+        //             id: params.purpose.id
+        //         }
+        //     });
+        // authorizeActions = authorizeActions.filter(
+        //     (a) => a.object.typeOf === factory.action.authorize.paymentMethod.any.ResultType.Payment
+        // );
+        // // Chevreを使用した承認を取り消し
+        // const authorizeActionsWithChevre = authorizeActions.filter((a) => {
+        //     return a.instrument?.identifier === factory.action.authorize.paymentMethod.any.ServiceIdentifier.Chevre;
+        // });
+        // if (authorizeActionsWithChevre.length > 0) {
+        //     await processVoidPayTransaction(params)(repos);
+        // }
+        await (0, processVoidPayTransaction_1.processVoidPayTransaction)(params)(repos);
+        // 決済URL無効化もここで処理
+        await (0, invalidatePaymentUrl_1.invalidatePaymentUrl)(params)(repos);
+    };
+}