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

package/lib/chevre/service/task/voidPayTransaction.js

@@ -0,0 +1,47 @@
+"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.call = void 0;
+const accountingReport_1 = require("../../repo/accountingReport");
+const action_1 = require("../../repo/action");
+const assetTransaction_1 = require("../../repo/assetTransaction");
+const product_1 = require("../../repo/product");
+const project_1 = require("../../repo/project");
+const seller_1 = require("../../repo/seller");
+const task_1 = require("../../repo/task");
+const transaction_1 = require("../../repo/transaction");
+const AnyPaymentService = require("../payment/any");
+/**
+ * タスク実行関数
+ */
+function call(data) {
+    return (settings) => __awaiter(this, void 0, void 0, function* () {
+        const accountingReportRepo = new accountingReport_1.MongoRepository(settings.connection);
+        const actionRepo = new action_1.MongoRepository(settings.connection);
+        const assetTransactionRepo = new assetTransaction_1.MongoRepository(settings.connection);
+        const productRepo = new product_1.MongoRepository(settings.connection);
+        const projectRepo = new project_1.MongoRepository(settings.connection);
+        const sellerRepo = new seller_1.MongoRepository(settings.connection);
+        const taskRepo = new task_1.MongoRepository(settings.connection);
+        const transactionRepo = new transaction_1.MongoRepository(settings.connection);
+        yield AnyPaymentService.voidPayTransaction(data)({
+            accountingReport: accountingReportRepo,
+            action: actionRepo,
+            assetTransaction: assetTransactionRepo,
+            product: productRepo,
+            project: projectRepo,
+            seller: sellerRepo,
+            task: taskRepo,
+            transaction: transactionRepo
+        });
+    });
+}
+exports.call = call;

package/lib/chevre/service/task/voidPayment.js

@@ -0,0 +1,41 @@
+"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.call = void 0;
+const accountingReport_1 = require("../../repo/accountingReport");
+const action_1 = require("../../repo/action");
+const product_1 = require("../../repo/product");
+const project_1 = require("../../repo/project");
+const seller_1 = require("../../repo/seller");
+const task_1 = require("../../repo/task");
+const PaymentService = require("../payment");
+/**
+ * タスク実行関数
+ */
+function call(data) {
+    return (settings) => __awaiter(this, void 0, void 0, function* () {
+        const accountingReportRepo = new accountingReport_1.MongoRepository(settings.connection);
+        const actionRepo = new action_1.MongoRepository(settings.connection);
+        const productRepo = new product_1.MongoRepository(settings.connection);
+        const projectRepo = new project_1.MongoRepository(settings.connection);
+        const sellerRepo = new seller_1.MongoRepository(settings.connection);
+        const taskRepo = new task_1.MongoRepository(settings.connection);
+        yield PaymentService.voidPayment(data)({
+            accountingReport: accountingReportRepo,
+            action: actionRepo,
+            product: productRepo,
+            project: projectRepo,
+            seller: sellerRepo,
+            task: taskRepo
+        });
+    });
+}
+exports.call = call;

package/lib/chevre/service/task/voidRegisterServiceTransaction.d.ts

@@ -0,0 +1,6 @@
+import { IOperation } from '../task';
+import * as factory from '../../factory';
+/**
+ * タスク実行関数
+ */
+export declare function call(data: factory.task.IData<factory.taskName.VoidRegisterServiceTransaction>): IOperation<void>;

package/lib/chevre/service/task/voidRegisterServiceTransaction.js

