@chevre/domain 23.2.0-alpha.6 → 23.2.0-alpha.61

package/lib/chevre/service/assetTransaction/pay/exportTasksById.js

@@ -0,0 +1,111 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exportTasksById = exportTasksById;
+const moment = require("moment");
+const factory = require("../../../factory");
+/**
+ * 取引のタスク出力
+ */
+function exportTasksById(params) {
+    // tslint:disable-next-line:max-func-body-length
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        const transaction = yield repos.assetTransaction.findById({
+            typeOf: factory.assetTransactionType.Pay,
+            id: params.id
+        });
+        const potentialActions = transaction.potentialActions;
+        if (transaction.status === factory.transactionStatusType.InProgress) {
+            throw new factory.errors.NotImplemented(`Transaction status "${transaction.status}" not implemented.`);
+        }
+        const taskAttributes = [];
+        // タスク実行日時バッファの指定があれば調整
+        let taskRunsAt = new Date();
+        if (typeof params.runsTasksAfterInSeconds === 'number') {
+            taskRunsAt = moment(taskRunsAt)
+                .add(params.runsTasksAfterInSeconds, 'seconds')
+                .toDate();
+        }
+        const payTransactionAsObject = {
+            project: transaction.project,
+            typeOf: transaction.typeOf,
+            id: transaction.id,
+            transactionNumber: transaction.transactionNumber,
+            object: transaction.object,
+            recipient: transaction.recipient
+        };
+        const voidPaymentTasks = {
+            project: transaction.project,
+            name: factory.taskName.VoidPayment,
+            status: factory.taskStatus.Ready,
+            runsAt: taskRunsAt,
+            remainingNumberOfTries: 10,
+            numberOfTried: 0,
+            executionResults: [],
+            data: { object: payTransactionAsObject }
+        };
+        // OnAssetTransactionStatusChangedを追加(2023-08-30~)
+        const onAssetTransactionStatusChangedTaskData = {
+            project: transaction.project,
+            object: {
+                typeOf: factory.assetTransactionType.Pay,
+                transactionNumber: transaction.transactionNumber,
+                status: transaction.status
+            },
+            purpose: {
+                confirmationNumber: '',
+                orderNumber: '',
+                typeOf: factory.order.OrderType.Order
+            },
+            useOnOrderStatusChanged: true
+        };
+        const onAssetTransactionStatusChangedTask = {
+            project: transaction.project,
+            name: factory.taskName.OnAssetTransactionStatusChanged,
+            status: factory.taskStatus.Ready,
+            runsAt: taskRunsAt,
+            remainingNumberOfTries: 10,
+            numberOfTried: 0,
+            executionResults: [],
+            data: onAssetTransactionStatusChangedTaskData
+        };
+        switch (transaction.status) {
+            case factory.transactionStatusType.Confirmed:
+                const payActions = potentialActions === null || potentialActions === void 0 ? void 0 : potentialActions.pay;
+                if (Array.isArray(payActions) && payActions.length > 0) {
+                    const payTasks = payActions.map(({ object, purpose }) => {
+                        const data = { object, purpose };
+                        return {
+                            project: transaction.project,
+                            name: factory.taskName.Pay,
+                            status: factory.taskStatus.Ready,
+                            runsAt: taskRunsAt,
+                            remainingNumberOfTries: 10,
+                            numberOfTried: 0,
+                            executionResults: [],
+                            data
+                        };
+                    });
+                    taskAttributes.push(...payTasks);
+                }
+                break;
+            case factory.transactionStatusType.Canceled:
+                taskAttributes.push(voidPaymentTasks, onAssetTransactionStatusChangedTask);
+                break;
+            case factory.transactionStatusType.Expired:
+                taskAttributes.push(voidPaymentTasks, onAssetTransactionStatusChangedTask);
+                break;
+            default:
+                throw new factory.errors.NotImplemented(`Transaction status "${transaction.status}" not implemented.`);
+        }
+        return repos.task.saveMany(taskAttributes, { emitImmediately: true });
+    });
+}

