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

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

@@ -4,18 +4,18 @@ import type { OrderRepo } from '../../repo/order';
 import type { OwnershipInfoRepo } from '../../repo/ownershipInfo';
 import type { SettingRepo } from '../../repo/setting';
 import type { TaskRepo } from '../../repo/task';
-import type { TransactionRepo } from '../../repo/transaction';
+import type { PlaceOrderRepo } from '../../repo/transaction/placeOrder';
 import * as factory from '../../factory';
-import { Settings } from '../../settings';
-type ISendOperation<T> = (repos: {
+interface ISendOrderRepos {
     acceptedOffer: AcceptedOfferRepo;
     action: ActionRepo;
     order: OrderRepo;
     ownershipInfo: OwnershipInfoRepo;
     setting: SettingRepo;
     task: TaskRepo;
-    transaction: TransactionRepo;
-}, settings: Settings) => Promise<T>;
+    placeOrder: PlaceOrderRepo;
+}
+type ISendOperation<T> = (repos: ISendOrderRepos) => Promise<T>;
 /**
  * 注文を配送する
  */
@@ -35,4 +35,4 @@ declare function sendOrder(params: {
     };
     useOnOrderStatusChanged: boolean;
 }): ISendOperation<void>;
-export { sendOrder };
+export { ISendOrderRepos, sendOrder };

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

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

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

@@ -2,12 +2,9 @@
  * 注文サービス
  */
 import { confirmPayTransaction } from './order/confirmPayTransaction';
-import { deleteOrder } from './order/deleteOrder';
-import { onAssetTransactionStatusChanged, paymentDue2Processing } from './order/onAssetTransactionStatusChanged';
-import { onOrderProcessing, processOrder } from './order/onOrderStatusChanged';
+import { paymentDue2Processing } from './order/onAssetTransactionStatusChanged';
+import { processOrder } from './order/onOrderStatusChanged';
 import { onOrderUpdated } from './order/onOrderUpdated';
-import { payOrder } from './order/payOrder';
 import { placeOrder } from './order/placeOrder';
 import { placeOrderWithoutTransaction } from './order/placeOrderWithoutTransaction';
-import { sendOrder } from './order/sendOrder';
-export { confirmPayTransaction, deleteOrder, onAssetTransactionStatusChanged, onOrderProcessing, onOrderUpdated, paymentDue2Processing, payOrder, placeOrder, placeOrderWithoutTransaction, processOrder, sendOrder };
+export { confirmPayTransaction, onOrderUpdated, paymentDue2Processing, placeOrder, placeOrderWithoutTransaction, processOrder, };

package/lib/chevre/service/order.js

@@ -1,26 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sendOrder = exports.processOrder = exports.placeOrderWithoutTransaction = exports.placeOrder = exports.payOrder = exports.paymentDue2Processing = exports.onOrderUpdated = exports.onOrderProcessing = exports.onAssetTransactionStatusChanged = exports.deleteOrder = exports.confirmPayTransaction = void 0;
+exports.processOrder = exports.placeOrderWithoutTransaction = exports.placeOrder = exports.paymentDue2Processing = exports.onOrderUpdated = exports.confirmPayTransaction = void 0;
 /**
  * 注文サービス
  */
 const confirmPayTransaction_1 = require("./order/confirmPayTransaction");
 Object.defineProperty(exports, "confirmPayTransaction", { enumerable: true, get: function () { return confirmPayTransaction_1.confirmPayTransaction; } });
-const deleteOrder_1 = require("./order/deleteOrder");
-Object.defineProperty(exports, "deleteOrder", { enumerable: true, get: function () { return deleteOrder_1.deleteOrder; } });
+// import { deleteOrder } from './order/deleteOrder';
 const onAssetTransactionStatusChanged_1 = require("./order/onAssetTransactionStatusChanged");