@@ -0,0 +1,39 @@
+"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.call = void 0;
+const factory = require("../../factory");
+const action_1 = require("../../repo/action");
+const registerServiceInProgress_1 = require("../../repo/action/registerServiceInProgress");
+const assetTransaction_1 = require("../../repo/assetTransaction");
+const transaction_1 = require("../../repo/transaction");
+const ProductOfferService = require("../offer/product");
+/**
+ * タスク実行関数
+ */
+function call(data) {
+    return (settings) => __awaiter(this, void 0, void 0, function* () {
+        if (settings.redisClient === undefined) {
+            throw new factory.errors.Argument('settings', 'redisClient required');
+        }
+        const actionRepo = new action_1.MongoRepository(settings.connection);
+        const registerActionInProgressRepo = new registerServiceInProgress_1.RedisRepository(settings.redisClient);
+        const assetTransactionRepo = new assetTransaction_1.MongoRepository(settings.connection);
+        const transactionRepo = new transaction_1.MongoRepository(settings.connection);
+        yield ProductOfferService.voidTransaction(data)({
+            action: actionRepo,
+            assetTransaction: assetTransactionRepo,
+            registerActionInProgress: registerActionInProgressRepo,
+            transaction: transactionRepo
+        });
+    });
+}
+exports.call = call;

package/lib/chevre/service/task/voidReserveTransaction.d.ts

@@ -0,0 +1,6 @@
+import { IOperation } from '../task';
+import * as factory from '../../factory';
+/**
+ * タスク実行関数
+ */
+export declare function call(data: factory.task.IData<factory.taskName.VoidReserveTransaction>): IOperation<void>;

package/lib/chevre/service/task/voidReserveTransaction.js

@@ -0,0 +1,45 @@
+"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.call = void 0;
+const factory = require("../../factory");
+const action_1 = require("../../repo/action");
+const assetTransaction_1 = require("../../repo/assetTransaction");
+const screeningEvent_1 = require("../../repo/itemAvailability/screeningEvent");
+const offer_1 = require("../../repo/rateLimit/offer");
+const reservation_1 = require("../../repo/reservation");
+const task_1 = require("../../repo/task");
+const EventOfferService = require("../offer/event");
+/**
+ * タスク実行関数
+ */
+function call(data) {
+    return (settings) => __awaiter(this, void 0, void 0, function* () {
+        if (settings.redisClient === undefined) {
+            throw new factory.errors.Argument('settings', 'redisClient required');
+        }
+        const actionRepo = new action_1.MongoRepository(settings.connection);
+        const assetTransactionRepo = new assetTransaction_1.MongoRepository(settings.connection);
+        const eventAvailabilityRepo = new screeningEvent_1.RedisRepository(settings.redisClient);
+        const offerRateLimitRepo = new offer_1.RedisRepository(settings.redisClient);
+        const reservationRepo = new reservation_1.MongoRepository(settings.connection);
+        const taskRepo = new task_1.MongoRepository(settings.connection);
+        yield EventOfferService.voidTransaction(data)({
+            action: actionRepo,
+            assetTransaction: assetTransactionRepo,
+            eventAvailability: eventAvailabilityRepo,
+            offerRateLimit: offerRateLimitRepo,
+            reservation: reservationRepo,
+            task: taskRepo
+        });
+    });
+}
+exports.call = call;

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

@@ -0,0 +1,47 @@
+import * as mongoose from 'mongoose';
+import * as redis from 'redis';
+import * as factory from '../factory';
+import { MongoRepository as TaskRepo } from '../repo/task';
+export interface IConnectionSettings {
+    /**
+     * MongoDBコネクション
+     */
+    connection: mongoose.Connection;
+    /**
+     * Redisクライアント
+     */
+    redisClient?: redis.RedisClient;
+}
+export declare type TaskOperation<T> = (repos: {
+    task: TaskRepo;
+}) => Promise<T>;
+export declare type IOperation<T> = (settings: IConnectionSettings) => Promise<T>;
+/**
+ * タスク名でタスクをひとつ実行する
+ */
+export declare function executeByName<T extends factory.taskName>(params: {
+    name: T;
+}): IOperation<void>;
+/**
+ * タスクを実行する
+ */
+export declare function execute(task: factory.task.ITask<factory.taskName>): IOperation<void>;
+/**
+ * 実行中ステータスのままになっているタスクをリトライする
+ */
+export declare function retry(params: {
+    intervalInMinutes: number;
+}): TaskOperation<void>;
+/**
+ * トライ可能回数が0に達したタスクを実行中止する
+ */
+export declare function abort(params: {
+    /**
+     * 最終トライ日時から何分経過したタスクを中止するか
+     */
+    intervalInMinutes: number;
+    notify: boolean;
+}): TaskOperation<void>;
+export declare function notifyAbortedTasks(params: {
+    dateAbortedGte: Date;
+}): TaskOperation<void>;