package/lib/chevre/service/assetTransaction/pay/publishPaymentUrl.d.ts

@@ -0,0 +1,48 @@
+import * as factory from '../../../factory';
+import { Settings } from '../../../settings';
+import type { AcceptedPaymentMethodRepo } from '../../../repo/acceptedPaymentMethod';
+import type { ActionRepo } from '../../../repo/action';
+import type { EventRepo } from '../../../repo/event';
+import type { EventSeriesRepo } from '../../../repo/eventSeries';
+import type { PaymentServiceRepo } from '../../../repo/paymentService';
+import type { PaymentServiceProviderRepo } from '../../../repo/paymentServiceProvider';
+import type { SellerPaymentAcceptedRepo } from '../../../repo/sellerPaymentAccepted';
+import * as CreditCardPayment from '../../payment/creditCard';
+export type IPublishPaymentUrlOperation<T> = (repos: {
+    acceptedPaymentMethod: AcceptedPaymentMethodRepo;
+    action: ActionRepo;
+    event: EventRepo;
+    eventSeries: EventSeriesRepo;
+    paymentAccepted: SellerPaymentAcceptedRepo;
+    paymentService: PaymentServiceRepo;
+    paymentServiceProvider: PaymentServiceProviderRepo;
+}, settings: Settings) => Promise<T>;
+export type IPublishPaymentUrlResult = CreditCardPayment.IPaymentAgencyTransaction & {
+    paymentMethodId: string;
+    paymentUrl: string;
+};
+/**
+ * 決済ロケーション発行
+ */
+export declare function publishPaymentUrl(params: Pick<factory.assetTransaction.pay.IStartParamsWithoutDetail, 'agent' | 'location' | 'project' | 'recipient' | 'transactionNumber' | 'typeOf'> & {
+    object: factory.action.accept.pay.IPayObject;
+    /**
+     * add identifier for an unique index(2025-02-25~)
+     */
+    identifier?: string;
+    instrument: factory.action.accept.pay.IInstrument[];
+}, options: {
+    purposeAsTransaction: {
+        id: string;
+    };
+    /**
+     * 実行者
+     */
+    executor?: {
+        /**
+         * task ID
+         * taskによって実行されている場合値が存在する
+         */
+        id?: string;
+    };
+}): IPublishPaymentUrlOperation<IPublishPaymentUrlResult>;

package/lib/chevre/service/assetTransaction/pay/publishPaymentUrl.js