-Object.defineProperty(exports, "onAssetTransactionStatusChanged", { enumerable: true, get: function () { return onAssetTransactionStatusChanged_1.onAssetTransactionStatusChanged; } });
 Object.defineProperty(exports, "paymentDue2Processing", { enumerable: true, get: function () { return onAssetTransactionStatusChanged_1.paymentDue2Processing; } });
 const onOrderStatusChanged_1 = require("./order/onOrderStatusChanged");
-Object.defineProperty(exports, "onOrderProcessing", { enumerable: true, get: function () { return onOrderStatusChanged_1.onOrderProcessing; } });
 Object.defineProperty(exports, "processOrder", { enumerable: true, get: function () { return onOrderStatusChanged_1.processOrder; } });
 const onOrderUpdated_1 = require("./order/onOrderUpdated");
 Object.defineProperty(exports, "onOrderUpdated", { enumerable: true, get: function () { return onOrderUpdated_1.onOrderUpdated; } });
-const payOrder_1 = require("./order/payOrder");
-Object.defineProperty(exports, "payOrder", { enumerable: true, get: function () { return payOrder_1.payOrder; } });
+// import { payOrder } from './order/payOrder';
 const placeOrder_1 = require("./order/placeOrder");
 Object.defineProperty(exports, "placeOrder", { enumerable: true, get: function () { return placeOrder_1.placeOrder; } });
 const placeOrderWithoutTransaction_1 = require("./order/placeOrderWithoutTransaction");
 Object.defineProperty(exports, "placeOrderWithoutTransaction", { enumerable: true, get: function () { return placeOrderWithoutTransaction_1.placeOrderWithoutTransaction; } });
-const sendOrder_1 = require("./order/sendOrder");
-Object.defineProperty(exports, "sendOrder", { enumerable: true, get: function () { return sendOrder_1.sendOrder; } });

package/lib/chevre/service/payment/any/{fixOrderAsNeeded.d.ts → authorize/fixOrderAsNeeded.d.ts}

