@chevre/domain 23.2.0-alpha.60 → 23.2.0-alpha.62

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

@@ -0,0 +1,102 @@
+"use strict";
+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 async (repos) => {
+        const transaction = await 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?.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,165 @@
+"use strict";
+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 async (repos, settings) => {
+        const paymentServiceType = params.object?.typeOf;
+        // 金額をfix
+        const amount = params.object.paymentMethod?.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');
+        }
+        await (0, validateSeller_1.validateSeller)(params)(repos);
+        // リソースの対応決済方法検証(2025-12-02~)
+        await (0, validateAcceptedPaymentMethodIfNeeded_1.validateAcceptedPaymentMethodIfNeeded)(params)(repos);
+        // 決済サービス確認
+        const paymentServiceId = getPaymentServiceId(params);
+        // 決済受入アクション生成(2024-03-28~)
+        const taskId = options?.executor?.id;
+        const actionAttributes = {
+            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 params.location?.typeOf === 'string')
+                ? { location: params.location }
+                : undefined,
+            ...(typeof params.identifier === 'string') ? { identifier: params.identifier } : undefined
+        };
+        const action = await repos.action.start(actionAttributes);
+        let result;
+        let recipe;
+        try {
+            switch (paymentServiceType) {
+                case factory.service.paymentService.PaymentServiceType.CreditCard:
+                    const authorizeResult = await CreditCardPayment.authorize({
+                        ...params,
+                        id: '' // 決済URL発行プロセスにおいては決済取引IDは使用しないので空文字でok
+                    }, paymentServiceId, {
+                        processPublishPaymentUrl: true,
+                        executor: (typeof options.executor?.id === 'string') ? { id: options.executor.id } : {} // タスク関連付け(2024-05-22~)
+                    })(repos, settings);
+                    let paymentUrl;
+                    // 3DS拡張(2024-01-02~)
+                    const retUrl = params.object.paymentMethod.creditCard?.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 {
+                await repos.action.giveUp({ typeOf: actionAttributes.typeOf, id: action.id, error });
+            }
+            catch (__) {
+                // 失敗したら仕方ない
+            }
+            throw error;
+        }
+        const actionResult = {
+            paymentMethodId: result.paymentMethodId,
+            paymentUrl: result.paymentUrl
+        };
+        await repos.action.completeWithVoid({ typeOf: actionAttributes.typeOf, id: action.id, result: actionResult, recipe });
+        return result;
+    };
+}
+function getPaymentServiceId(params) {
+    let paymentServiceId = '';
+    const paymentServiceType = params.object?.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,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.searchGMOTrade = searchGMOTrade;
+const factory = require("../../../factory");
+const CreditCardPayment = require("../../payment/creditCard");
+/**
+ * 決済代行取引参照
+ */
+function searchGMOTrade(params) {
+    return async (repos, settings) => {
+        const assetTransaction = await 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 = assetTransaction.object.paymentMethod?.identifier;
+        if (typeof paymentMethodType !== 'string') {
+            throw new factory.errors.ArgumentNull('object.paymentMethod.identifier');
+        }
+        const paymentServiceId = String(assetTransaction.object.id);
+        const availableChannel = await repos.paymentService.findAvailableChannelCreditCard({
+            project: assetTransaction.project,
+            // typeOf: factory.service.paymentService.PaymentServiceType.CreditCard,
+            id: paymentServiceId
+        });
+        const sellerId = assetTransaction.recipient?.id;
+        if (typeof sellerId !== 'string') {
+            throw new factory.errors.ArgumentNull('recipient.id');
+        }
+        const { shopId, shopPass } = await 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

@@ -1,30 +1,20 @@
 "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.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;
+    return async (repos) => {
         // 引き出し口座の存在を確認する
-        const paymentMethodType = (_a = params.object.paymentMethod) === null || _a === void 0 ? void 0 : _a.identifier;
+        const paymentMethodType = params.object.paymentMethod?.identifier;
         if (typeof paymentMethodType !== 'string') {
             throw new factory.errors.ArgumentNull('object.paymentMethod.identifier');
         }
-        const accountNumber = (_b = params.object.paymentMethod) === null || _b === void 0 ? void 0 : _b.accountId;
+        const accountNumber = params.object.paymentMethod?.accountId;
         if (typeof accountNumber !== 'string') {
             throw new factory.errors.ArgumentNull('object.paymentMethod.accountId');
         }
         // 販売者から決済情報取得
-        const sellerId = (_c = params.recipient) === null || _c === void 0 ? void 0 : _c.id;
+        const sellerId = params.recipient?.id;
         if (typeof sellerId !== 'string') {
             throw new factory.errors.ArgumentNull('recipient.id');
         }
@@ -42,12 +32,12 @@ function validateAccount(params) {
         //     throw new factory.errors.NotFound(factory.organizationType.Corporation);
         // }
         // const paymentAccepted = seller.paymentAccepted?.some((a) => a.paymentMethodType === paymentMethodType);
-        const paymentAccepted = yield repos.paymentAccepted.isAcceptedBySeller({
+        const paymentAccepted = await repos.paymentAccepted.isAcceptedBySeller({
             seller: { id: sellerId },
             codeValue: paymentMethodType
         });
         if (paymentAccepted !== true) {
             throw new factory.errors.Argument('recipient', `payment not accepted [${paymentMethodType}]`);
         }
-    });
+    };
 }

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,23 +4,22 @@ 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;
     const { instrument } = params;
     const paymentServiceId = (params.paymentService !== undefined)
         ? String(params.paymentService.id)
         : '';
     const paymentMethodType = (params.paymentService !== undefined)
         // FaceToFace以外は、プロダクトから決済方法タイプを自動取得
-        ? (_a = params.paymentService.serviceType) === null || _a === void 0 ? void 0 : _a.codeValue
-        : (_b = params.object.paymentMethod) === null || _b === void 0 ? void 0 : _b.identifier;
+        ? params.paymentService.serviceType?.codeValue
+        : params.object.paymentMethod?.identifier;
     if (typeof paymentMethodType !== 'string') {
         throw new factory.errors.ArgumentNull('object.paymentMethod.identifier');
     }
     let totalPaymentDue;
-    let accountId = (_c = params.object.paymentMethod) === null || _c === void 0 ? void 0 : _c.accountId;
+    let accountId = params.object.paymentMethod?.accountId;
     switch (params.paymentServiceType) {
         case factory.service.paymentService.PaymentServiceType.FaceToFace:
             // 対面決済ではとりあえず問答無用にJPY
@@ -39,14 +38,14 @@ function createStartParams(params, options) {
             accountId = ''; // 強制的に空文字化(2024-06-14~)
             break;
         case factory.service.paymentService.PaymentServiceType.MovieTicket:
-            const specifiedMovieTickets = (_d = params.object.paymentMethod) === null || _d === void 0 ? void 0 : _d.movieTickets;
+            const specifiedMovieTickets = params.object.paymentMethod?.movieTickets;
             totalPaymentDue = {
                 typeOf: 'MonetaryAmount',
                 currency: factory.unitCode.C62,
                 value: (Array.isArray(specifiedMovieTickets)) ? specifiedMovieTickets.length : 0
             };
             // MovieTicketIFの決済取引において最大同時着券数を設定可能にする(2023-03-27~)
-            const totalPaymentDueMaxValue = (_g = (_f = (_e = params.paymentService) === null || _e === void 0 ? void 0 : _e.availableChannel) === null || _f === void 0 ? void 0 : _f.totalPaymentDue) === null || _g === void 0 ? void 0 : _g.maxValue;
+            const totalPaymentDueMaxValue = params.paymentService?.availableChannel?.totalPaymentDue?.maxValue;
             const totalPaymentDueValue = totalPaymentDue.value;
             if (typeof totalPaymentDueValue === 'number' && typeof totalPaymentDueMaxValue === 'number') {
                 if (totalPaymentDueValue > totalPaymentDueMaxValue) {
@@ -67,19 +66,19 @@ function createStartParams(params, options) {
     // currencyはデフォルトでJPY
     let paymentMethodCurrency = factory.priceCurrency.JPY;
     if (params.paymentServiceType === factory.service.paymentService.PaymentServiceType.PaymentCard) {
-        const paymentCardServiceOutputCurrency = (_k = (_j = (_h = params.paymentService) === null || _h === void 0 ? void 0 : _h.serviceOutput) === null || _j === void 0 ? void 0 : _j.amount) === null || _k === void 0 ? void 0 : _k.currency;
+        const paymentCardServiceOutputCurrency = params.paymentService?.serviceOutput?.amount?.currency;
         if (typeof paymentCardServiceOutputCurrency === 'string') {
             paymentMethodCurrency = paymentCardServiceOutputCurrency;
         }
     }
     else if (params.paymentServiceType === factory.service.paymentService.PaymentServiceType.CreditCard) {
-        const creditCardPaymentServiceOutput = (_l = params.paymentService) === null || _l === void 0 ? void 0 : _l.serviceOutput;
+        const creditCardPaymentServiceOutput = params.paymentService?.serviceOutput;
         const invoiceAsServiceOutput = (Array.isArray(creditCardPaymentServiceOutput))
-            ? creditCardPaymentServiceOutput.find((output) => (output === null || output === void 0 ? void 0 : output.typeOf) === 'Invoice')
+            ? creditCardPaymentServiceOutput.find((output) => output?.typeOf === 'Invoice')
             : creditCardPaymentServiceOutput;
         // カード通貨区分が存在すれば適用
-        if ((invoiceAsServiceOutput === null || invoiceAsServiceOutput === void 0 ? void 0 : invoiceAsServiceOutput.typeOf) === 'Invoice') {
-            const creditCardAsPaymentServiceOutputCurrency = (_o = (_m = invoiceAsServiceOutput.paymentMethod) === null || _m === void 0 ? void 0 : _m.amount) === null || _o === void 0 ? void 0 : _o.currency;
+        if (invoiceAsServiceOutput?.typeOf === 'Invoice') {
+            const creditCardAsPaymentServiceOutputCurrency = invoiceAsServiceOutput.paymentMethod?.amount?.currency;
             if (typeof creditCardAsPaymentServiceOutputCurrency === 'string') {
                 paymentMethodCurrency = creditCardAsPaymentServiceOutputCurrency;
             }
@@ -90,43 +89,72 @@ function createStartParams(params, options) {
         currency: paymentMethodCurrency,
         value: params.amount
     };
-    const paymentMethod = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ additionalProperty: (Array.isArray((_p = params.object.paymentMethod) === null || _p === void 0 ? void 0 : _p.additionalProperty))
-            ? (_q = params.object.paymentMethod) === null || _q === void 0 ? void 0 : _q.additionalProperty
-            : [], name: (typeof ((_r = params.object.paymentMethod) === null || _r === void 0 ? void 0 : _r.name) === 'string')
+    const paymentMethod = {
+        additionalProperty: (Array.isArray(params.object.paymentMethod?.additionalProperty))
+            ? params.object.paymentMethod?.additionalProperty
+            : [],
+        name: (typeof params.object.paymentMethod?.name === 'string')
             ? params.object.paymentMethod.name
-            : paymentMethodType, amount: paymentMethodAmount, identifier: paymentMethodType }, (typeof ((_s = params.object.paymentMethod) === null || _s === void 0 ? void 0 : _s.description) === 'string')
-        ? { description: (_t = params.object.paymentMethod) === null || _t === void 0 ? void 0 : _t.description }
-        : undefined), (totalPaymentDue !== undefined)
-        ? { totalPaymentDue: totalPaymentDue }
-        : undefined), (typeof accountId === 'string') ? { accountId: accountId } : undefined), (typeof ((_u = params.object.paymentMethod) === null || _u === void 0 ? void 0 : _u.method) === 'string')
-        ? { method: (_v = params.object.paymentMethod) === null || _v === void 0 ? void 0 : _v.method }
-        : undefined), (((_w = params.object.paymentMethod) === null || _w === void 0 ? void 0 : _w.creditCard) !== undefined)
-        ? { creditCard: (_x = params.object.paymentMethod) === null || _x === void 0 ? void 0 : _x.creditCard }
-        : undefined), (Array.isArray((_y = params.object.paymentMethod) === null || _y === void 0 ? void 0 : _y.movieTickets))
-        ? { movieTickets: (_z = params.object.paymentMethod) === null || _z === void 0 ? void 0 : _z.movieTickets }
-        : undefined), (params.paymentServiceType === factory.service.paymentService.PaymentServiceType.CreditCard)
-        ? { paymentMethodId: params.transactionNumber } // 必要ないはずだが互換性維持対応(2024-06-14~)
-        : undefined);
-    const object = Object.assign({ accountId: (typeof accountId === 'string') ? accountId : '', paymentMethodId: params.transactionNumber, typeOf: params.paymentServiceType, id: paymentServiceId, 
+            : paymentMethodType,
+        amount: paymentMethodAmount, // MonetaryAmount対応(2023-08-14~)
+        identifier: paymentMethodType, // 追加(2023-08-29~)
+        ...(typeof params.object.paymentMethod?.description === 'string')
+            ? { description: params.object.paymentMethod?.description }
+            : undefined,
+        ...(totalPaymentDue !== undefined)
+            ? { totalPaymentDue: totalPaymentDue }
+            : undefined,
+        ...(typeof accountId === 'string') ? { accountId: accountId } : undefined,
+        ...(typeof params.object.paymentMethod?.method === 'string')
+            ? { method: params.object.paymentMethod?.method }
+            : undefined,
+        ...(params.object.paymentMethod?.creditCard !== undefined)
+            ? { creditCard: params.object.paymentMethod?.creditCard }
+            : undefined,
+        ...(Array.isArray(params.object.paymentMethod?.movieTickets))
+            ? { movieTickets: params.object.paymentMethod?.movieTickets }
+            : undefined,
+        ...(params.paymentServiceType === factory.service.paymentService.PaymentServiceType.CreditCard)
+            ? { paymentMethodId: params.transactionNumber } // 必要ないはずだが互換性維持対応(2024-06-14~)
+            : undefined
+    };
+    const object = {
+        accountId: (typeof accountId === 'string') ? accountId : '',
+        paymentMethodId: params.transactionNumber,
+        typeOf: params.paymentServiceType,
+        id: paymentServiceId,
         // onPaymentStatusChanged: { informPayment: params.informActions }, // discontinue(2025-02-09~)
-        paymentMethod, serviceOutput: (((_0 = params.object.serviceOutput) === null || _0 === void 0 ? void 0 : _0.typeOf) === 'Invoice') // support serviceOutput(2025-11-24~)
+        paymentMethod,
+        serviceOutput: (params.object.serviceOutput?.typeOf === 'Invoice') // support serviceOutput(2025-11-24~)
             ? params.object.serviceOutput
             : {
                 typeOf: 'Invoice',
                 referencesOrder: { typeOf: factory.order.OrderType.Order }
-            } }, (params.paymentServiceType === factory.service.paymentService.PaymentServiceType.MovieTicket)
-        ? { checkedAction: { id: options.checkedAction.id } } // add checkedAction(2024-12-13~)
-        : undefined);
+            },
+        ...(params.paymentServiceType === factory.service.paymentService.PaymentServiceType.MovieTicket)
+            ? { checkedAction: { id: options.checkedAction.id } } // add checkedAction(2024-12-13~)
+            : undefined
+    };
     const potentialAction = [];
     params.informActions.forEach((informAction) => {
         if (typeof informAction.id === 'string' && informAction.id !== '') {
             potentialAction.push({ id: informAction.id, typeOf: factory.actionType.InformAction });
         }
     });
-    return Object.assign(Object.assign({ project: { typeOf: factory.organizationType.Project, id: params.project.id }, transactionNumber: params.transactionNumber, typeOf: factory.assetTransactionType.Pay, agent: params.agent, recipient: params.recipient, object, expires: params.expires, instrument: (Array.isArray(instrument)) ? instrument : [] }, (typeof ((_1 = params.location) === null || _1 === void 0 ? void 0 : _1.typeOf) === 'string')
-        ? { location: params.location }
-        : undefined), (potentialAction.length > 0) ? { potentialAction } : undefined // add potentialAction(2025-02-05~)
-    );
+    return {
+        project: { typeOf: factory.organizationType.Project, id: params.project.id },
+        transactionNumber: params.transactionNumber,
+        typeOf: factory.assetTransactionType.Pay,
+        agent: params.agent,
+        recipient: params.recipient,
+        object,
+        expires: params.expires,
+        instrument: (Array.isArray(instrument)) ? instrument : [], // add(2025-02-18~)
+        ...(typeof params.location?.typeOf === 'string')
+            ? { location: params.location }
+            : undefined,
+        ...(potentialAction.length > 0) ? { potentialAction } : undefined // add potentialAction(2025-02-05~)
+    };
 }
 // function createInformPaymentParams(params: {
 //     paymentService?: Pick<factory.service.paymentService.IService, 'availableChannel' | 'potentialAction'>;

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';
 /**
  * 必要あらば関連リソースの対応決済方法を検証する
  */