package/lib/chevre/service/task.js

@@ -0,0 +1,133 @@
+"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.notifyAbortedTasks = exports.abort = exports.retry = exports.execute = exports.executeByName = void 0;
+/**
+ * タスクサービス
+ */
+const createDebug = require("debug");
+const factory = require("../factory");
+const task_1 = require("../repo/task");
+const NotificationService = require("./notification");
+const factory_1 = require("./notification/factory");
+const settings_1 = require("../settings");
+const debug = createDebug('chevre-domain:service:task');
+/**
+ * タスク名でタスクをひとつ実行する
+ */
+function executeByName(params) {
+    return (settings) => __awaiter(this, void 0, void 0, function* () {
+        const taskRepo = new task_1.MongoRepository(settings.connection);
+        // 未実行のタスクを取得
+        // tslint:disable-next-line:no-null-keyword
+        let task = null;
+        try {
+            task = yield taskRepo.executeOneByName(params);
+        }
+        catch (error) {
+            // tslint:disable-next-line:no-single-line-block-comment
+            /* istanbul ignore next */
+            debug('executeByName error:', error);
+        }
+        // タスクがなければ終了
+        if (task !== null) {
+            yield execute(task)(settings);
+        }
+    });
+}
+exports.executeByName = executeByName;
+/**
+ * タスクを実行する
+ */
+function execute(task) {
+    const now = new Date();
+    return (settings) => __awaiter(this, void 0, void 0, function* () {
+        const taskRepo = new task_1.MongoRepository(settings.connection);
+        try {
+            // タスク名の関数が定義されていなければ、TypeErrorとなる
+            const { call } = yield Promise.resolve().then(() => require(`./task/${task.name}`));
+            yield call(task.data)(settings);
+            const result = {
+                executedAt: now,
+                endDate: new Date(),
+                error: ''
+            };
+            yield taskRepo.pushExecutionResultById(task.id, factory.taskStatus.Executed, result);
+        }
+        catch (error) {
+            debug('service.task.execute throwed an error. task:', task.name, task.id, 'error:', error === null || error === void 0 ? void 0 : error.name, error === null || error === void 0 ? void 0 : error.message);
+            if (typeof error !== 'object') {
+                error = { message: String(error) };
+            }
+            // 実行結果追加
+            const result = {
+                executedAt: now,
+                endDate: new Date(),
+                error: Object.assign(Object.assign({}, error), { code: error.code, message: error.message, name: error.name, stack: error.stack })
+            };
+            // 失敗してもここではステータスを戻さない(Runningのまま待機)
+            yield taskRepo.pushExecutionResultById(task.id, task.status, result);
+        }
+    });
+}
+exports.execute = execute;
+/**
+ * 実行中ステータスのままになっているタスクをリトライする
+ */
+function retry(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        yield repos.task.retry(params);
+    });
+}
+exports.retry = retry;
+/**
+ * トライ可能回数が0に達したタスクを実行中止する
+ */
+function abort(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        const abortedTask = yield repos.task.abortOne(params);
+        // tslint:disable-next-line:no-single-line-block-comment
+        /* istanbul ignore if */
+        if (abortedTask === null) {
+            return;
+        }
+        if (params.notify === true) {
+            // 中止を報告しないタスクであれば終了
+            if (settings_1.ABORTED_TASKS_WITHOUT_REPORT.includes(abortedTask.name)) {
+                return;
+            }
+            // 開発者へ報告
+            const message = (0, factory_1.task2lineNotify)({ task: abortedTask });
+            yield NotificationService.report2developers(message.subject, message.content)();
+        }
+    });
+}
+exports.abort = abort;
+function notifyAbortedTasks(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        let abortedTasks = yield repos.task.search({
+            statuses: [factory.taskStatus.Aborted],
+            dateAborted: {
+                $gte: params.dateAbortedGte
+            }
+        });
+        // 中止を報告しないタスク以外にフィルター
+        abortedTasks = abortedTasks.filter((task) => {
+            return !settings_1.ABORTED_TASKS_WITHOUT_REPORT.includes(task.name);
+        });
+        if (abortedTasks.length > 0) {
+            // 開発者へ報告
+            const message = (0, factory_1.tasks2lineNotify)({ tasks: abortedTasks });
+            yield NotificationService.report2developers(message.subject, message.content)();
+        }
+    });
+}
+exports.notifyAbortedTasks = notifyAbortedTasks;

