@chevre/domain 15.65.0-alpha.9 → 20.0.0-alpha.1

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

@@ -0,0 +1,94 @@
+"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.onPaymentStatusChanged = void 0;
+const factory = require("../../../factory");
+const onPaid_1 = require("./onPaymentStatusChanged/onPaid");
+const onRefunded_1 = require("./onPaymentStatusChanged/onRefunded");
+/**
+ * 決済ステータス変更イベント
+ */
+function onPaymentStatusChanged(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        // アクションリポジトリから実アクションを参照する
+        // そうすることで、通知する情報は最低限で済む
+        const action = yield repos.action.findById({ id: params.id, typeOf: params.typeOf });
+        const optimizedAction = optimizeAction4report(action);
+        switch (optimizedAction.typeOf) {
+            case factory.actionType.PayAction:
+                yield (0, onPaid_1.onPaid)(optimizedAction)(repos);
+                break;
+            case factory.actionType.RefundAction:
+                yield (0, onRefunded_1.onRefunded)(optimizedAction)(repos);
+                break;
+            default:
+            // no op
+        }
+    });
+}
+exports.onPaymentStatusChanged = onPaymentStatusChanged;
+/**
+ * 経理レポート連携対象としてのアクションを最適化
+ */
+function optimizeAction4report(action) {
+    let optimizedAction;
+    // 現時点で経理レポートで使用されているのは、typeOf,object,purpose,startDate
+    const actionTypeOf = action.typeOf;
+    switch (actionTypeOf) {
+        case factory.actionType.PayAction:
+            const optimizedPayActionObject = action.object.map((o) => {
+                return {
+                    id: o.id,
+                    paymentMethod: o.paymentMethod,
+                    typeOf: o.typeOf
+                };
+            });
+            const optimizedPayAction = {
+                actionStatus: action.actionStatus,
+                endDate: action.endDate,
+                id: action.id,
+                object: optimizedPayActionObject,
+                project: action.project,
+                purpose: action.purpose,
+                startDate: action.startDate,
+                typeOf: action.typeOf
+                // 不要なので廃止(2022-05-19~)
+                // ...(maskedRecipient !== undefined) ? { recipient: <factory.action.trade.pay.IRecipient>maskedRecipient } : undefined
+            };
+            optimizedAction = optimizedPayAction;
+            break;
+        case factory.actionType.RefundAction:
+            const optimizedRefundActionObject = action.object.map((o) => {
+                return {
+                    id: o.id,
+                    paymentMethod: o.paymentMethod,
+                    typeOf: o.typeOf
+                };
+            });
+            const optimizedRefundAction = {
+                actionStatus: action.actionStatus,
+                endDate: action.endDate,
+                id: action.id,
+                object: optimizedRefundActionObject,
+                project: action.project,
+                purpose: action.purpose,
+                startDate: action.startDate,
+                typeOf: action.typeOf
+                // 不要なので廃止(2022-05-19~)
+                // ...(maskedRecipient !== undefined) ? { recipient: maskedRecipient } : undefined
+            };
+            optimizedAction = optimizedRefundAction;
+            break;
+        default:
+            throw new factory.errors.NotImplemented(`action type '${actionTypeOf}' not implemented`);
+    }
+    return optimizedAction;
+}

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

@@ -0,0 +1,16 @@
+/**
+ * 汎用決済サービス
+ */
+import * as factory from '../../../factory';
+import { MongoRepository as AccountingReportRepo } from '../../../repo/accountingReport';
+import { MongoRepository as ActionRepo } from '../../../repo/action';
+import { MongoRepository as TaskRepo } from '../../../repo/task';
+/**
+ * 返金後のアクション
+ */
+declare function onRefund(refundAction: factory.action.trade.refund.IAction): (repos: {
+    action: ActionRepo;
+    accountingReport: AccountingReportRepo;
+    task: TaskRepo;
+}) => Promise<any[]>;
+export { onRefund };

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