@@ -0,0 +1,164 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.publishPaymentUrl = publishPaymentUrl;
+const factory = require("../../../factory");
+const CreditCardPayment = require("../../payment/creditCard");
+const validateAcceptedPaymentMethodIfNeeded_1 = require("./start/preStart/validateAcceptedPaymentMethodIfNeeded");
+const validateSeller_1 = require("./start/preStart/validateSeller");
+function publishPaymentUrlResult2recipe(params) {
+    const { project, result } = params;
+    return {
+        project: { id: project.id, typeOf: factory.organizationType.Project },
+        typeOf: 'Recipe',
+        recipeCategory: factory.recipe.RecipeCategory.publishPaymentUrl,
+        step: [{
+                typeOf: 'HowToSection',
+                itemListElement: [
+                    {
+                        typeOf: 'HowToStep',
+                        identifier: factory.recipe.StepIdentifier.entryTran,
+                        itemListElement: [{
+                                typeOf: 'HowToDirection',
+                                beforeMedia: result.entryTranArgs,
+                                afterMedia: result.entryTranResult
+                                // text: 'entryTran'
+                            }]
+                    },
+                    {
+                        typeOf: 'HowToStep',
+                        identifier: factory.recipe.StepIdentifier.execTran,
+                        itemListElement: [{
+                                typeOf: 'HowToDirection',
+                                beforeMedia: result.execTranArgs,
+                                afterMedia: result.execTranResult
+                                // text: 'execTran'
+                            }]
+                    }
+                ]
+            }]
+    };
+}
+/**
+ * 決済ロケーション発行
+ */
+// tslint:disable-next-line:max-func-body-length
+function publishPaymentUrl(params, options) {
+    // tslint:disable-next-line:max-func-body-length
+    return (repos, settings) => __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d, _e, _f;
+        const paymentServiceType = (_a = params.object) === null || _a === void 0 ? void 0 : _a.typeOf;
+        // 金額をfix
+        const amount = (_b = params.object.paymentMethod) === null || _b === void 0 ? void 0 : _b.amount;
+        if (typeof amount !== 'number') {
+            throw new factory.errors.ArgumentNull('object.paymentMethod.amount');
+        }
+        const transactionNumber = params.transactionNumber;
+        if (typeof transactionNumber !== 'string' || transactionNumber.length === 0) {
+            throw new factory.errors.ArgumentNull('transactionNumber');
+        }
+        yield (0, validateSeller_1.validateSeller)(params)(repos);
+        // リソースの対応決済方法検証(2025-12-02~)
+        yield (0, validateAcceptedPaymentMethodIfNeeded_1.validateAcceptedPaymentMethodIfNeeded)(params)(repos);
+        // 決済サービス確認
+        const paymentServiceId = getPaymentServiceId(params);
+        // 決済受入アクション生成(2024-03-28~)
+        const taskId = (_c = options === null || options === void 0 ? void 0 : options.executor) === null || _c === void 0 ? void 0 : _c.id;
+        const actionAttributes = Object.assign(Object.assign(Object.assign({ project: params.project, typeOf: factory.actionType.AcceptAction, agent: params.agent, object: {
+                object: params.object,
+                transactionNumber,
+                typeOf: params.typeOf
+            }, purpose: { typeOf: factory.transactionType.PlaceOrder, id: options.purposeAsTransaction.id }, instrument: (Array.isArray(params.instrument)) ? params.instrument : [] }, (typeof taskId === 'string')
+            ? { sameAs: { id: taskId, typeOf: 'Task' } } // タスク関連付け(2024-05-22~)
+            : undefined), (typeof ((_d = params.location) === null || _d === void 0 ? void 0 : _d.typeOf) === 'string')
+            ? { location: params.location }
+            : undefined), (typeof params.identifier === 'string') ? { identifier: params.identifier } : undefined);
+        const action = yield repos.action.start(actionAttributes);
+        let result;
+        let recipe;
+        try {
+            switch (paymentServiceType) {
+                case factory.service.paymentService.PaymentServiceType.CreditCard:
+                    const authorizeResult = yield CreditCardPayment.authorize(Object.assign(Object.assign({}, params), { id: '' // 決済URL発行プロセスにおいては決済取引IDは使用しないので空文字でok
+                     }), paymentServiceId, {
+                        processPublishPaymentUrl: true,
+                        executor: (typeof ((_e = options.executor) === null || _e === void 0 ? void 0 : _e.id) === 'string') ? { id: options.executor.id } : {} // タスク関連付け(2024-05-22~)
+                    })(repos, settings);
+                    let paymentUrl;
+                    // 3DS拡張(2024-01-02~)
+                    const retUrl = (_f = params.object.paymentMethod.creditCard) === null || _f === void 0 ? void 0 : _f.retUrl;
+                    if (typeof retUrl === 'string' && retUrl.length > 0) {
+                        paymentUrl = authorizeResult.execTranResult.redirectUrl;
+                    }
+                    else {
+                        paymentUrl = authorizeResult.execTranResult.acsUrl;
+                    }
+                    if (typeof paymentUrl !== 'string' || paymentUrl.length === 0) {
+                        throw new factory.errors.Internal(`Payment URL unable to publish. [retUrl: ${retUrl}]`);
+                    }
+                    result = {
+                        paymentMethodId: transactionNumber,
+                        paymentUrl,
+                        entryTranArgs: authorizeResult.entryTranArgs,
+                        entryTranResult: authorizeResult.entryTranResult,
+                        execTranArgs: authorizeResult.execTranArgs,
+                        execTranResult: authorizeResult.execTranResult
+                    };
+                    // create recipe(2024-06-02~)
+                    recipe = publishPaymentUrlResult2recipe({
+                        project: { id: params.project.id },
+                        result
+                    });
+                    break;
+                default:
+                    throw new factory.errors.NotImplemented(`Payment service '${paymentServiceType}' not implemented`);
+            }
+        }
+        catch (error) {
+            try {
+                yield repos.action.giveUp({ typeOf: actionAttributes.typeOf, id: action.id, error });
+            }
+            catch (__) {
+                // 失敗したら仕方ない
+            }
+            throw error;
+        }
+        const actionResult = {
+            paymentMethodId: result.paymentMethodId,
+            paymentUrl: result.paymentUrl
+        };
+        yield repos.action.completeWithVoid({ typeOf: actionAttributes.typeOf, id: action.id, result: actionResult, recipe });
+        return result;
+    });
+}
+function getPaymentServiceId(params) {
+    var _a;
+    let paymentServiceId = '';
+    const paymentServiceType = (_a = params.object) === null || _a === void 0 ? void 0 : _a.typeOf;
+    if (typeof params.object.id === 'string' && params.object.id.length > 0) {
+        paymentServiceId = params.object.id;
+    }
+    else {
+        switch (paymentServiceType) {
+            case factory.service.paymentService.PaymentServiceType.FaceToFace:
+                // 対面決済は特に何もしない
+                break;
+            case factory.service.paymentService.PaymentServiceType.PaymentCard:
+            case factory.service.paymentService.PaymentServiceType.CreditCard:
+            case factory.service.paymentService.PaymentServiceType.MovieTicket:
+                // リクエストでの指定を必須化(2022-04-12~)
+                throw new factory.errors.ArgumentNull('object.id');
+            default:
+                throw new factory.errors.NotImplemented(`Payment service '${paymentServiceType}' not implemented`);
+        }
+    }
+    return paymentServiceId;
+}