package/lib/chevre/service/transaction/moneyTransfer/exportTasks/factory.d.ts

@@ -0,0 +1,8 @@
+import * as factory from '../../../../factory';
+/**
+ * 取引のタスクを作成する
+ */
+export declare function createTasks(params: {
+    transaction: factory.transaction.ITransaction<factory.transactionType.MoneyTransfer>;
+    runsAt: Date;
+}): factory.task.IAttributes<factory.taskName>[];

package/lib/chevre/service/transaction/moneyTransfer/exportTasks/factory.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTasks = void 0;
+const moment = require("moment");
+const factory = require("../../../../factory");
+const settings_1 = require("../../../../settings");
+/**
+ * 取引のタスクを作成する
+ */
+function createTasks(params) {
+    const taskAttributes = [];
+    const transaction = params.transaction;
+    const taskRunsAt = params.runsAt;
+    // 取引削除タスクを作成(取引ステータスによってrunsAtを調整)
+    let deleteAt = moment(transaction.endDate)
+        .add(settings_1.TRANSACTION_CONFIRMED_STORAGE_PERIOD_IN_DAYS, 'days')
+        .toDate();
+    switch (transaction.status) {
+        case factory.transactionStatusType.Confirmed:
+            break;
+        case factory.transactionStatusType.Canceled:
+        case factory.transactionStatusType.Expired:
+            deleteAt = moment(transaction.endDate)
+                .add(settings_1.TRANSACTION_CANCELED_STORAGE_PERIOD_IN_DAYS, 'days')
+                .toDate();
+            break;
+        default:
+    }
+    const deleteTransactionTask = {
+        project: transaction.project,
+        name: factory.taskName.DeleteTransaction,
+        status: factory.taskStatus.Ready,
+        runsAt: deleteAt,
+        remainingNumberOfTries: 3,
+        numberOfTried: 0,
+        executionResults: [],
+        data: {
+            object: transaction
+        }
+    };
+    taskAttributes.push(deleteTransactionTask);
+    switch (transaction.status) {
+        case factory.transactionStatusType.Confirmed:
+            // tslint:disable-next-line:no-single-line-block-comment
+            /* istanbul ignore else */
+            if (transaction.potentialActions !== undefined) {
+                // tslint:disable-next-line:no-single-line-block-comment
+                /* istanbul ignore else */
+                if (transaction.potentialActions.moneyTransfer !== undefined) {
+                    taskAttributes.push(...transaction.potentialActions.moneyTransfer.map((a) => {
+                        return {
+                            project: transaction.project,
+                            name: factory.taskName.ConfirmMoneyTransfer,
+                            status: factory.taskStatus.Ready,
+                            runsAt: taskRunsAt,
+                            remainingNumberOfTries: 10,
+                            numberOfTried: 0,
+                            executionResults: [],
+                            data: a
+                        };
+                    }));
+                }
+            }
+            break;
+        case factory.transactionStatusType.Canceled:
+        case factory.transactionStatusType.Expired:
+            const voidMoneyTransferTaskAttributes = {
+                project: { typeOf: transaction.project.typeOf, id: transaction.project.id },
+                name: factory.taskName.VoidMoneyTransferTransaction,
+                status: factory.taskStatus.Ready,
+                runsAt: taskRunsAt,
+                remainingNumberOfTries: 10,
+                numberOfTried: 0,
+                executionResults: [],
+                data: {
+                    project: { typeOf: transaction.project.typeOf, id: transaction.project.id },
+                    purpose: { typeOf: transaction.typeOf, id: transaction.id }
+                }
+            };
+            taskAttributes.push(voidMoneyTransferTaskAttributes);
+            break;
+        default:
+            throw new factory.errors.NotImplemented(`Transaction status "${transaction.status}" not implemented.`);
+    }
+    return taskAttributes;
+}
+exports.createTasks = createTasks;

