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

package/lib/chevre/service/account.js

@@ -0,0 +1,147 @@
+"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.cancelMoneyTransfer = exports.transferMoney = exports.close = exports.open = void 0;
+/**
+ * 口座サービス
+ * 開設、閉鎖等、口座アクション実行など
+ */
+const factory = require("../factory");
+/**
+ * 口座を開設する
+ */
+function open(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        const openDate = new Date();
+        return repos.account.open(params.map((p) => {
+            return {
+                project: { typeOf: factory.organizationType.Project, id: p.project.id },
+                typeOf: p.typeOf,
+                name: p.name,
+                accountType: p.accountType,
+                accountNumber: p.accountNumber,
+                initialBalance: p.initialBalance,
+                openDate: openDate
+            };
+        }));
+    });
+}
+exports.open = open;
+/**
+ * 口座を解約する
+ */
+function close(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        yield repos.account.close({
+            accountNumber: params.accountNumber,
+            closeDate: new Date()
+        });
+    });
+}
+exports.close = close;
+/**
+ * 転送する
+ * 確定取引結果から、実際の転送アクションを実行します。
+ */
+function transferMoney(actionAttributes) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        let action = yield repos.accountAction.startByIdentifier(actionAttributes);
+        // すでに完了していれば何もしない
+        if (action.actionStatus === factory.actionStatusType.CompletedActionStatus) {
+            return;
+        }
+        let fromAccountNumber;
+        let toAccountNumber;
+        try {
+            fromAccountNumber = (typeof action.fromLocation.accountNumber === 'string')
+                ? action.fromLocation.accountNumber
+                // tslint:disable-next-line:no-single-line-block-comment
+                /* istanbul ignore next */
+                : undefined;
+            toAccountNumber = (typeof action.toLocation.accountNumber === 'string')
+                ? action.toLocation.accountNumber
+                // tslint:disable-next-line:no-single-line-block-comment
+                /* istanbul ignore next */
+                : undefined;
+            yield repos.account.settleTransaction({
+                fromAccountNumber: fromAccountNumber,
+                toAccountNumber: toAccountNumber,
+                amount: (typeof action.amount === 'number') ? action.amount : Number(action.amount.value),
+                transactionId: action.purpose.id
+            });
+        }
+        catch (error) {
+            // actionにエラー結果を追加
+            try {
+                const actionError = Object.assign(Object.assign({}, error), { message: error.message, name: error.name });
+                yield repos.accountAction.giveUp(action.typeOf, action.id, actionError);
+            }
+            catch (__) {
+                // 失敗したら仕方ない
+            }
+            throw error;
+        }
+        // アクション完了
+        const actionResult = {};
+        action = yield repos.accountAction.complete(action.typeOf, action.id, actionResult);
+    });
+}
+exports.transferMoney = transferMoney;
+/**
+ * 転送取消
+ * 期限切れ、あるいは、中止された取引から、転送をアクションを取り消します。
+ */
+function cancelMoneyTransfer(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        let fromAccountNumber;
+        let toAccountNumber;
+        // 取引存在確認
+        const transaction = yield repos.accountTransaction.findById({ typeOf: params.transaction.typeOf, id: params.transaction.id });
+        switch (params.transaction.typeOf) {
+            case factory.account.transactionType.Deposit:
+                toAccountNumber =
+                    transaction.object.toLocation.accountNumber;
+                break;
+            case factory.account.transactionType.Withdraw:
+                fromAccountNumber =
+                    transaction.object.fromLocation.accountNumber;
+                break;
+            case factory.account.transactionType.Transfer:
+                fromAccountNumber =
+                    transaction.object.fromLocation.accountNumber;
+                toAccountNumber =
+                    // tslint:disable-next-line:max-line-length
+                    transaction.object.toLocation.accountNumber;
+                break;
+            default:
+                throw new factory.errors.Argument('typeOf', `transaction type ${params.transaction.typeOf} unknown`);
+        }
+        yield repos.account.voidTransaction({
+            fromAccountNumber: fromAccountNumber,
+            toAccountNumber: toAccountNumber,
+            amount: (typeof transaction.object.amount === 'number')
+                ? transaction.object.amount
+                : transaction.object.amount.value,
+            transactionId: transaction.id
+        });
+        // アクション取得
+        const actions = yield repos.accountAction.searchTransferActions({
+            purpose: {
+                typeOf: { $eq: transaction.typeOf },
+                id: { $eq: transaction.id }
+            }
+        });
+        yield Promise.all(actions.map((action) => __awaiter(this, void 0, void 0, function* () {
+            yield repos.accountAction.cancel(action.typeOf, action.id);
+        })));
+    });
+}
+exports.cancelMoneyTransfer = cancelMoneyTransfer;