@@ -1,8 +1,8 @@
-import * as factory from '../../../factory';
-import type { ConfirmationNumberRepo } from '../../../repo/confirmationNumber';
-import type { OrderNumberRepo } from '../../../repo/orderNumber';
-import type { ProjectRepo } from '../../../repo/project';
-import type { TransactionRepo } from '../../../repo/transaction';
+import * as factory from '../../../../factory';
+import type { ConfirmationNumberRepo } from '../../../../repo/confirmationNumber';
+import type { OrderNumberRepo } from '../../../../repo/orderNumber';
+import type { ProjectRepo } from '../../../../repo/project';
+import type { PlaceOrderRepo } from '../../../../repo/transaction/placeOrder';
 declare function fixOrderAsNeeded(params: {
     project: {
         id: string;
@@ -10,7 +10,7 @@ declare function fixOrderAsNeeded(params: {
     purpose: factory.action.authorize.paymentMethod.any.IPurpose;
 }): (repos: {
     project: ProjectRepo;
-    transaction: TransactionRepo;
+    placeOrder: PlaceOrderRepo;
     confirmationNumber: ConfirmationNumberRepo;
     orderNumber: OrderNumberRepo;
 }) => Promise<{

package/lib/chevre/service/payment/any/{fixOrderAsNeeded.js → authorize/fixOrderAsNeeded.js}

@@ -24,9 +24,9 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fixOrderAsNeeded = fixOrderAsNeeded;
-const factory = __importStar(require("../../../factory"));
-const publishConfirmationNumberIfNotExist_1 = require("../../transaction/placeOrder/publishConfirmationNumberIfNotExist");
-const publishOrderNumberIfNotExist_1 = require("../../transaction/placeOrder/publishOrderNumberIfNotExist");
+const factory = __importStar(require("../../../../factory"));
+const publishConfirmationNumberIfNotExist_1 = require("../../../transaction/placeOrder/publishConfirmationNumberIfNotExist");
+const issueOrderNumberIfNotExist_1 = require("../../../transaction/placeOrder/issueOrderNumberIfNotExist");
 function fixOrderAsNeeded(params) {
     return async (repos) => {
         const orderDate = new Date();
@@ -38,13 +38,10 @@ function fixOrderAsNeeded(params) {
             id: params.purpose.id,
             status: { $in: [factory.transactionStatusType.InProgress] },
             object: { orderDate }
-        })({
-            confirmationNumber: repos.confirmationNumber,
-            transaction: repos.transaction
-        });
+        })(repos);
         // }
         // publish orderNumber(2025-02-14~)
-        const orderNumber = await (0, publishOrderNumberIfNotExist_1.publishOrderNumberIfNotExist)({
+        const orderNumber = await (0, issueOrderNumberIfNotExist_1.issueOrderNumberIfNotExist)({
             project: { id: params.project.id },
             id: params.purpose.id,
             object: { orderDate }

package/lib/chevre/service/payment/any/authorize/fixTransactionNumber.d.ts

@@ -2,7 +2,7 @@ import * as factory from '../../../../factory';
 import type { ActionRepo } from '../../../../repo/action';
 import type { AuthorizationRepo } from '../../../../repo/authorization';
 import type { TicketRepo } from '../../../../repo/ticket';
-import type { ITransactionInProgress, TransactionRepo } from '../../../../repo/transaction';
+import type { ITransactionInProgress, PlaceOrderRepo } from '../../../../repo/transaction/placeOrder';
 import type { TransactionNumberRepo } from '../../../../repo/transactionNumber';
 import * as PayTransactionService from '../../../assetTransaction/pay';
 import { IInvoiceByTicketToken } from '../factory';
@@ -10,7 +10,7 @@ interface IFixTransactionNumberRepos {
     action: ActionRepo;
     authorization: AuthorizationRepo;
     ticket: TicketRepo;
-    transaction: TransactionRepo;
+    placeOrder: PlaceOrderRepo;
     transactionNumber: TransactionNumberRepo;
 }
 type IFixTransactionNumberOperation<T> = (repos: IFixTransactionNumberRepos) => Promise<T>;
@@ -22,7 +22,7 @@ type IObjectWithoutDetail = factory.action.authorize.paymentMethod.any.IObjectWi
  */
 declare function fixTransactionNumber(params: {
     object: IObjectWithoutDetail;
-    transaction: Pick<ITransactionInProgress<factory.transactionType.PlaceOrder>, 'agent' | 'expires' | 'id' | 'typeOf' | 'project' | 'seller'>;
+    transaction: Pick<ITransactionInProgress, 'agent' | 'expires' | 'id' | 'typeOf' | 'project' | 'seller'>;
     paymentServiceType: factory.service.paymentService.PaymentServiceType;
 }): IFixTransactionNumberOperation<{
     transactionNumber: string;

package/lib/chevre/service/payment/any/authorize/handlePrePublishedPaymentMethodIdOnAuthorizing.d.ts

@@ -2,7 +2,7 @@ import * as factory from '../../../../factory';
 import type { ActionRepo } from '../../../../repo/action';
 import type { AuthorizationRepo } from '../../../../repo/authorization';
 import type { TicketRepo } from '../../../../repo/ticket';
-import type { ITransactionInProgress, TransactionRepo } from '../../../../repo/transaction';
+import type { ITransactionInProgress, PlaceOrderRepo } from '../../../../repo/transaction/placeOrder';
 import * as PayTransactionService from '../../../assetTransaction/pay';
 import type { IInvoiceByTicketToken } from '../factory';
 type IObjectWithoutDetail = factory.action.authorize.paymentMethod.any.IObjectWithoutDetail;
@@ -16,12 +16,12 @@ interface IAcceptAction2ticketResult {
 declare function handlePrePublishedPaymentMethodIdOnAuthorizing(params: {
     object: Pick<IObjectWithoutDetail, 'amount' | 'issuedThrough' | 'paymentMethod' | 'referencesOrder'>;
     prePublishedPaymentMethodId: string;
-    transaction: Pick<ITransactionInProgress<factory.transactionType.PlaceOrder>, 'agent' | 'expires' | 'id' | 'typeOf' | 'project' | 'seller'>;
+    transaction: Pick<ITransactionInProgress, 'agent' | 'expires' | 'id' | 'typeOf' | 'project' | 'seller'>;
 }): (repos: {
     action: ActionRepo;
     authorization: AuthorizationRepo;
     ticket: TicketRepo;
-    transaction: TransactionRepo;
+    placeOrder: PlaceOrderRepo;
 }) => Promise<{
     authorizeParams?: {
         creditCard: factory.action.authorize.paymentMethod.any.ICreditCard;

package/lib/chevre/service/payment/any/authorize/handlePrePublishedPaymentMethodIdOnAuthorizing.js

@@ -122,7 +122,7 @@ function handlePrePublishedPaymentMethodIdOnAuthorizing(params) {
         let acceptPayAction;
         // transaction.objectへのアクセス回避(2024-05-30~)
         // const paymentMethodByTransaction = transaction.object.paymentMethods;
-        const paymentMethodByTransaction = await repos.transaction.findInProgressPaymentMethodId({ id: params.transaction.id });
+        const paymentMethodByTransaction = await repos.placeOrder.findInProgressPaymentMethodId({ id: params.transaction.id });
         if (params.prePublishedPaymentMethodId === paymentMethodByTransaction?.paymentMethodId) {
             // check existence of acceptAction when authorizing payment(2024-06-01~)
             acceptPayAction = (await repos.action.search({

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

@@ -0,0 +1,92 @@
+import * as factory from '../../../factory';
+import { Settings } from '../../../settings';
+import type { AcceptedPaymentMethodRepo } from '../../../repo/acceptedPaymentMethod';
+import type { AccountingReportRepo } from '../../../repo/accountingReport';
+import type { ActionRepo } from '../../../repo/action';
+import type { CheckMovieTicketActionRepo } from '../../../repo/action/checkMovieTicket';
+import type { AssetTransactionRepo } from '../../../repo/assetTransaction';
+import type { AuthorizationRepo } from '../../../repo/authorization';
+import type { ConfirmationNumberRepo } from '../../../repo/confirmationNumber';
+import type { CredentialsRepo } from '../../../repo/credentials';
+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 { PotentialActionRepo } from '../../../repo/potentialAction';
+import type { ProductRepo } from '../../../repo/product';
+import type { ProjectRepo } from '../../../repo/project';
+import type { SellerPaymentAcceptedRepo } from '../../../repo/sellerPaymentAccepted';
+import type { TaskRepo } from '../../../repo/task';
+import type { TicketRepo } from '../../../repo/ticket';
+import type { PlaceOrderRepo } from '../../../repo/transaction/placeOrder';
+import type { TransactionNumberRepo } from '../../../repo/transactionNumber';
+interface IAuthorizeRepos {
+    acceptedPaymentMethod: AcceptedPaymentMethodRepo;
+    accountingReport: AccountingReportRepo;
+    action: ActionRepo;
+    checkMovieTicketAction: CheckMovieTicketActionRepo;
+    assetTransaction: AssetTransactionRepo;
+    authorization: AuthorizationRepo;
+    confirmationNumber: ConfirmationNumberRepo;
+    credentials: CredentialsRepo;
+    event: EventRepo;
+    eventSeries: EventSeriesRepo;
+    orderNumber: OrderNumberRepo;
+    paymentAccepted: SellerPaymentAcceptedRepo;
+    paymentService: PaymentServiceRepo;
+    paymentServiceProvider: PaymentServiceProviderRepo;
+    potentialAction: PotentialActionRepo;
+    product: ProductRepo;
+    project: ProjectRepo;
+    task: TaskRepo;
+    ticket: TicketRepo;
+    placeOrder: PlaceOrderRepo;
+    transactionNumber: TransactionNumberRepo;
+}
+type IAuthorizeOperation<T> = (repos: IAuthorizeRepos, settings: Settings) => Promise<T>;
+type IObjectWithoutDetail = factory.action.authorize.paymentMethod.any.IObjectWithoutDetail & {
+    ticketToken?: string;
+};
+/**
+ * 決済承認
+ * CreditCard,MovieTicket -> 決済承認タスクから呼ばれる
+ * FaceToFace,PaymentCard -> apiから呼ばれる
+ */
+declare function authorize(params: {
+    project: {
+        id: string;
+    };
+    agent: {
+        id: string;
+    };
+    object: IObjectWithoutDetail;
+    purpose: factory.action.authorize.paymentMethod.any.IPurpose;
+    paymentServiceType: factory.service.paymentService.PaymentServiceType;
+    location?: factory.action.trade.pay.ILocation;
+    options: {
+        /**
+         * アクション失敗時に即時に決済取引を中止するかどうか
+         */
+        useCancelPayTransactionOnFailed: boolean;
+        checkedAction: {
+            id: string;
+        };
+    };
+    sameAs?: {
+        /**
+         * 実行元タスクID
+         */
+        id: string;
+    };
+    /**
+     * ツールとしての対応決済方法オファー
+     */
+    instrument: factory.action.trade.pay.IAcceptedPaymentMethodOfferAsInstrument[];
+}): IAuthorizeOperation<{
+    /**
+     * 承認アクションID
+     */
+    id: string;
+}>;
+export { authorize, IAuthorizeRepos };

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

@@ -0,0 +1,225 @@
+"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.authorize = authorize;
+const util = __importStar(require("util"));
+const factory = __importStar(require("../../../factory"));
+const PayTransactionService = __importStar(require("../../assetTransaction/pay"));
+const fixTransactionNumber_1 = require("./authorize/fixTransactionNumber");
+const factory_1 = require("./factory");
+const fixOrderAsNeeded_1 = require("./authorize/fixOrderAsNeeded");
+const processVoidPayTransaction_1 = require("./processVoidPayTransaction");
+/**
+ * 承認アクションオブジェクトから冗長な属性を排除する
+ */
+function minimizeObjectIncludingPaymentMethodDetails(authorizeObjectIncludingPaymentMethodDetails) {
+    const { accountId, paymentMethodId, typeOf } = authorizeObjectIncludingPaymentMethodDetails;
+    return { authorizeObject: { accountId, paymentMethodId, typeOf } }; // optimize(2024-06-26~)
+}
+/**
+ * 決済承認
+ * CreditCard,MovieTicket -> 決済承認タスクから呼ばれる
+ * FaceToFace,PaymentCard -> apiから呼ばれる
+ */
+function authorize(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'`);
+        }
+        const transaction = await repos.placeOrder.findPlaceOrderInProgressById({ typeOf: purpose.typeOf, id: purpose.id }, ['agent', 'expires', 'typeOf', 'project', 'seller']);
+        if (project.id !== transaction.project.id) {
+            throw new factory.errors.NotFound(factory.transactionType.PlaceOrder);
+        }
+        const { confirmationNumber, orderNumber } = await (0, fixOrderAsNeeded_1.fixOrderAsNeeded)({
+            project: { id: transaction.project.id },
+            purpose
+            // paymentServiceType
+        })(repos);
+        // 取引番号生成
+        const fixTransactionNumberResult = await (0, fixTransactionNumber_1.fixTransactionNumber)({
+            object: params.object,
+            transaction,
+            paymentServiceType
+        })(repos);
+        if (typeof fixTransactionNumberResult.id === 'string') {
+            return { id: fixTransactionNumberResult.id };
+        }
+        const { transactionNumber, pendingPaymentAgencyTransaction, creditCard, invoiceByTicketToken, ticketToken } = fixTransactionNumberResult;
+        const movieTickets = (Array.isArray(params.object.movieTickets)) ? params.object.movieTickets.map(factory_1.createMovieTicket) : undefined;
+        const { accountId } = await fixAccountIdIfPossible({
+            object: params.object, project: { id: transaction.project.id }
+        })();
+        const authorizeObjectIncludingPaymentMethodDetails = {
+            ...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 },
+            ...(creditCard !== undefined) ? { creditCard } : undefined,
+            ...(Array.isArray(movieTickets)) ? { movieTickets } : undefined
+        };
+        const { authorizeObject } = minimizeObjectIncludingPaymentMethodDetails(authorizeObjectIncludingPaymentMethodDetails);
+        // 承認アクションを開始する
+        const taskId = params.sameAs?.id;
+        const uniqueActionIdentifier = util.format(`%s:%s:%s`, factory.actionType.AuthorizeAction, factory.action.authorize.paymentMethod.any.ResultType.Payment, authorizeObject.paymentMethodId);
+        const actionAttributes = {
+            project: transaction.project,
+            typeOf: factory.actionType.AuthorizeAction,
+            object: authorizeObject,
+            agent: {
+                typeOf: transaction.agent.typeOf,
+                id: transaction.agent.id
+            },
+            instrument: {
+                typeOf: factory.assetTransactionType.Pay, // 資産取引化(2024-03-11~)
+                identifier: factory.action.authorize.paymentMethod.any.ServiceIdentifier.Chevre,
+                transactionNumber
+            },
+            recipient: {
+                typeOf: transaction.seller.typeOf,
+                id: transaction.seller.id,
+                name: (typeof transaction.seller.name === 'string')
+                    ? transaction.seller.name
+                    : String(transaction.seller.name?.ja)
+            },
+            purpose: { typeOf: transaction.typeOf, id: transaction.id },
+            identifier: uniqueActionIdentifier, // add unique identifier(2025-02-25~)
+            ...(typeof taskId === 'string') ? { sameAs: { id: taskId, typeOf: 'Task' } } : undefined // タスク関連付け(2024-04-22~)
+        };
+        const action = await repos.action.start(actionAttributes);
+        let payTransaction;
+        try {
+            const startParams = (0, factory_1.creatPayTransactionStartParams)({
+                accountId,
+                object: authorizeObjectIncludingPaymentMethodDetails,
+                paymentServiceType,
+                transaction: transaction,
+                transactionNumber: transactionNumber,
+                location: params.location,
+                // confirmationNumber required(2025-02-12~)
+                // orderNumber required(2025-02-14~)
+                order: { confirmationNumber, orderNumber },
+                action: { id: action.id, typeOf: action.typeOf },
+                ticketToken,
+                instrument: params.instrument
+            });
+            payTransaction = await PayTransactionService.start(startParams, {
+                // useCheckByIdentifierIfNotYet: params.options.useCheckByIdentifierIfNotYet,
+                executor: (typeof taskId === 'string') ? { id: taskId } : {}, // タスク関連付け(2024-05-18~)
+                purpose: { id: transaction.id },
+                checkedAction: params.options.checkedAction,
+                ...(pendingPaymentAgencyTransaction !== undefined) ? { pendingPaymentAgencyTransaction } : undefined
+            })(repos, settings);
+        }
+        catch (error) {
+            try {
+                await repos.action.giveUp({ typeOf: action.typeOf, id: action.id, error });
+            }
+            catch (__) {
+                // no op
+            }
+            // 即時に決済取引を中止するか？(2023-02-03~)
+            if (params.options.useCancelPayTransactionOnFailed) {
+                // abortエラーの場合は状態不明なので即時中止しない(2023-06-01~)
+                // {
+                //     "type": "aborted",
+                //     "message": "The user aborted a request.",
+                //     "name": "AbortError"
+                // }
+                const rawError = Array.isArray(error) ? error[1] : undefined;
+                if (rawError !== undefined && rawError.name !== 'AbortError') {
+                    await (0, processVoidPayTransaction_1.processVoidPayTransaction)({
+                        project: actionAttributes.project,
+                        id: action.id,
+                        purpose: actionAttributes.purpose
+                    })(repos);
+                }
+            }
+            // 複数対応(決済代行IFの場合、0:ChevreError,1:rawError)(2024-03-27~)
+            if (Array.isArray(error)) {
+                throw error[0];
+            }
+            else {
+                throw error;
+            }
+        }
+        const result = (0, factory_1.createAuthorizeResult)({
+            payTransaction,
+            object: authorizeObjectIncludingPaymentMethodDetails,
+            invoiceByTicketToken
+        });
+        await repos.action.completeWithVoid({ typeOf: action.typeOf, id: action.id, result: result });
+        return { id: action.id };
+    };
+}
+/**
+ * 承認しようとしているobjectからaccountIdを決定する
+ */
+function fixAccountIdIfPossible(params) {
+    return async (
+    // repos: {
+    //     action: ActionRepo;
+    //     authorization: AuthorizationRepo;
+    //     ticket: TicketRepo;
+    // }
+    // credentials: {
+    //     jwt: JWTCredentials;
+    // }
+    ) => {
+        let accountId = '';
+        const fromLocation = params.object?.fromLocation;
+        const movieTickets = params.object?.movieTickets;
+        // discontinue token as fromLocation(ticketTokenへ移行するべき)(2024-12-18~)
+        if (typeof fromLocation === 'string') {
+            throw new factory.errors.NotImplemented('object.fromLocation as string not implemented');
+            // トークン化されたペイメントカード情報でリクエストされた場合、実ペイメントカード情報へ変換する
+            // const { authorizedObject } = await verifyToken({
+            //     project: { id: params.project.id },
+            //     agent: { id: params.project.id, typeOf: factory.organizationType.Project },
+            //     token: fromLocation
+            // })(repos);
+            // const paymentCardOwnershipInfo = authorizedObject;
+            // if (Array.isArray(paymentCardOwnershipInfo)) {
+            //     throw new factory.errors.NotImplemented('fromLocation as an array not implemented');
+            // }
+            // if (paymentCardOwnershipInfo.typeOf !== 'OwnershipInfo') {
+            //     throw new factory.errors.Argument('fromLocation', 'must be OwnershipInfo');
+            // }
+            // if (paymentCardOwnershipInfo.typeOfGood.typeOf !== factory.permit.PermitType.Permit) {
+            //     throw new factory.errors.Argument('fromLocation', 'must be Permit');
+            // }
+            // accountId = paymentCardOwnershipInfo.typeOfGood.identifier;
+        }
+        // 購入番号管理番号をaccountIdにセット(2024-03-24~)
+        if (Array.isArray(movieTickets) && movieTickets.length > 0) {
+            accountId = movieTickets[0].identifier; // 決済カードidentifierは1つのみ許可の前提
+        }
+        return { accountId };
+    };
+}

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

@@ -0,0 +1,43 @@
+import * as factory from '../../../factory';
+import type { AcceptPayActionRepo } from '../../../repo/action/acceptPay';
+import type { TaskRepo } from '../../../repo/task';
+interface IFindAcceptActionResult {
+    /**
+     * アクションID
+     */
+    id?: string;
+    /**
+     * アクションスタータス
+     */
+    actionStatus: factory.actionStatusType;
+    object?: Pick<factory.action.accept.pay.IObject, 'transactionNumber'>;
+    /**
+     * エラー
+     */
+    error?: {
+        name?: string;
+        message?: string;
+    };
+    result?: factory.action.accept.pay.IResult;
+}
+declare function findAcceptAction(params: {
+    project: {
+        id: string;
+    };
+    sameAs: {
+        /**
+         * task ID
+         */
+        id: string;
+    };
+    purpose: {
+        /**
+         * transaction ID
+         */
+        id: string;
+    };
+}): (repos: {
+    acceptPayAction: AcceptPayActionRepo;
+    task: TaskRepo;
+}) => Promise<IFindAcceptActionResult>;
+export { findAcceptAction, };