@@ -0,0 +1,98 @@
+"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.onRefund = void 0;
+/**
+ * 汎用決済サービス
+ */
+const factory = require("../../../factory");
+const factory_1 = require("./factory");
+const onPaymentStatusChanged_1 = require("./onPaymentStatusChanged");
+/**
+ * 返金後のアクション
+ */
+function onRefund(refundAction) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const aciton4inform = (0, factory_1.optimizeAction4inform)(refundAction);
+        const potentialActions = refundAction.potentialActions;
+        const now = new Date();
+        const taskAttributes = [];
+        const add2report = potentialActions === null || potentialActions === void 0 ? void 0 : potentialActions.add2report;
+        if (add2report === true) {
+            // 同期的に経理レポート連携する(2022-08-27~)
+            yield (0, onPaymentStatusChanged_1.onPaymentStatusChanged)(aciton4inform)(repos);
+        }
+        const informPayment = potentialActions === null || potentialActions === void 0 ? void 0 : potentialActions.informPayment;
+        // 手数料決済があれば処理
+        const refundFee = (_a = refundAction.object[0]) === null || _a === void 0 ? void 0 : _a.refundFee;
+        if (typeof refundFee === 'number' && refundFee > 0) {
+            const payObject = refundAction.object.map((o) => {
+                return {
+                    typeOf: o.typeOf,
+                    id: o.id,
+                    paymentMethod: {
+                        accountId: o.paymentMethod.accountId,
+                        additionalProperty: o.paymentMethod.additionalProperty,
+                        name: o.paymentMethod.name,
+                        paymentMethodId: o.paymentMethod.paymentMethodId,
+                        totalPaymentDue: {
+                            typeOf: 'MonetaryAmount',
+                            currency: factory.priceCurrency.JPY,
+                            value: refundFee
+                        },
+                        typeOf: o.paymentMethod.typeOf
+                    }
+                };
+            });
+            const payAction = {
+                project: refundAction.project,
+                typeOf: factory.actionType.PayAction,
+                object: payObject,
+                agent: refundAction.recipient,
+                recipient: refundAction.agent,
+                purpose: refundAction.purpose,
+                potentialActions: {
+                    add2report: true,
+                    informPayment: (Array.isArray(informPayment)) ? informPayment : []
+                }
+            };
+            const payTask = {
+                project: refundAction.project,
+                name: factory.taskName.Pay,
+                status: factory.taskStatus.Ready,
+                runsAt: now,
+                remainingNumberOfTries: 10,
+                numberOfTried: 0,
+                executionResults: [],
+                data: payAction
+            };
+            taskAttributes.push(payTask);
+        }
+        if (Array.isArray(informPayment)) {
+            taskAttributes.push(...informPayment.map((a) => {
+                return {
+                    project: a.project,
+                    name: factory.taskName.TriggerWebhook,
+                    status: factory.taskStatus.Ready,
+                    runsAt: now,
+                    remainingNumberOfTries: 10,
+                    numberOfTried: 0,
+                    executionResults: [],
+                    data: Object.assign(Object.assign({}, a), { object: aciton4inform })
+                };
+            }));
+        }
+        // タスク保管
+        return repos.task.saveMany(taskAttributes);
+    });
+}
+exports.onRefund = onRefund;

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

@@ -0,0 +1,3 @@
+import * as factory from '../../../factory';
+declare function person2username(person: factory.person.IPerson): Promise<string>;
+export { person2username };

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