package/lib/chevre/service/accountTransaction/deposit.js

@@ -0,0 +1,74 @@
+"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.start = void 0;
+/**
+ * 入金取引サービス
+ */
+const factory = require("../../factory");
+const factory_1 = require("./factory");
+/**
+ * 取引開始
+ */
+function start(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        // 口座存在確認
+        const account = yield repos.account.findByAccountNumber({
+            accountNumber: params.object.toLocation.accountNumber
+        });
+        // 取引ファクトリーで新しい進行中取引オブジェクトを作成
+        const startParams = Object.assign({ project: { typeOf: params.project.typeOf, id: params.project.id }, typeOf: factory.account.transactionType.Deposit, agent: params.agent, recipient: params.recipient, object: {
+                // clientUser: params.object.clientUser,
+                amount: params.object.amount,
+                toLocation: {
+                    typeOf: account.typeOf,
+                    accountType: account.accountType,
+                    accountNumber: account.accountNumber,
+                    name: account.name
+                },
+                description: params.object.description
+            }, expires: params.expires, 
+            // 必須化(2022-09-26~)
+            transactionNumber: params.transactionNumber }, (typeof params.identifier === 'string' && params.identifier.length > 0) ? { identifier: params.identifier } : undefined);
+        // 取引作成
+        let transaction;
+        try {
+            // 取引識別子が指定されていれば、進行中取引のユニークネスを保証する
+            transaction = yield repos.accountTransaction.startByIdentifier(startParams);
+        }
+        catch (error) {
+            // tslint:disable-next-line:no-single-line-block-comment
+            /* istanbul ignore next */
+            if (error.name === 'MongoError') {
+                // no op
+            }
+            throw error;
+        }
+        const pendingTransaction = {
+            typeOf: transaction.typeOf,
+            id: transaction.id,
+            amount: (typeof params.object.amount === 'number')
+                ? params.object.amount
+                : params.object.amount.value
+        };
+        // 入金先口座に進行中取引を追加
+        yield repos.account.startTransaction({
+            accountNumber: params.object.toLocation.accountNumber,
+            transaction: pendingTransaction
+        });
+        // アクション開始
+        const moneyTransferActionAttributes = (0, factory_1.createMoneyTransferActionAttributes)({ transaction });
+        yield repos.accountAction.startByIdentifier(moneyTransferActionAttributes);
+        // 結果返却
+        return transaction;
+    });
+}
+exports.start = start;