package/lib/chevre/service/assetTransaction/pay/searchGMOTrade.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 決済取引サービス
+ */
+import * as GMO from '@motionpicture/gmo-service';
+import { Settings } from '../../../settings';
+import type { AssetTransactionRepo } from '../../../repo/assetTransaction';
+import type { PaymentServiceRepo } from '../../../repo/paymentService';
+import type { PaymentServiceProviderRepo } from '../../../repo/paymentServiceProvider';
+import type { SellerPaymentAcceptedRepo } from '../../../repo/sellerPaymentAccepted';
+/**
+ * 決済代行取引参照
+ */
+export declare function searchGMOTrade(params: {
+    transactionNumber: string;
+}): (repos: {
+    paymentAccepted: SellerPaymentAcceptedRepo;
+    paymentService: PaymentServiceRepo;
+    paymentServiceProvider: PaymentServiceProviderRepo;
+    assetTransaction: AssetTransactionRepo;
+}, settings: Settings) => Promise<GMO.factory.credit.ISearchTradeResult>;

package/lib/chevre/service/assetTransaction/pay/searchGMOTrade.js

@@ -0,0 +1,59 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.searchGMOTrade = searchGMOTrade;
+const factory = require("../../../factory");
+const CreditCardPayment = require("../../payment/creditCard");
+/**
+ * 決済代行取引参照
+ */
+function searchGMOTrade(params) {
+    return (repos, settings) => __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        const assetTransaction = yield repos.assetTransaction.findByTransactionNumber({
+            typeOf: factory.assetTransactionType.Pay,
+            transactionNumber: params.transactionNumber
+        });
+        if (assetTransaction.object.typeOf !== factory.service.paymentService.PaymentServiceType.CreditCard) {
+            throw new factory.errors.Argument('transactionNumber', 'must be CreditCard payment service');
+        }
+        // if (assetTransaction.status !== factory.transactionStatusType.Confirmed) {
+        //     throw new factory.errors.Argument('transactionNumber', 'must be confirmed');
+        // }
+        // CreditCard系統の決済方法タイプは動的
+        const paymentMethodType = (_a = assetTransaction.object.paymentMethod) === null || _a === void 0 ? void 0 : _a.identifier;
+        if (typeof paymentMethodType !== 'string') {
+            throw new factory.errors.ArgumentNull('object.paymentMethod.identifier');
+        }
+        const paymentServiceId = String(assetTransaction.object.id);
+        const availableChannel = yield repos.paymentService.findAvailableChannelCreditCard({
+            project: assetTransaction.project,
+            // typeOf: factory.service.paymentService.PaymentServiceType.CreditCard,
+            id: paymentServiceId
+        });
+        const sellerId = (_b = assetTransaction.recipient) === null || _b === void 0 ? void 0 : _b.id;
+        if (typeof sellerId !== 'string') {
+            throw new factory.errors.ArgumentNull('recipient.id');
+        }
+        const { shopId, shopPass } = yield CreditCardPayment.getGMOInfoFromSeller({
+            paymentMethodType,
+            seller: { id: sellerId },
+            paymentServiceId,
+            requirePaymentAccepted: false
+        })(repos);
+        return CreditCardPayment.searchGMOTrade({
+            availableChannel,
+            paymentMethodId: String(assetTransaction.transactionNumber),
+            shopId,
+            shopPass
+        }, settings);
+    });
+}