@@ -0,0 +1,52 @@
+"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.person2username = void 0;
+const settings_1 = require("../../../settings");
+const person_1 = require("../../../repo/person");
+const USERPOOL_ID_OLD = settings_1.settings.userPoolIdOld;
+const SSKTS_PROVIDER_NAME = 'SSKTS';
+function person2username(person) {
+    var _a, _b, _c, _d;
+    return __awaiter(this, void 0, void 0, function* () {
+        let username = (_a = person.memberOf) === null || _a === void 0 ? void 0 : _a.membershipNumber;
+        // ユーザープールが本家の場合とsskstの場合に対応
+        // 本家にssktsをプロバイダーとしてログインしている場合、追加特性に以下のような値のidentitiesがあるはず
+        // [{"userId":"xxxx","providerName":"SSKTS","providerType":"OIDC"}]
+        const userIdentitiesStr = (_c = (_b = person.additionalProperty) === null || _b === void 0 ? void 0 : _b.find((p) => p.name === 'identities')) === null || _c === void 0 ? void 0 : _c.value;
+        if (typeof userIdentitiesStr === 'string' && userIdentitiesStr.length > 0) {
+            try {
+                const identities = JSON.parse(userIdentitiesStr);
+                if (Array.isArray(identities) && identities.length > 0) {
+                    const providerName = identities[0].providerName;
+                    const userIdByIdentities = identities[0].userId;
+                    if (providerName === SSKTS_PROVIDER_NAME) {
+                        if (typeof userIdByIdentities === 'string' && userIdByIdentities.length > 0) {
+                            const personRepo = new person_1.CognitoRepository({
+                                userPoolId: USERPOOL_ID_OLD
+                            });
+                            // oldUserは必ず存在するはず
+                            const oldUser = yield personRepo.findById({ userId: userIdByIdentities });
+                            username = String((_d = oldUser.memberOf) === null || _d === void 0 ? void 0 : _d.membershipNumber);
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                // tslint:disable-next-line:no-console
+                console.error('person2username throwed', error);
+                throw error;
+            }
+        }
+        return username;
+    });
+}
+exports.person2username = person2username;

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

@@ -0,0 +1,105 @@
+/**
+ * 汎用決済サービス
+ */
+import * as factory from '../../factory';
+import { MongoRepository as AccountingReportRepo } from '../../repo/accountingReport';
+import { MongoRepository as ActionRepo } from '../../repo/action';
+import { MongoRepository as AssetTransactionRepo } from '../../repo/assetTransaction';
+import { MongoRepository as EventRepo } from '../../repo/event';
+import { CognitoRepository as PersonRepo } from '../../repo/person';
+import { MongoRepository as ProductRepo } from '../../repo/product';
+import { MongoRepository as ProjectRepo } from '../../repo/project';
+import { MongoRepository as SellerRepo } from '../../repo/seller';
+import { MongoRepository as TaskRepo } from '../../repo/task';
+import { MongoRepository as TransactionRepo } from '../../repo/transaction';
+import { RedisRepository as TransactionNumberRepo } from '../../repo/transactionNumber';
+import * as PayTransactionService from '../assetTransaction/pay';
+import { onPaymentStatusChanged } from './any/onPaymentStatusChanged';
+import { person2username } from './any/person2username';
+declare type IAuthorizePaymentAction = factory.action.authorize.paymentMethod.any.IAction;
+/**
+ * 決済承認中止
+ * タスクから決済承認を取り消す
+ */
+declare function voidPayTransaction(params: factory.task.IData<factory.taskName.VoidPayTransaction>): (repos: {
+    accountingReport: AccountingReportRepo;
+    action: ActionRepo;
+    assetTransaction: AssetTransactionRepo;
+    product: ProductRepo;
+    project: ProjectRepo;
+    seller: SellerRepo;
+    task: TaskRepo;
+    transaction: TransactionRepo;
+}) => Promise<void>;
+declare function invalidatePaymentUrl(params: factory.task.IData<factory.taskName.VoidPayTransaction>): (repos: {
+    accountingReport: AccountingReportRepo;
+    action: ActionRepo;
+    assetTransaction: AssetTransactionRepo;
+    product: ProductRepo;
+    project: ProjectRepo;
+    seller: SellerRepo;
+    task: TaskRepo;
+    transaction: TransactionRepo;
+}) => Promise<void>;
+/**
+ * 決済承認中止
+ * apiもしくはタスクから決済承認を取り消す
+ */
+declare function processVoidPayTransaction(params: factory.task.IData<factory.taskName.VoidPayTransaction>): (repos: {
+    action: ActionRepo;
+    assetTransaction: AssetTransactionRepo;
+    transaction: TransactionRepo;
+}) => Promise<void>;
+interface IAuthorizeRepos {
+    accountingReport: AccountingReportRepo;
+    action: ActionRepo;
+    assetTransaction: AssetTransactionRepo;
+    event: EventRepo;
+    person: PersonRepo;
+    product: ProductRepo;
+    project: ProjectRepo;
+    seller: SellerRepo;
+    task: TaskRepo;
+    transaction: TransactionRepo;
+    transactionNumber: TransactionNumberRepo;
+}
+declare type IAuthorizeOperation<T> = (repos: IAuthorizeRepos) => Promise<T>;
+interface IPublishPaymentUrlRepos {
+    assetTransaction: AssetTransactionRepo;
+    person: PersonRepo;
+    product: ProductRepo;
+    project: ProjectRepo;
+    seller: SellerRepo;
+    transaction: TransactionRepo;
+    transactionNumber: TransactionNumberRepo;
+}
+declare type IPublishPaymentUrlOperation<T> = (repos: IPublishPaymentUrlRepos) => Promise<T>;
+/**
+ * 外部決済ロケーションを発行する
+ */
+declare function publishPaymentUrl(params: {
+    project: {
+        id: string;
+    };
+    agent: {
+        id: string;
+    };
+    object: factory.action.authorize.paymentMethod.any.IObject;
+    purpose: factory.action.authorize.paymentMethod.any.IPurpose;
+    paymentServiceType: factory.service.paymentService.PaymentServiceType;
+}): IPublishPaymentUrlOperation<PayTransactionService.IPublishPaymentUrlResult>;
+/**
+ * 決済承認
+ */
+declare function authorize(params: {
+    project: {
+        id: string;
+    };
+    agent: {
+        id: string;
+    };
+    object: factory.action.authorize.paymentMethod.any.IObject;
+    purpose: factory.action.authorize.paymentMethod.any.IPurpose;
+    paymentServiceType: factory.service.paymentService.PaymentServiceType;
+}): IAuthorizeOperation<IAuthorizePaymentAction>;
+export { onPaymentStatusChanged, authorize, invalidatePaymentUrl, voidPayTransaction, person2username, processVoidPayTransaction, publishPaymentUrl };

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

@@ -0,0 +1,293 @@
+"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 = exports.processVoidPayTransaction = exports.person2username = exports.voidPayTransaction = exports.invalidatePaymentUrl = exports.authorize = exports.onPaymentStatusChanged = void 0;
+/**
+ * 汎用決済サービス
+ */
+const factory = require("../../factory");
+const PayTransactionService = require("../assetTransaction/pay");
+const code_1 = require("../code");
+const factory_1 = require("./any/factory");
+const onPaymentStatusChanged_1 = require("./any/onPaymentStatusChanged");
+Object.defineProperty(exports, "onPaymentStatusChanged", { enumerable: true, get: function () { return onPaymentStatusChanged_1.onPaymentStatusChanged; } });
+const person2username_1 = require("./any/person2username");
+Object.defineProperty(exports, "person2username", { enumerable: true, get: function () { return person2username_1.person2username; } });
+/**
+ * 決済承認中止
+ * タスクから決済承認を取り消す
+ */
+function voidPayTransaction(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        // 決済承認アクションを検索
+        let authorizeActions = yield repos.action.searchByPurpose({
+            typeOf: factory.actionType.AuthorizeAction,
+            purpose: {
+                typeOf: params.purpose.typeOf,
+                id: params.purpose.id
+            }
+        });
+        authorizeActions = authorizeActions.filter((a) => a.object.typeOf === factory.action.authorize.paymentMethod.any.ResultType.Payment);
+        // Chevreを使用した承認を取り消し
+        const authorizeActionsWithChevre = authorizeActions.filter((a) => {
+            var _a;
+            return ((_a = a.instrument) === null || _a === void 0 ? void 0 : _a.identifier) === factory.action.authorize.paymentMethod.any.ServiceIdentifier.Chevre;
+        });
+        if (authorizeActionsWithChevre.length > 0) {
+            yield processVoidPayTransaction(params)(repos);
+        }
+        // 決済URL無効化もここで処理
+        yield invalidatePaymentUrl(params)(repos);
+    });
+}
+exports.voidPayTransaction = voidPayTransaction;
+function invalidatePaymentUrl(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d, _e;
+        const transaction = yield repos.transaction.findById({
+            typeOf: params.purpose.typeOf,
+            id: params.purpose.id
+        });
+        const paymentMethodIdByPaymentUrl = (_a = transaction.object.paymentMethods) === null || _a === void 0 ? void 0 : _a.paymentMethodId;
+        const paymentMethodType = (_b = transaction.object.paymentMethods) === null || _b === void 0 ? void 0 : _b.typeOf;
+        if (typeof paymentMethodIdByPaymentUrl === 'string' && paymentMethodIdByPaymentUrl.length > 0
+            && typeof paymentMethodType === 'string' && paymentMethodType.length > 0) {
+            // chevreで決済URL無効化
+            yield PayTransactionService.invalidatePaymentUrl({
+                project: transaction.project,
+                typeOf: factory.actionType.RefundAction,
+                agent: {
+                    typeOf: transaction.seller.typeOf,
+                    name: (typeof transaction.seller.name === 'string')
+                        ? transaction.seller.name
+                        : String((_c = transaction.seller.name) === null || _c === void 0 ? void 0 : _c.ja),
+                    id: transaction.seller.id
+                    // project: transaction.seller.project
+                },
+                recipient: { typeOf: transaction.agent.typeOf, name: transaction.agent.name },
+                object: [{
+                        typeOf: factory.service.paymentService.PaymentServiceType.CreditCard,
+                        // tslint:disable-next-line:max-line-length
+                        id: (_e = (_d = transaction.object.paymentMethods) === null || _d === void 0 ? void 0 : _d.issuedThrough) === null || _e === void 0 ? void 0 : _e.id,
+                        paymentMethod: {
+                            additionalProperty: [],
+                            name: paymentMethodType,
+                            typeOf: paymentMethodType,
+                            paymentMethodId: paymentMethodIdByPaymentUrl
+                        },
+                        refundFee: 0
+                    }],
+                purpose: { typeOf: transaction.typeOf, id: transaction.id }
+            })(repos);
+        }
+    });
+}
+exports.invalidatePaymentUrl = invalidatePaymentUrl;
+/**
+ * 決済承認中止
+ * apiもしくはタスクから決済承認を取り消す
+ */
+function processVoidPayTransaction(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        const transaction = yield repos.transaction.findById({
+            typeOf: params.purpose.typeOf,
+            id: params.purpose.id
+        });
+        // 承認アクションを取得
+        let authorizeActions;
+        if (typeof params.id === 'string') {
+            const authorizeAction = yield repos.action.findById({ typeOf: factory.actionType.AuthorizeAction, id: params.id });
+            // 取引内のアクションかどうか確認
+            if (authorizeAction.purpose.typeOf !== transaction.typeOf || authorizeAction.purpose.id !== transaction.id) {
+                throw new factory.errors.Argument('Transaction', 'Action not found in the transaction');
+            }
+            authorizeActions = [authorizeAction];
+        }
+        else {
+            const authorizeActionsOnTransaction = yield repos.action.searchByPurpose({
+                typeOf: factory.actionType.AuthorizeAction,
+                purpose: {
+                    typeOf: factory.transactionType.PlaceOrder,
+                    id: transaction.id
+                }
+            });
+            authorizeActions = authorizeActionsOnTransaction.filter((a) => {
+                var _a, _b;
+                return ((_a = a.object) === null || _a === void 0 ? void 0 : _a.typeOf) === factory.action.authorize.paymentMethod.any.ResultType.Payment
+                    && ((_b = a.instrument) === null || _b === void 0 ? void 0 : _b.identifier) === factory.action.authorize.paymentMethod.any.ServiceIdentifier.Chevre;
+            });
+        }
+        const errors = [];
+        for (const action of authorizeActions) {
+            // 直列にゆっくり処理する場合↓
+            // tslint:disable-next-line:no-magic-numbers
+            // await new Promise((resolve) => setTimeout(() => { resolve(); }, 1000));
+            // 失敗するケースがあっても、残りが少なくとも処理されるようにエラーハンドリング
+            try {
+                // 取引が存在すれば中止
+                const transactionNumber = action.object.paymentMethodId;
+                if (typeof transactionNumber === 'string' && transactionNumber.length > 0) {
+                    const payTransactions = yield repos.assetTransaction.search({
+                        limit: 1,
+                        page: 1,
+                        project: { id: { $eq: action.project.id } },
+                        typeOf: factory.assetTransactionType.Pay,
+                        transactionNumber: { $eq: transactionNumber }
+                    });
+                    if (payTransactions.length > 0) {
+                        yield PayTransactionService.cancel({ transactionNumber })(repos);
+                    }
+                }
+                yield repos.action.cancel({ typeOf: action.typeOf, id: action.id });
+            }
+            catch (error) {
+                errors.push(error);
+            }
+        }
+        if (errors.length > 0) {
+            throw errors[0];
+        }
+    });
+}
+exports.processVoidPayTransaction = processVoidPayTransaction;
+/**
+ * 外部決済ロケーションを発行する
+ */
+function publishPaymentUrl(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        const transaction = yield repos.transaction.findInProgressById({ typeOf: params.purpose.typeOf, id: params.purpose.id });
+        const paymentServiceType = params.paymentServiceType;
+        // 取引番号生成
+        const { transactionNumber } = yield repos.transactionNumber.publishByTimestamp({
+            startDate: new Date()
+        });
+        let result;
+        // URL発行
+        const startParams = (0, factory_1.creatPayTransactionStartParams)({
+            object: params.object,
+            paymentServiceType,
+            transaction: transaction,
+            transactionNumber: transactionNumber
+        });
+        // result = await repos.payTransaction.publishPaymentUrl({ ...startParams, iss: params.iss });
+        result = yield PayTransactionService.publishPaymentUrl(startParams)(repos);
+        // 取引に保管
+        const paymentMethodByPaymentUrl = {
+            typeOf: params.object.paymentMethod,
+            paymentMethodId: result.paymentMethodId,
+            paymentUrl: result.paymentUrl,
+            issuedThrough: { id: (typeof startParams.object.id === 'string') ? startParams.object.id : '' }
+        };
+        yield repos.transaction.findByIdAndUpdate({
+            id: transaction.id,
+            update: { 'object.paymentMethods': paymentMethodByPaymentUrl }
+        });
+        return result;
+    });
+}
+exports.publishPaymentUrl = publishPaymentUrl;
+/**
+ * 決済承認
+ */
+function authorize(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        const transaction = yield repos.transaction.findInProgressById({ typeOf: params.purpose.typeOf, id: params.purpose.id });
+        const paymentServiceType = params.paymentServiceType;
+        // 取引番号生成
+        let transactionNumber;
+        // リクエストでpaymentMethodIdを指定された場合、取引に保管されたpaymentMethodIdに一致すればそちらを適用(外部サイト決済対応)
+        if (typeof params.object.paymentMethodId === 'string' && params.object.paymentMethodId.length > 0) {
+            const paymentMethodIdByTransaction = (_a = transaction.object.paymentMethods) === null || _a === void 0 ? void 0 : _a.paymentMethodId;
+            if (params.object.paymentMethodId === paymentMethodIdByTransaction) {
+                transactionNumber = params.object.paymentMethodId;
+            }
+            else {
+                // 取引にないpaymentMethodIdの指定はクライアントエラー
+                throw new factory.errors.Argument('paymentMethodId', 'invalid paymentMethodId for the transaction');
+            }
+        }
+        if (typeof transactionNumber !== 'string') {
+            const publishTransactionNumberResult = yield repos.transactionNumber.publishByTimestamp({ startDate: new Date() });
+            transactionNumber = publishTransactionNumberResult.transactionNumber;
+        }
+        // 承認アクションを開始する
+        const actionAttributes = {
+            project: transaction.project,
+            typeOf: factory.actionType.AuthorizeAction,
+            object: Object.assign(Object.assign({}, params.object), { paymentMethodId: transactionNumber, typeOf: factory.action.authorize.paymentMethod.any.ResultType.Payment }),
+            agent: {
+                typeOf: transaction.agent.typeOf,
+                id: transaction.agent.id
+            },
+            instrument: {
+                typeOf: 'WebAPI',
+                identifier: factory.action.authorize.paymentMethod.any.ServiceIdentifier.Chevre
+            },
+            recipient: {
+                typeOf: transaction.seller.typeOf,
+                id: transaction.seller.id,
+                name: (typeof transaction.seller.name === 'string')
+                    ? transaction.seller.name
+                    : String((_b = transaction.seller.name) === null || _b === void 0 ? void 0 : _b.ja)
+            },
+            purpose: { typeOf: transaction.typeOf, id: transaction.id }
+        };
+        const action = yield repos.action.start(actionAttributes);
+        let payTransaction;
+        try {
+            const { accountId } = yield validateFromLocation({
+                object: params.object,
+                project: { id: transaction.project.id }
+            })({ action: repos.action });
+            const startParams = (0, factory_1.creatPayTransactionStartParams)({
+                accountId,
+                object: params.object,
+                paymentServiceType,
+                transaction: transaction,
+                transactionNumber: transactionNumber
+            });
+            // payTransaction = await repos.payTransaction.start({ ...startParams, iss: params.iss });
+            payTransaction = yield PayTransactionService.start(startParams)(repos);
+        }
+        catch (error) {
+            try {
+                const actionError = Object.assign(Object.assign({}, error), { message: error.message, name: error.name });
+                yield repos.action.giveUp({ typeOf: action.typeOf, id: action.id, error: actionError });
+            }
+            catch (__) {
+                // no op
+            }
+            throw error;
+        }
+        // アクションを完了
+        const result = (0, factory_1.createAuthorizeResult)({ payTransaction, object: params.object });
+        return yield repos.action.complete({ typeOf: action.typeOf, id: action.id, result: result });
+    });
+}
+exports.authorize = authorize;
+function validateFromLocation(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        let accountId = (_a = params.object) === null || _a === void 0 ? void 0 : _a.accountId;
+        const fromLocation = (_b = params.object) === null || _b === void 0 ? void 0 : _b.fromLocation;
+        // トークン化されたペイメントカード情報でリクエストされた場合、実ペイメントカード情報へ変換する
+        if (typeof fromLocation === 'string') {
+            const paymentCardOwnershipInfo = yield (0, code_1.verifyToken)({
+                project: { id: params.project.id },
+                agent: { id: params.project.id, typeOf: factory.organizationType.Project },
+                token: fromLocation
+            })(repos);
+            accountId = paymentCardOwnershipInfo.typeOfGood.identifier;
+        }
+        return { accountId };
+    });
+}