package/lib/chevre/service/accountTransaction/factory.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMoneyTransferActionAttributes = void 0;
+/**
+ * 取引ファクトリー
+ */
+const factory = require("../../factory");
+/**
+ * 転送アクション属性作成
+ */
+// tslint:disable-next-line:max-func-body-length
+function createMoneyTransferActionAttributes(params) {
+    var _a, _b;
+    const transaction = params.transaction;
+    let fromLocation = {
+        typeOf: transaction.agent.typeOf,
+        name: transaction.agent.name
+    };
+    let toLocation = {
+        typeOf: transaction.recipient.typeOf,
+        name: transaction.recipient.name
+    };
+    switch (transaction.typeOf) {
+        case factory.account.transactionType.Deposit:
+            if (typeof ((_a = transaction.object.fromLocation) === null || _a === void 0 ? void 0 : _a.typeOf) === 'string') {
+                fromLocation = Object.assign({ typeOf: transaction.object.fromLocation.typeOf, name: transaction.agent.name }, (typeof transaction.object.fromLocation.id === 'string')
+                    ? { id: transaction.object.fromLocation.id }
+                    : undefined);
+            }
+            toLocation = {
+                typeOf: transaction.object.toLocation.typeOf,
+                accountType: transaction.object.toLocation.accountType,
+                accountNumber: transaction.object.toLocation.accountNumber,
+                name: transaction.recipient.name
+            };
+            break;
+        case factory.account.transactionType.Transfer:
+            fromLocation = {
+                typeOf: transaction.object.fromLocation.typeOf,
+                accountType: transaction.object.fromLocation.accountType,
+                accountNumber: transaction.object.fromLocation.accountNumber,
+                name: transaction.agent.name
+            };
+            toLocation = {
+                typeOf: transaction.object.toLocation.typeOf,
+                accountType: transaction.object.toLocation.accountType,
+                accountNumber: transaction.object.toLocation.accountNumber,
+                name: transaction.recipient.name
+            };
+            break;
+        case factory.account.transactionType.Withdraw:
+            fromLocation = {
+                typeOf: transaction.object.fromLocation.typeOf,
+                accountType: transaction.object.fromLocation.accountType,
+                accountNumber: transaction.object.fromLocation.accountNumber,
+                name: transaction.agent.name
+            };
+            if (typeof ((_b = transaction.object.toLocation) === null || _b === void 0 ? void 0 : _b.typeOf) === 'string') {
+                toLocation = Object.assign({ typeOf: transaction.object.toLocation.typeOf, name: transaction.recipient.name }, (typeof transaction.object.toLocation.id === 'string')
+                    ? { id: transaction.object.toLocation.id }
+                    : undefined);
+            }
+            break;
+        default:
+    }
+    let accountType;
+    const transactionType = params.transaction.typeOf;
+    switch (transactionType) {
+        case factory.account.transactionType.Deposit:
+            accountType = params.transaction.object.toLocation.accountType;
+            break;
+        case factory.account.transactionType.Transfer:
+            accountType = params.transaction.object.fromLocation.accountType;
+            break;
+        case factory.account.transactionType.Withdraw:
+            accountType = params.transaction.object.fromLocation.accountType;
+            break;
+        default:
+            throw new factory.errors.NotImplemented(`transaction type ${transactionType} not implemented`);
+    }
+    return {
+        project: transaction.project,
+        typeOf: factory.actionType.MoneyTransfer,
+        identifier: `${factory.actionType.MoneyTransfer}-${transaction.typeOf}-${transaction.id}`,
+        description: transaction.object.description,
+        // result: {
+        //     amount: transaction.object.amount
+        // },
+        object: {},
+        agent: transaction.agent,
+        recipient: transaction.recipient,
+        amount: {
+            typeOf: 'MonetaryAmount',
+            currency: accountType,
+            value: (typeof transaction.object.amount === 'number')
+                ? transaction.object.amount
+                : transaction.object.amount.value
+        },
+        fromLocation: fromLocation,
+        toLocation: toLocation,
+        purpose: Object.assign({ typeOf: transaction.typeOf, id: transaction.id, transactionNumber: transaction.transactionNumber }, (typeof transaction.identifier === 'string')
+            ? { identifier: transaction.identifier }
+            : /* istanbul ignore next */ undefined)
+    };
+}
+exports.createMoneyTransferActionAttributes = createMoneyTransferActionAttributes;

package/lib/chevre/service/accountTransaction/transfer.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 転送取引サービス
+ */
+import * as factory from '../../factory';
+import { MongoRepository as AccountRepo } from '../../repo/account';
+import { MongoRepository as AccountActionRepo } from '../../repo/accountAction';
+import { MongoRepository as AccountTransactionRepo } from '../../repo/accountTransaction';
+export declare type IStartOperation<T> = (repos: {
+    account: AccountRepo;
+    accountAction: AccountActionRepo;
+    accountTransaction: AccountTransactionRepo;
+}) => Promise<T>;
+/**
+ * 取引開始
+ */
+export declare function start(params: factory.account.transaction.transfer.IStartParamsWithoutDetail): IStartOperation<factory.account.transaction.transfer.ITransaction>;