package/lib/chevre/service/transaction/moneyTransfer/factory.d.ts

@@ -0,0 +1,2 @@
+import * as factory from '../../../factory';
+export declare function createStartParams(params: factory.transaction.moneyTransfer.IStartParamsWithoutDetail, passport: factory.waiter.passport.IPassport | undefined, seller: factory.seller.ISeller, amount: factory.monetaryAmount.IMonetaryAmount, fromLocation: factory.assetTransaction.moneyTransfer.IFromLocationBeforeStart, toLocation: factory.transaction.moneyTransfer.IToLocation, transactionNumber: string): factory.transaction.IStartParams<factory.transactionType.MoneyTransfer>;

package/lib/chevre/service/transaction/moneyTransfer/factory.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStartParams = void 0;
+const factory = require("../../../factory");
+function createStartParams(params, passport, seller, amount, fromLocation, toLocation, transactionNumber) {
+    var _a;
+    // 取引ファクトリーで新しい進行中取引オブジェクトを作成
+    return {
+        project: params.project,
+        typeOf: factory.transactionType.MoneyTransfer,
+        agent: params.agent,
+        recipient: params.recipient,
+        seller: {
+            id: String(seller.id),
+            name: seller.name,
+            typeOf: seller.typeOf
+            // ↓最適化(2022-05-24~)
+            // ...{ project: seller.project }
+        },
+        object: Object.assign(Object.assign({ amount: amount, fromLocation: fromLocation, toLocation: toLocation, authorizeActions: [], pendingTransaction: Object.assign({ transactionNumber }, (typeof ((_a = params.object.pendingTransaction) === null || _a === void 0 ? void 0 : _a.identifier) === 'string')
+                ? { identifier: params.object.pendingTransaction.identifier }
+                : undefined) }, (passport !== undefined) ? { passport } : undefined), (typeof params.object.description === 'string') ? { description: params.object.description } : undefined),
+        expires: params.expires
+    };
+}
+exports.createStartParams = createStartParams;

package/lib/chevre/service/transaction/moneyTransfer/potentialActions.d.ts

@@ -0,0 +1,8 @@
+import * as factory from '../../../factory';
+export declare type IAuthorizeMoneyTransferOffer = factory.action.authorize.offer.moneyTransfer.IAction;
+/**
+ * 取引のポストアクションを作成する
+ */
+export declare function createPotentialActions(params: {
+    transaction: factory.transaction.ITransaction<factory.transactionType.MoneyTransfer>;
+}): Promise<factory.transaction.IPotentialActions<factory.transactionType.MoneyTransfer>>;

package/lib/chevre/service/transaction/moneyTransfer/potentialActions.js

