@chevre/domain 24.0.0-alpha.4 → 24.0.0-alpha.40

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

@@ -0,0 +1,187 @@
+"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.invalidatePaymentUrl = invalidatePaymentUrl;
+const factory = __importStar(require("../../../factory"));
+/**
+ * 決済承認中止タスクから決済URLを無効化する
+ */
+function invalidatePaymentUrl(params) {
+    return async (repos
+    // settings: Settings
+    ) => {
+        if (params.purpose.typeOf !== factory.transactionType.PlaceOrder) {
+            throw new factory.errors.Argument('purpose.typeOf', `must be ${factory.transactionType.PlaceOrder}`);
+        }
+        const transaction = await repos.placeOrder.findPlaceOrderById({
+            typeOf: params.purpose.typeOf,
+            id: params.purpose.id
+        }, ['typeOf', 'status', 'object', 'project', 'seller', 'agent']);
+        // const orderCancelled: boolean = params.purpose.result?.order?.orderStatus === factory.orderStatus.OrderCancelled;
+        // if (transaction.status === factory.transactionStatusType.Confirmed) {
+        //     if (!orderCancelled) {
+        //         // no op
+        //         return;
+        //     }
+        // }
+        // support multiple accept actions(2025-02-25~)
+        let acceptPayActions = await repos.acceptPayAction.findAcceptActionsByPurpose({
+            // project: { id: { $eq: transaction.project.id } },
+            // typeOf: { $eq: factory.actionType.AcceptAction },
+            // // actionStatus: { $in: [factory.actionStatusType.CompletedActionStatus] }, // all statuses(2025-02-26~)
+            // purpose: { id: { $in: [transaction.id] } },
+            // object: {
+            //     // transactionNumber: { $eq: paymentMethodIdByPaymentUrl },
+            //     typeOf: { $eq: factory.assetTransactionType.Pay }
+            // }
+            project: { id: transaction.project.id },
+            purpose: { id: transaction.id },
+        }, ['object']);
+        switch (transaction.status) {
+            case factory.transactionStatusType.InProgress:
+                throw new factory.errors.NotImplemented(`${transaction.status} not implemented`);
+            case factory.transactionStatusType.Confirmed:
+                // support OrderCanceled(2025-02-25~)
+                const orderCancelled = params.purpose.result?.order?.orderStatus === factory.orderStatus.OrderCancelled;
+                if (!orderCancelled) {
+                    const paymentMethodIdByPaymentUrl = transaction.object.paymentMethods?.paymentMethodId;
+                    if (typeof paymentMethodIdByPaymentUrl === 'string') {
+                        acceptPayActions = acceptPayActions.filter(({ object }) => object.transactionNumber !== paymentMethodIdByPaymentUrl);
+                    }
+                }
+                break;
+            default:
+            // no op
+        }
+        const invalidatePaymentUrlTasks = [];
+        const runsAt = new Date();
+        for (const acceptPayAction of acceptPayActions) {
+            const paymentMethodIdByPaymentUrl = acceptPayAction.object.transactionNumber;
+            const paymentMethodType = acceptPayAction.object.object.paymentMethod.identifier;
+            if (typeof paymentMethodType === 'string' && paymentMethodType.length > 0) {
+                // create task(2025-02-26~)
+                // await PayTransactionService.invalidatePaymentUrl({})(repos, settings);
+                const invalidatePaymentUrlData = {
+                    project: transaction.project,
+                    typeOf: factory.actionType.RefundAction,
+                    agent: {
+                        typeOf: transaction.seller.typeOf,
+                        name: (typeof transaction.seller.name === 'string')
+                            ? transaction.seller.name
+                            : String(transaction.seller.name?.ja),
+                        id: transaction.seller.id
+                    },
+                    recipient: {
+                        typeOf: transaction.agent.typeOf,
+                        id: transaction.agent.id,
+                        name: transaction.agent.name
+                    },
+                    object: [{
+                            typeOf: factory.service.paymentService.PaymentServiceType.CreditCard,
+                            id: acceptPayAction.object.object.id,
+                            paymentMethod: {
+                                additionalProperty: [],
+                                name: paymentMethodType,
+                                typeOf: paymentMethodType,
+                                paymentMethodId: paymentMethodIdByPaymentUrl
+                            },
+                            refundFee: 0
+                        }],
+                    purpose: { typeOf: transaction.typeOf, id: transaction.id },
+                    instrument: []
+                    // ...(typeof params.sameAs?.id === 'string') ? { sameAs: params.sameAs } : undefined
+                };
+                invalidatePaymentUrlTasks.push({
+                    project: transaction.project,
+                    name: factory.taskName.InvalidatePaymentUrl,
+                    status: factory.taskStatus.Ready,
+                    runsAt,
+                    remainingNumberOfTries: 10,
+                    numberOfTried: 0,
+                    executionResults: [],
+                    data: invalidatePaymentUrlData
+                });
+            }
+        }
+        if (invalidatePaymentUrlTasks.length > 0) {
+            await repos.task.saveMany(invalidatePaymentUrlTasks, { emitImmediately: true });
+        }
+        // const paymentMethodIdByPaymentUrl = transaction.object.paymentMethods?.paymentMethodId;
+        // if (typeof paymentMethodIdByPaymentUrl === 'string' && paymentMethodIdByPaymentUrl.length > 0) {
+        //     const acceptPayAction = (<Pick<IAcceptPayAction, 'object'>[]>await repos.action.search(
+        //         {
+        //             limit: 1,
+        //             page: 1,
+        //             project: { id: { $eq: transaction.project.id } },
+        //             typeOf: { $eq: factory.actionType.AcceptAction },
+        //             actionStatus: { $in: [factory.actionStatusType.CompletedActionStatus] },
+        //             purpose: { id: { $in: [transaction.id] } },
+        //             object: {
+        //                 transactionNumber: { $eq: paymentMethodIdByPaymentUrl },
+        //                 typeOf: { $eq: factory.assetTransactionType.Pay }
+        //             }
+        //         },
+        //         ['object']
+        //     )).shift();
+        //     if (acceptPayAction !== undefined) {
+        //         // const paymentMethodType = transaction.object.paymentMethods?.typeOf;
+        //         const paymentMethodType = acceptPayAction.object.object.paymentMethod.identifier;
+        //         if (typeof paymentMethodType === 'string' && paymentMethodType.length > 0) {
+        //             // chevreで決済URL無効化
+        //             await PayTransactionService.invalidatePaymentUrl({
+        //                 project: transaction.project,
+        //                 typeOf: factory.actionType.RefundAction,
+        //                 agent: {
+        //                     typeOf: transaction.seller.typeOf,
+        //                     name: (typeof transaction.seller.name === 'string')
+        //                         ? transaction.seller.name
+        //                         : String(transaction.seller.name?.ja),
+        //                     id: transaction.seller.id
+        //                 },
+        //                 recipient: {
+        //                     typeOf: transaction.agent.typeOf,
+        //                     id: transaction.agent.id,
+        //                     name: transaction.agent.name
+        //                 },
+        //                 object: [{
+        //                     typeOf: factory.service.paymentService.PaymentServiceType.CreditCard,
+        //                     id: acceptPayAction.object.object.id,
+        //                     paymentMethod: {
+        //                         additionalProperty: [],
+        //                         name: paymentMethodType,
+        //                         typeOf: paymentMethodType,
+        //                         paymentMethodId: paymentMethodIdByPaymentUrl
+        //                     },
+        //                     refundFee: 0
+        //                 }],
+        //                 purpose: { typeOf: transaction.typeOf, id: transaction.id },
+        //                 instrument: [],
+        //                 ...(typeof params.sameAs?.id === 'string') ? { sameAs: params.sameAs } : undefined
+        //             })(repos, settings);
+        //         }
+        //     }
+        // }
+    };
+}

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/payment/any/processVoidPayTransaction.d.ts