package/lib/chevre/service/accountTransaction/transfer.js

@@ -0,0 +1,106 @@
+"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.start = void 0;
+/**
+ * 転送取引サービス
+ */
+const factory = require("../../factory");
+const factory_1 = require("./factory");
+/**
+ * 取引開始
+ */
+function start(params) {
+    // tslint:disable-next-line:max-func-body-length
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        // 口座存在確認
+        const fromAccount = yield repos.account.findByAccountNumber({
+            accountNumber: params.object.fromLocation.accountNumber
+        });
+        const toAccount = yield repos.account.findByAccountNumber({
+            accountNumber: params.object.toLocation.accountNumber
+        });
+        // tslint:disable-next-line:no-single-line-block-comment
+        /* istanbul ignore if */
+        if (fromAccount.accountType !== toAccount.accountType) {
+            throw new factory.errors.Argument('accountType', 'FromLocation accountType must be the same as ToLocation');
+        }
+        // tslint:disable-next-line:no-single-line-block-comment
+        /* istanbul ignore if */
+        if (fromAccount.accountNumber === toAccount.accountNumber) {
+            throw new factory.errors.Argument('accountNumber', 'FromLocation accountNumber must be different from ToLocation');
+        }
+        // 残高検証(2022-10-28~)
+        if (fromAccount.availableBalance < params.object.amount.value) {
+            throw new factory.errors.Argument('fromLocation', 'Insufficient balance');
+        }
+        // 取引ファクトリーで新しい進行中取引オブジェクトを作成
+        const startParams = Object.assign({ project: { typeOf: params.project.typeOf, id: params.project.id }, typeOf: factory.account.transactionType.Transfer, agent: params.agent, recipient: params.recipient, object: {
+                // clientUser: params.object.clientUser,
+                amount: params.object.amount,
+                fromLocation: {
+                    typeOf: fromAccount.typeOf,
+                    accountType: fromAccount.accountType,
+                    accountNumber: fromAccount.accountNumber,
+                    name: fromAccount.name
+                },
+                toLocation: {
+                    typeOf: toAccount.typeOf,
+                    accountType: toAccount.accountType,
+                    accountNumber: toAccount.accountNumber,
+                    name: toAccount.name
+                },
+                description: params.object.description
+            }, expires: params.expires, 
+            // 必須化(2022-09-26~)
+            transactionNumber: params.transactionNumber }, (typeof params.identifier === 'string' && params.identifier.length > 0) ? { identifier: params.identifier } : undefined);
+        // 取引作成
+        let transaction;
+        try {
+            // 取引識別子が指定されていれば、進行中取引のユニークネスを保証する
+            transaction = yield repos.accountTransaction.startByIdentifier(startParams);
+        }
+        catch (error) {
+            // tslint:disable-next-line:no-single-line-block-comment
+            /* istanbul ignore next */
+            if (error.name === 'MongoError') {
+                // no op
+            }
+            throw error;
+        }
+        const pendingTransaction = {
+            typeOf: transaction.typeOf,
+            id: transaction.id,
+            amount: (typeof params.object.amount === 'number')
+                ? params.object.amount
+                : params.object.amount.value
+        };
+        // 残高確認
+        yield repos.account.authorizeAmount({
+            accountNumber: params.object.fromLocation.accountNumber,
+            amount: (typeof params.object.amount === 'number')
+                ? params.object.amount
+                : params.object.amount.value,
+            transaction: pendingTransaction
+        });
+        // 転送先口座に進行中取引を追加
+        yield repos.account.startTransaction({
+            accountNumber: params.object.toLocation.accountNumber,
+            transaction: pendingTransaction
+        });
+        // アクション開始
+        const moneyTransferActionAttributes = (0, factory_1.createMoneyTransferActionAttributes)({ transaction });
+        yield repos.accountAction.startByIdentifier(moneyTransferActionAttributes);
+        // 結果返却
+        return transaction;
+    });
+}
+exports.start = start;