@@ -0,0 +1,72 @@
+"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.createPotentialActions = void 0;
+const factory = require("../../../factory");
+function createMoneyTransferActions(params) {
+    const moneyTransferActions = [];
+    const authorizeMoneyTransferActions = params.transaction.object.authorizeActions
+        .filter((a) => a.actionStatus === factory.actionStatusType.CompletedActionStatus)
+        .filter((a) => a.object.typeOf === factory.offerType.Offer)
+        .filter((a) => { var _a; return ((_a = a.object.itemOffered) === null || _a === void 0 ? void 0 : _a.typeOf) === factory.actionType.MoneyTransfer; });
+    authorizeMoneyTransferActions.forEach((a) => {
+        var _a;
+        const actionResult = a.result;
+        const pendingTransaction = (_a = a.object.itemOffered.object) === null || _a === void 0 ? void 0 : _a.pendingTransaction;
+        // const fromLocation = params.transaction.object.fromLocation;
+        if (actionResult !== undefined && pendingTransaction !== undefined) {
+            moneyTransferActions.push({
+                project: params.transaction.project,
+                typeOf: factory.actionType.ConfirmAction,
+                object: {
+                    pendingTransaction: { id: actionResult.responseBody.id },
+                    transactionNumber: pendingTransaction.transactionNumber,
+                    typeOf: factory.assetTransactionType.MoneyTransfer
+                },
+                // agent: Projectに統一(2022-05-16~)
+                agent: params.transaction.project,
+                // agent: params.transaction.agent,
+                // ↓recipient廃止(2022-05-16~)
+                // recipient: a.recipient,
+                // amount: {
+                //     typeOf: 'MonetaryAmount',
+                //     value: a.object.itemOffered.amount.value,
+                //     currency: a.object.itemOffered.amount.currency
+                // },
+                // fromLocation: fromLocation,
+                // toLocation: params.transaction.object.toLocation,
+                purpose: {
+                    typeOf: params.transaction.typeOf,
+                    id: params.transaction.id
+                }
+                // ...(typeof a.object.description === 'string') ? { description: a.object.description } : {}
+            });
+        }
+    });
+    return moneyTransferActions;
+}
+/**
+ * 取引のポストアクションを作成する
+ */
+function createPotentialActions(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // 通貨転送アクション属性作成
+        const moneyTransferActionAttributesList = createMoneyTransferActions(params);
+        // まずは1転送アクションのみ対応
+        if (moneyTransferActionAttributesList.length !== 1) {
+            throw new factory.errors.Argument('Transaction', 'Number of moneyTransfer actions must be 1');
+        }
+        return {
+            moneyTransfer: moneyTransferActionAttributesList
+        };
+    });
+}
+exports.createPotentialActions = createPotentialActions;

package/lib/chevre/service/transaction/moneyTransfer.d.ts

@@ -0,0 +1,63 @@
+import * as factory from '../../factory';
+import { MongoRepository as ActionRepo } from '../../repo/action';
+import { MongoRepository as AssetTransactionRepo } from '../../repo/assetTransaction';
+import { MongoRepository as OrderRepo } from '../../repo/order';
+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 { IPassportValidator as IWaiterPassportValidator } from './validation';
+export interface IStartOperationRepos {
+    action: ActionRepo;
+    order: OrderRepo;
+    product: ProductRepo;
+    project: ProjectRepo;
+    seller: SellerRepo;
+    transaction: TransactionRepo;
+    transactionNumber: TransactionNumberRepo;
+    assetTransaction: AssetTransactionRepo;
+}
+export declare type IStartOperation<T> = (repos: IStartOperationRepos) => Promise<T>;
+export declare type ITaskAndTransactionOperation<T> = (repos: {
+    task: TaskRepo;
+    transaction: TransactionRepo;
+}) => Promise<T>;
+export declare type IConfirmOperation<T> = (repos: {
+    action: ActionRepo;
+    transaction: TransactionRepo;
+}) => Promise<T>;
+export declare type IPassportValidator = IWaiterPassportValidator;
+export declare type IStartParams = factory.transaction.moneyTransfer.IStartParamsWithoutDetail & {
+    passportValidator?: IPassportValidator;
+};
+/**
+ * 取引開始
+ * 通貨転送資産取引サービスを利用して転送取引を開始する
+ */
+export declare function start(params: IStartParams): IStartOperation<factory.transaction.moneyTransfer.ITransaction>;
+export declare type IAuthorizeOperation<T> = (repos: {
+    action: ActionRepo;
+    order: OrderRepo;
+    product: ProductRepo;
+    project: ProjectRepo;
+    transaction: TransactionRepo;
+    assetTransaction: AssetTransactionRepo;
+}) => Promise<T>;
+/**
+ * 取引確定
+ */
+export declare function confirm(params: {
+    id: string;
+}): IConfirmOperation<void>;
+/**
+ * 取引のタスク出力
+ */
+export declare function exportTasksById(params: {
+    id: string;
+    /**
+     * タスク実行日時バッファ
+     */
+    runsTasksAfterInSeconds?: number;
+}): ITaskAndTransactionOperation<void>;