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

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

@@ -1,20 +1,8 @@
 "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.validateAcceptedPaymentMethodIfNeeded = validateAcceptedPaymentMethodIfNeeded;
-/**
- * ペイメントカード決済取引バリデーション
- */
 const createDebug = require("debug");
-const factory = require("../../../factory");
+const factory = require("../../../../../factory");
 const debug = createDebug('chevre-domain:service:assetTransaction:pay');
 /**
  * 必要あらば関連リソースの対応決済方法を検証する
@@ -22,8 +10,7 @@ const debug = createDebug('chevre-domain:service:assetTransaction:pay');
 // tslint:disable-next-line:max-func-body-length
 function validateAcceptedPaymentMethodIfNeeded(params) {
     // tslint:disable-next-line:max-func-body-length
-    return (repos) => __awaiter(this, void 0, void 0, function* () {
-        var _a, _b;
+    return async (repos) => {
         const now = new Date();
         /**
          * 検証対象のイベントIDリスト
@@ -34,7 +21,7 @@ function validateAcceptedPaymentMethodIfNeeded(params) {
         // CreditCard or MovieTicket?
         if (paymentServiceType === factory.service.paymentService.PaymentServiceType.CreditCard) {
             // クレジットカードIF決済の場合、objectに注文アイテム指定があればそちらで検証する
-            const orderedItems = (_a = params.object.serviceOutput) === null || _a === void 0 ? void 0 : _a.referencesOrder.orderedItem;
+            const orderedItems = params.object.serviceOutput?.referencesOrder.orderedItem;
             if (Array.isArray(orderedItems)) {
                 checkingEventIds = orderedItems.map((orderedItem) => orderedItem.orderedItem.serviceOutput.reservationFor.id);
             }
@@ -59,7 +46,7 @@ function validateAcceptedPaymentMethodIfNeeded(params) {
                 throw new factory.errors.ArgumentNull('object.serviceOutput.referencesOrder.orderedItem');
             }
             // 指定された全イベントについて、施設コンテンツの対応決済方法を検証する
-            const eventSeriesIds = (yield repos.event.projectEventFields({
+            const eventSeriesIds = (await repos.event.projectEventFields({
                 limit: checkingEventIds.length,
                 page: 1,
                 id: { $in: checkingEventIds },
@@ -71,7 +58,7 @@ function validateAcceptedPaymentMethodIfNeeded(params) {
             const uniqueEventSeriesIds = [...new Set(eventSeriesIds)];
             debug('validateAcceptedPaymentMethodIfNeeded: eventSeries with AggregateOffer?', uniqueEventSeriesIds);
             for (const eventSeriesId of uniqueEventSeriesIds) {
-                const eventSeries = (yield repos.eventSeries.projectEventSeriesFields({
+                const eventSeries = (await repos.eventSeries.projectEventSeriesFields({
                     limit: 1,
                     page: 1,
                     id: { $eq: eventSeriesId }
@@ -79,7 +66,7 @@ function validateAcceptedPaymentMethodIfNeeded(params) {
                 if (eventSeries === undefined) {
                     throw new factory.errors.NotFound(factory.eventType.ScreeningEventSeries);
                 }
-                if (((_b = eventSeries.offers) === null || _b === void 0 ? void 0 : _b.typeOf) === factory.offerType.AggregateOffer) {
+                if (eventSeries.offers?.typeOf === factory.offerType.AggregateOffer) {
                     // 対応決済方法オファーIDの指定が必要
                     const acceptedPaymentMethodOfferIds = [];
                     params.instrument.forEach((instrument) => {
@@ -91,7 +78,7 @@ function validateAcceptedPaymentMethodIfNeeded(params) {
                         throw new factory.errors.ArgumentNull('acceptedPaymentMethodOfferIds');
                     }
                     // 全施設コンテンツについて有効な対応決済方法オファーの存在を検証
-                    const validAcceptedPaymentMethodOffer = (yield repos.acceptedPaymentMethod.findAcceptedPaymentMethods({
+                    const validAcceptedPaymentMethodOffer = (await repos.acceptedPaymentMethod.findAcceptedPaymentMethods({
                         limit: 1,
                         page: 1,
                         id: { $in: acceptedPaymentMethodOfferIds }, // 指定されたIDで
@@ -112,5 +99,5 @@ function validateAcceptedPaymentMethodIfNeeded(params) {
         else {
             // 関連注文の指定がなければ検証の必要なし
         }
-    });
+    };
 }

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,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateSeller = validateSeller;
+const factory = require("../../../../../factory");
+/**
+ * 販売者の対応決済方法検証
+ */
+function validateSeller(params) {
+    return async (repos) => {
+        const sellerId = params.recipient?.id;
+        if (typeof sellerId !== 'string') {
+            throw new factory.errors.ArgumentNull('recipient.id');
+        }
+        const paymentMethodType = params.object.paymentMethod?.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 = await 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 = await 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,39 @@
+"use strict";
+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 async (repos) => {
+        const amount = params.object.paymentMethod?.amount;
+        if (typeof amount !== 'number') {
+            throw new factory.errors.ArgumentNull('object.paymentMethod?.amount');
+        }
+        await (0, validation_1.validateAccount)(params)(repos);
+        const { pendingTransaction, currency, accountNumber } = await 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 async (repos) => {
+        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>;

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processAuthorizeCreditCard = processAuthorizeCreditCard;
+const CreditCardPayment = require("../../../payment/creditCard");
+function processAuthorizeCreditCard(params, transaction, paymentServiceId, options) {
+    return async (repos, settings) => {
+        await CreditCardPayment.authorize({ ...params, id: transaction.id }, paymentServiceId, {
+            processPublishPaymentUrl: false,
+            executor: (typeof options.executor?.id === 'string') ? { id: options.executor.id } : {}, // タスク関連付け(2024-05-18~)
+            ...(options.pendingPaymentAgencyTransaction !== undefined)
+                ? { pendingPaymentAgencyTransaction: options.pendingPaymentAgencyTransaction }
+                : undefined
+        })(repos, settings);
+        // ↓discontinue(2024-06-14~)
+        // return saveAuthorizeResult({
+        //     id: transaction.id,
+        //     update: {
+        //         'object.accountId': authorizeResult.accountId,
+        //         'object.paymentMethod.accountId': authorizeResult.accountId,
+        //         'object.paymentMethod.paymentMethodId': authorizeResult.paymentMethodId,
+        //         'object.entryTranArgs': authorizeResult.entryTranArgs,
+        //         'object.entryTranResult': authorizeResult.entryTranResult,
+        //         'object.execTranArgs': authorizeResult.execTranArgs,
+        //         'object.execTranResult': authorizeResult.execTranResult,
+        //         ...(authorizeResult.secureTran2Result !== undefined)
+        //             ? { 'object.secureTran2Result': authorizeResult.secureTran2Result }
+        //             : undefined
+        //     }
+        // })(repos);
+    };
+}

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

@@ -0,0 +1,42 @@
+import * as factory from '../../../../factory';
+import { Settings } from '../../../../settings';
+import type { AccountingReportRepo } from '../../../../repo/accountingReport';
+import type { ActionRepo } from '../../../../repo/action';
+import type { AssetTransactionRepo } from '../../../../repo/assetTransaction';
+import type { CredentialsRepo } from '../../../../repo/credentials';
+import type { EventRepo } from '../../../../repo/event';
+import type { PaymentServiceRepo } from '../../../../repo/paymentService';
+import type { PaymentServiceProviderRepo } from '../../../../repo/paymentServiceProvider';
+import type { SellerPaymentAcceptedRepo } from '../../../../repo/sellerPaymentAccepted';
+import type { TaskRepo } from '../../../../repo/task';
+export declare function processAuthorizeMovieTicket(params: factory.assetTransaction.pay.IStartParamsWithoutDetail, transaction: factory.assetTransaction.pay.ITransaction, paymentServiceId: string, options: {
+    /**
+     * 実行者
+     */
+    executor?: {
+        /**
+         * task ID
+         * taskによって実行されている場合値が存在する
+         */
+        id?: string;
+    };
+    purpose: {
+        /**
+         * placeOrder ID
+         */
+        id?: string;
+    };
+    checkedAction: {
+        id: string;
+    };
+}): (repos: {
+    accountingReport: AccountingReportRepo;
+    action: ActionRepo;
+    credentials: CredentialsRepo;
+    event: EventRepo;
+    paymentAccepted: SellerPaymentAcceptedRepo;
+    paymentService: PaymentServiceRepo;
+    paymentServiceProvider: PaymentServiceProviderRepo;
+    assetTransaction: AssetTransactionRepo;
+    task: TaskRepo;
+}, settings: Settings) => Promise<factory.assetTransaction.pay.ITransaction>;

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processAuthorizeMovieTicket = processAuthorizeMovieTicket;
+const MovieTicketPayment = require("../../../payment/movieTicket");
+function processAuthorizeMovieTicket(params, transaction, paymentServiceId, 
+// useCheckByIdentifierIfNotYet: boolean,
+options) {
+    return async (repos, settings) => {
+        // const { accountsReceivablesByServiceType } = await MovieTicketPayment.authorize(
+        //     params, transaction, paymentServiceId, options
+        // )(repos, settings);
+        await MovieTicketPayment.authorize(params, transaction, paymentServiceId, options)(repos, settings);
+        return transaction;
+        // discontinue(2024-12-17~)
+        // return saveAuthorizeResult({
+        //     id: transaction.id,
+        //     update: {
+        //         'object.accountsReceivablesByServiceType': accountsReceivablesByServiceType // 認証レスポンスより計上金額を保管(2023-05-15~)
+        //     }
+        // })(repos);
+    };
+}

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

@@ -0,0 +1,60 @@
+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 { AssetTransactionRepo } from '../../../repo/assetTransaction';
+import type { CredentialsRepo } from '../../../repo/credentials';
+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 { PotentialActionRepo } from '../../../repo/potentialAction';
+import type { ProductRepo } from '../../../repo/product';
+import type { SellerPaymentAcceptedRepo } from '../../../repo/sellerPaymentAccepted';
+import type { TaskRepo } from '../../../repo/task';
+import { IPaymentAgencyTransaction } from '../../payment/creditCard';
+export interface IStartOperationRepos {
+    acceptedPaymentMethod: AcceptedPaymentMethodRepo;
+    accountingReport: AccountingReportRepo;
+    action: ActionRepo;
+    credentials: CredentialsRepo;
+    event: EventRepo;
+    eventSeries: EventSeriesRepo;
+    paymentAccepted: SellerPaymentAcceptedRepo;
+    paymentService: PaymentServiceRepo;
+    paymentServiceProvider: PaymentServiceProviderRepo;
+    potentialAction: PotentialActionRepo;
+    product: ProductRepo;
+    assetTransaction: AssetTransactionRepo;
+    task: TaskRepo;
+}
+export type IStartOperation<T> = (repos: IStartOperationRepos, settings: Settings) => Promise<T>;
+export { IPaymentAgencyTransaction };
+/**
+ * 取引開始
+ */
+export declare function start(params: factory.assetTransaction.pay.IStartParamsWithoutDetail & {
+    instrument: factory.action.trade.pay.IPlaceOrderRelatedInstrument[];
+}, options: {
+    pendingPaymentAgencyTransaction?: IPaymentAgencyTransaction;
+    /**
+     * 実行者
+     */
+    executor?: {
+        /**
+         * task ID
+         * taskによって実行されている場合値が存在する
+         */
+        id?: string;
+    };
+    purpose: {
+        /**
+         * placeOrder ID
+         */
+        id?: string;
+    };
+    checkedAction: {
+        id: string;
+    };
+}): IStartOperation<Pick<factory.assetTransaction.pay.ITransaction, 'id' | 'object'>>;

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

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.start = start;
+const factory = require("../../../factory");
+const fixInformAction_1 = require("../fixInformAction");
+const validateAcceptedPaymentMethodIfNeeded_1 = require("./start/preStart/validateAcceptedPaymentMethodIfNeeded");
+const validateSeller_1 = require("./start/preStart/validateSeller");
+const factory_1 = require("./start/factory");
+const processAuthorizeAccount_1 = require("./start/processAuthorizeAccount");
+const processAuthorizeCreditCard_1 = require("./start/processAuthorizeCreditCard");
+const processAuthorizeMovieTicket_1 = require("./start/processAuthorizeMovieTicket");
+/**
+ * 取引開始
+ */
+function start(params, options) {
+    return async (repos, settings) => {
+        // 金額を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 paymentServiceType = params.object?.typeOf;
+        const paymentService = await fixPaymentService(params)(repos);
+        const informActions = await (0, fixInformAction_1.fixInformAction)({
+            paymentService,
+            project: { id: params.project.id }
+        })(repos);
+        // 取引開始
+        let transaction;
+        const startParams = (0, factory_1.createStartParams)({
+            ...params,
+            transactionNumber,
+            paymentServiceType,
+            amount,
+            paymentService,
+            informActions
+        }, { checkedAction: options.checkedAction } // 連携(2024-12-13~)
+        );
+        transaction = await repos.assetTransaction.start(startParams);
+        switch (paymentServiceType) {
+            case factory.service.paymentService.PaymentServiceType.FaceToFace:
+                // 対面決済は特に何もしない
+                break;
+            case factory.service.paymentService.PaymentServiceType.PaymentCard:
+                transaction = await (0, processAuthorizeAccount_1.processAuthorizeAccount)(params, transaction, String(paymentService?.id))(repos);
+                break;
+            case factory.service.paymentService.PaymentServiceType.CreditCard:
+                // transaction =
+                await (0, processAuthorizeCreditCard_1.processAuthorizeCreditCard)(params, transaction, String(paymentService?.id), {
+                    executor: (typeof options.executor?.id === 'string') ? { id: options.executor.id } : {}, // タスク関連付け(2024-05-18~)
+                    ...(options.pendingPaymentAgencyTransaction !== undefined)
+                        ? { pendingPaymentAgencyTransaction: options.pendingPaymentAgencyTransaction }
+                        : undefined
+                })(repos, settings);
+                break;
+            case factory.service.paymentService.PaymentServiceType.MovieTicket:
+                transaction = await (0, processAuthorizeMovieTicket_1.processAuthorizeMovieTicket)(params, transaction, String(paymentService?.id), 
+                // options.useCheckByIdentifierIfNotYet,
+                {
+                    executor: (typeof options.executor?.id === 'string') ? { id: options.executor.id } : {},
+                    purpose: options.purpose,
+                    checkedAction: options.checkedAction
+                })(repos, settings);
+                break;
+            default:
+                throw new factory.errors.NotImplemented(`Payment service '${paymentServiceType}' not implemented`);
+        }
+        return transaction;
+    };
+}
+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;
+}
+function fixPaymentService(params) {
+    return async (repos) => {
+        const paymentServiceType = params.object?.typeOf;
+        let paymentService;
+        switch (paymentServiceType) {
+            case factory.service.paymentService.PaymentServiceType.FaceToFace:
+                // no op
+                // FaceToFaceの場合プロダクトは存在しない
+                break;
+            // PaymentCardの場合、プロダクト検索
+            case factory.service.paymentService.PaymentServiceType.PaymentCard:
+                paymentService = (await repos.product.projectFields({
+                    limit: 1,
+                    page: 1,
+                    project: { id: { $eq: params.project.id } },
+                    typeOf: { $eq: factory.product.ProductType.PaymentCard },
+                    id: { $eq: getPaymentServiceId(params) }
+                }, ['availableChannel', 'serviceOutput', 'serviceType', 'potentialAction']
+                // []
+                )).shift();
+                if (paymentService === undefined) {
+                    throw new factory.errors.NotFound('PaymentService');
+                }
+                break;
+            default:
+                paymentService = (await repos.paymentService.projectFields({
+                    limit: 1,
+                    page: 1,
+                    project: { id: { $eq: params.project.id } },
+                    typeOf: { $eq: paymentServiceType },
+                    id: { $eq: getPaymentServiceId(params) }
+                }, ['availableChannel', 'serviceOutput', 'serviceType', 'potentialAction'])).shift();
+                if (paymentService === undefined) {
+                    throw new factory.errors.NotFound('PaymentService');
+                }
+        }
+        return paymentService;
+    };
+}