package/lib/chevre/service/assetTransaction/pay/{account → start/account}/validation.d.ts

@@ -1,8 +1,8 @@
 /**
  * ペイメントカード決済取引バリデーション
  */
-import type { SellerPaymentAcceptedRepo } from '../../../../repo/sellerPaymentAccepted';
-import * as factory from '../../../../factory';
+import type { SellerPaymentAcceptedRepo } from '../../../../../repo/sellerPaymentAccepted';
+import * as factory from '../../../../../factory';
 export declare function validateAccount(params: factory.assetTransaction.pay.IStartParamsWithoutDetail): (repos: {
     paymentAccepted: SellerPaymentAcceptedRepo;
 }) => Promise<void>;

package/lib/chevre/service/assetTransaction/pay/{account → start/account}/validation.js

@@ -10,7 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateAccount = validateAccount;
-const factory = require("../../../../factory");
+const factory = require("../../../../../factory");
 function validateAccount(params) {
     return (repos) => __awaiter(this, void 0, void 0, function* () {
         var _a, _b, _c;

package/lib/chevre/service/assetTransaction/pay/{factory.d.ts → start/factory.d.ts}

@@ -1,7 +1,7 @@
 /**
  * 決済取引ファクトリー
  */
-import * as factory from '../../../factory';
+import * as factory from '../../../../factory';
 export declare function createStartParams(params: factory.assetTransaction.pay.IStartParamsWithoutDetail & {
     transactionNumber: string;
     paymentServiceType: factory.service.paymentService.PaymentServiceType;

package/lib/chevre/service/assetTransaction/pay/{factory.js → start/factory.js}

@@ -4,7 +4,7 @@ exports.createStartParams = createStartParams;
 /**
  * 決済取引ファクトリー
  */
-const factory = require("../../../factory");
+const factory = require("../../../../factory");
 // tslint:disable-next-line:cyclomatic-complexity max-func-body-length
 function createStartParams(params, options) {
     var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1;

package/lib/chevre/service/assetTransaction/pay/{validateAcceptedPaymentMethodIfNeeded.d.ts → start/preStart/validateAcceptedPaymentMethodIfNeeded.d.ts}

@@ -1,7 +1,7 @@
-import * as factory from '../../../factory';
-import type { AcceptedPaymentMethodRepo } from '../../../repo/acceptedPaymentMethod';
-import type { EventRepo } from '../../../repo/event';
-import type { EventSeriesRepo } from '../../../repo/eventSeries';
+import * as factory from '../../../../../factory';
+import type { AcceptedPaymentMethodRepo } from '../../../../../repo/acceptedPaymentMethod';
+import type { EventRepo } from '../../../../../repo/event';
+import type { EventSeriesRepo } from '../../../../../repo/eventSeries';
 /**
  * 必要あらば関連リソースの対応決済方法を検証する
  */

package/lib/chevre/service/assetTransaction/pay/{validateAcceptedPaymentMethodIfNeeded.js → start/preStart/validateAcceptedPaymentMethodIfNeeded.js}

@@ -10,11 +10,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateAcceptedPaymentMethodIfNeeded = validateAcceptedPaymentMethodIfNeeded;
-/**
- * ペイメントカード決済取引バリデーション
- */
 const createDebug = require("debug");
-const factory = require("../../../factory");
+const factory = require("../../../../../factory");
 const debug = createDebug('chevre-domain:service:assetTransaction:pay');
 /**
  * 必要あらば関連リソースの対応決済方法を検証する

package/lib/chevre/service/assetTransaction/pay/start/preStart/validateSeller.d.ts

@@ -0,0 +1,8 @@
+import * as factory from '../../../../../factory';
+import type { SellerPaymentAcceptedRepo } from '../../../../../repo/sellerPaymentAccepted';
+/**
+ * 販売者の対応決済方法検証
+ */
+export declare function validateSeller(params: Pick<factory.assetTransaction.pay.IStartParamsWithoutDetail, 'object' | 'recipient'>): (repos: {
+    paymentAccepted: SellerPaymentAcceptedRepo;
+}) => Promise<void>;

package/lib/chevre/service/assetTransaction/pay/start/preStart/validateSeller.js

@@ -0,0 +1,54 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateSeller = validateSeller;
+const factory = require("../../../../../factory");
+/**
+ * 販売者の対応決済方法検証
+ */
+function validateSeller(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        const sellerId = (_a = params.recipient) === null || _a === void 0 ? void 0 : _a.id;
+        if (typeof sellerId !== 'string') {
+            throw new factory.errors.ArgumentNull('recipient.id');
+        }
+        const paymentMethodType = (_b = params.object.paymentMethod) === null || _b === void 0 ? void 0 : _b.identifier;
+        if (typeof paymentMethodType !== 'string') {
+            throw new factory.errors.ArgumentNull('object.paymentMethod.identifier');
+        }
+        // FaceToFaceの場合、決済方法区分未指定に対応(2023-08-29~)
+        if (params.object.typeOf === factory.service.paymentService.PaymentServiceType.FaceToFace) {
+            if (paymentMethodType.length > 0) {
+                // 販売者の対応決済方法かどうか確認
+                // const paymentAccepted = seller.paymentAccepted?.some((a) => a.paymentMethodType === paymentMethodType);
+                const paymentAccepted = yield repos.paymentAccepted.isAcceptedBySeller({
+                    seller: { id: sellerId },
+                    codeValue: paymentMethodType
+                });
+                if (paymentAccepted !== true) {
+                    throw new factory.errors.Argument('object.paymentMethod.identifier', `payment not accepted [${paymentMethodType}]`);
+                }
+            }
+        }
+        else {
+            // 販売者の対応決済方法かどうか確認
+            // const paymentAccepted = seller.paymentAccepted?.some((a) => a.paymentMethodType === paymentMethodType);
+            const paymentAccepted = yield repos.paymentAccepted.isAcceptedBySeller({
+                seller: { id: sellerId },
+                codeValue: paymentMethodType
+            });
+            if (paymentAccepted !== true) {
+                throw new factory.errors.Argument('object.paymentMethod.identifier', `payment not accepted [${paymentMethodType}]`);
+            }
+        }
+    });
+}

package/lib/chevre/service/assetTransaction/pay/start/processAuthorizeAccount.d.ts

@@ -0,0 +1,13 @@
+import * as factory from '../../../../factory';
+import type { AssetTransactionRepo } from '../../../../repo/assetTransaction';
+import type { EventRepo } from '../../../../repo/event';
+import type { ProductRepo } from '../../../../repo/product';
+import type { SellerPaymentAcceptedRepo } from '../../../../repo/sellerPaymentAccepted';
+export declare function processAuthorizeAccount(params: factory.assetTransaction.pay.IStartParamsWithoutDetail, transaction: {
+    id: string;
+}, paymentServiceId: string): (repos: {
+    event: EventRepo;
+    paymentAccepted: SellerPaymentAcceptedRepo;
+    product: ProductRepo;
+    assetTransaction: AssetTransactionRepo;
+}) => Promise<factory.assetTransaction.pay.ITransaction>;

package/lib/chevre/service/assetTransaction/pay/start/processAuthorizeAccount.js

@@ -0,0 +1,49 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processAuthorizeAccount = processAuthorizeAccount;
+const factory = require("../../../../factory");
+const PaymentCardPayment = require("../../../payment/paymentCard");
+const validation_1 = require("./account/validation");
+function processAuthorizeAccount(params, transaction, paymentServiceId) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const amount = (_a = params.object.paymentMethod) === null || _a === void 0 ? void 0 : _a.amount;
+        if (typeof amount !== 'number') {
+            throw new factory.errors.ArgumentNull('object.paymentMethod?.amount');
+        }
+        yield (0, validation_1.validateAccount)(params)(repos);
+        const { pendingTransaction, currency, accountNumber } = yield PaymentCardPayment.authorize(params, paymentServiceId)(repos);
+        const totalPaymentDue = {
+            typeOf: 'MonetaryAmount',
+            currency,
+            value: amount
+        };
+        const savingPendingTransaction = {
+            typeOf: pendingTransaction.typeOf,
+            id: pendingTransaction.id,
+            transactionNumber: pendingTransaction.transactionNumber,
+            object: { fromLocation: { accountNumber } }
+        };
+        return saveAuthorizeResult({
+            id: transaction.id,
+            update: {
+                'object.paymentMethod.totalPaymentDue': totalPaymentDue,
+                'object.pendingTransaction': savingPendingTransaction
+            }
+        })(repos);
+    });
+}
+function saveAuthorizeResult(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        return repos.assetTransaction.findByIdAndUpdateInProgress(params);
+    });
+}

package/lib/chevre/service/assetTransaction/pay/start/processAuthorizeCreditCard.d.ts

@@ -0,0 +1,29 @@
+import * as factory from '../../../../factory';
+import { Settings } from '../../../../settings';
+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 * as CreditCardPayment from '../../../payment/creditCard';
+export declare function processAuthorizeCreditCard(params: factory.assetTransaction.pay.IStartParamsWithoutDetail, transaction: {
+    id: string;
+}, paymentServiceId: string, options: {
+    pendingPaymentAgencyTransaction?: CreditCardPayment.IPaymentAgencyTransaction;
+    /**
+     * 実行者
+     */
+    executor?: {
+        /**
+         * task ID
+         * taskによって実行されている場合値が存在する
+         */
+        id?: string;
+    };
+}): (repos: {
+    action: ActionRepo;
+    paymentAccepted: SellerPaymentAcceptedRepo;
+    paymentService: PaymentServiceRepo;
+    paymentServiceProvider: PaymentServiceProviderRepo;
+    assetTransaction: AssetTransactionRepo;
+}, settings: Settings) => Promise<void>;