@@ -0,0 +1,30 @@
+import * as factory from '../../../factory';
+import type { AccountingReportRepo } from '../../../repo/accountingReport';
+import type { AuthorizePaymentMethodActionRepo } from '../../../repo/action/authorizePaymentMethod';
+import type { AssetTransactionRepo } from '../../../repo/assetTransaction';
+import type { TaskRepo } from '../../../repo/task';
+import type { PlaceOrderRepo } from '../../../repo/transaction/placeOrder';
+interface IProcessVoidPayTransactionRepos {
+    action?: never;
+    authorizePaymentMethodAction: AuthorizePaymentMethodActionRepo;
+    accountingReport: AccountingReportRepo;
+    assetTransaction: AssetTransactionRepo;
+    task: TaskRepo;
+    placeOrder: PlaceOrderRepo;
+}
+/**
+ * 決済承認中止
+ * apiもしくはタスクから決済承認を取り消す
+ */
+declare function processVoidPayTransaction(params: factory.task.IData<factory.taskName.VoidPayTransaction> & {
+    project: {
+        id: string;
+    };
+    sameAs?: {
+        /**
+         * 実行元タスクID
+         */
+        id: string;
+    };
+}): (repos: IProcessVoidPayTransactionRepos) => Promise<void>;
+export { IProcessVoidPayTransactionRepos, processVoidPayTransaction, };

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.authorizePaymentMethodAction.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.authorizePaymentMethodAction.findAuthorizePaymentMethodActionsByPurpose({
+                // 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.authorizePaymentMethodAction.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 { AcceptPayActionRepo } from '../../../repo/action/acceptPay';
+import type { AuthorizeInvoiceActionRepo } from '../../../repo/action/authorizeInvoice';
+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;
+    acceptPayAction: AcceptPayActionRepo;
+    authorizeInvoiceAction: AuthorizeInvoiceActionRepo;
+    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,34 @@
+import * as factory from '../../../factory';
+import type { AccountingReportRepo } from '../../../repo/accountingReport';
+import type { AcceptPayActionRepo } from '../../../repo/action/acceptPay';
+import type { AuthorizePaymentMethodActionRepo } from '../../../repo/action/authorizePaymentMethod';
+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?: never;
+    acceptPayAction: AcceptPayActionRepo;
+    authorizePaymentMethodAction: AuthorizePaymentMethodActionRepo;
+    assetTransaction: AssetTransactionRepo;
+    paymentAccepted: SellerPaymentAcceptedRepo;
+    paymentService: PaymentServiceRepo;
+    paymentServiceProvider: PaymentServiceProviderRepo;
+    task: TaskRepo;
+    placeOrder: PlaceOrderRepo;
+}) => Promise<void>;
+export { voidPayTransaction, };