package/lib/chevre/service/accountTransaction/withdraw.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 出金取引サービス
+ */
+import * as factory from '../../factory';
+import { MongoRepository as AccountRepo } from '../../repo/account';
+import { MongoRepository as AccountActionRepo } from '../../repo/accountAction';
+import { MongoRepository as AccountTransactionRepo } from '../../repo/accountTransaction';
+export declare type IStartOperation<T> = (repos: {
+    account: AccountRepo;
+    accountAction: AccountActionRepo;
+    accountTransaction: AccountTransactionRepo;
+}) => Promise<T>;
+/**
+ * 取引開始
+ */
+export declare function start(params: factory.account.transaction.withdraw.IStartParamsWithoutDetail): IStartOperation<factory.account.transaction.withdraw.ITransaction>;

package/lib/chevre/service/accountTransaction/withdraw.js

@@ -0,0 +1,85 @@
+"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.start = void 0;
+/**
+ * 出金取引サービス
+ */
+const factory = require("../../factory");
+const factory_1 = require("./factory");
+/**
+ * 取引開始
+ */
+function start(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        // 口座存在確認
+        const fromAccount = yield repos.account.findByAccountNumber({
+            accountNumber: params.object.fromLocation.accountNumber
+        });
+        const forcibly = (params.object.force === true);
+        if (!forcibly) {
+            // 残高検証(2022-10-28~)
+            if (fromAccount.availableBalance < params.object.amount.value) {
+                throw new factory.errors.Argument('fromLocation', 'Insufficient balance');
+            }
+        }
+        // 取引ファクトリーで新しい進行中取引オブジェクトを作成
+        const startParams = Object.assign({ project: { typeOf: params.project.typeOf, id: params.project.id }, typeOf: factory.account.transactionType.Withdraw, agent: params.agent, recipient: params.recipient, object: {
+                // clientUser: params.object.clientUser,
+                amount: params.object.amount,
+                fromLocation: {
+                    typeOf: fromAccount.typeOf,
+                    accountType: fromAccount.accountType,
+                    accountNumber: fromAccount.accountNumber,
+                    name: fromAccount.name
+                },
+                description: params.object.description
+            }, expires: params.expires, 
+            // 必須化(2022-09-26~)
+            transactionNumber: params.transactionNumber }, (typeof params.identifier === 'string' && params.identifier.length > 0) ? { identifier: params.identifier } : undefined);
+        // 取引作成
+        let transaction;
+        try {
+            // 取引識別子が指定されていれば、進行中取引のユニークネスを保証する
+            transaction = yield repos.accountTransaction.startByIdentifier(startParams);
+        }
+        catch (error) {
+            // tslint:disable-next-line:no-single-line-block-comment
+            /* istanbul ignore next */
+            if (error.name === 'MongoError') {
+                // no op
+            }
+            throw error;
+        }
+        const pendingTransaction = {
+            typeOf: transaction.typeOf,
+            id: transaction.id,
+            amount: (typeof params.object.amount === 'number')
+                ? params.object.amount
+                : params.object.amount.value
+        };
+        // 残高確保
+        yield repos.account.authorizeAmount({
+            accountNumber: params.object.fromLocation.accountNumber,
+            amount: (typeof params.object.amount === 'number')
+                ? params.object.amount
+                : params.object.amount.value,
+            transaction: pendingTransaction,
+            force: forcibly
+        });
+        // アクション開始
+        const moneyTransferActionAttributes = (0, factory_1.createMoneyTransferActionAttributes)({ transaction });
+        yield repos.accountAction.startByIdentifier(moneyTransferActionAttributes);
+        // 結果返却
+        return transaction;
+    });
+}
+exports.start = start;

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

@@ -0,0 +1,20 @@
+/**
+ * 口座取引サービス
+ */
+import { MongoRepository as AccountTransactionRepo } from '../repo/accountTransaction';
+import * as factory from '../factory';
+import * as DepositTransactionService from './accountTransaction/deposit';
+import * as TransferTransactionService from './accountTransaction/transfer';
+import * as WithdrawTransactionService from './accountTransaction/withdraw';
+declare type IConfirmOperation<T> = (repos: {
+    accountTransaction: AccountTransactionRepo;
+}) => Promise<T>;
+/**
+ * 取引確定
+ */
+declare function confirm(params: {
+    id?: string;
+    transactionNumber?: string;
+    typeOf?: factory.account.transactionType;
+}): IConfirmOperation<factory.account.transaction.ITransaction<factory.account.transactionType>>;
+export { DepositTransactionService as deposit, TransferTransactionService as transfer, WithdrawTransactionService as withdraw, confirm };

package/lib/chevre/service/accountTransaction.js

@@ -0,0 +1,60 @@
+"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.confirm = exports.withdraw = exports.transfer = exports.deposit = void 0;
+const factory = require("../factory");
+const DepositTransactionService = require("./accountTransaction/deposit");
+exports.deposit = DepositTransactionService;
+const TransferTransactionService = require("./accountTransaction/transfer");
+exports.transfer = TransferTransactionService;
+const WithdrawTransactionService = require("./accountTransaction/withdraw");
+exports.withdraw = WithdrawTransactionService;
+const factory_1 = require("./accountTransaction/factory");
+/**
+ * 取引確定
+ */
+function confirm(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        let transaction;
+        // 取引存在確認
+        // tslint:disable-next-line:no-single-line-block-comment
+        /* istanbul ignore else */
+        if (typeof params.id === 'string') {
+            transaction = yield repos.accountTransaction.findById({ typeOf: params.typeOf, id: params.id });
+        }
+        else if (typeof params.transactionNumber === 'string') {
+            // tslint:disable-next-line:no-single-line-block-comment
+            /* istanbul ignore next */
+            transaction = yield repos.accountTransaction.findByTransactionNumber({
+                typeOf: params.typeOf,
+                transactionNumber: params.transactionNumber
+            });
+        }
+        else {
+            // tslint:disable-next-line:no-single-line-block-comment
+            /* istanbul ignore next */
+            throw new factory.errors.ArgumentNull('Transaction ID or Transaction Number');
+        }
+        // 現金転送アクション属性作成
+        const moneyTransferActionAttributes = (0, factory_1.createMoneyTransferActionAttributes)({ transaction });
+        const potentialActions = {
+            moneyTransfer: moneyTransferActionAttributes
+        };
+        // 取引確定
+        return repos.accountTransaction.confirm({
+            typeOf: transaction.typeOf,
+            id: transaction.id,
+            result: {},
+            potentialActions
+        });
+    });
+}
+exports.confirm = confirm;

package/lib/chevre/service/aggregation/event/aggregateScreeningEvent.d.ts

@@ -0,0 +1,30 @@
+import { MongoRepository as EventRepo } from '../../../repo/event';
+import { RedisRepository as EventAvailabilityRepo } from '../../../repo/itemAvailability/screeningEvent';
+import { MongoRepository as OfferRepo } from '../../../repo/offer';
+import { MongoRepository as PlaceRepo } from '../../../repo/place';
+import { MongoRepository as ProductRepo } from '../../../repo/product';
+import { MongoRepository as ProjectRepo } from '../../../repo/project';
+import { RedisRepository as OfferRateLimitRepo } from '../../../repo/rateLimit/offer';
+import { MongoRepository as ReservationRepo } from '../../../repo/reservation';
+import { MongoRepository as TaskRepo } from '../../../repo/task';
+import * as factory from '../../../factory';
+export declare type IAggregateScreeningEventOperation<T> = (repos: {
+    event: EventRepo;
+    eventAvailability: EventAvailabilityRepo;
+    offer: OfferRepo;
+    offerRateLimit: OfferRateLimitRepo;
+    place: PlaceRepo;
+    product: ProductRepo;
+    project: ProjectRepo;
+    reservation: ReservationRepo;
+    task: TaskRepo;
+}) => Promise<T>;
+/**
+ * イベントデータをID指定で集計する
+ */
+export declare function aggregateScreeningEvent(params: {
+    id: string;
+}): IAggregateScreeningEventOperation<void>;
+export declare function aggregateByEvent(params: {
+    event: factory.event.screeningEvent.IEvent;
+}): IAggregateScreeningEventOperation<void>;