@chevre/domain/lib/service/transaction/cancelReservation.js

Chevre Domain Library for Node.js

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    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) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
/**
 * 予約キャンセル取引サービス
 */
const createDebug = require("debug");
const factory = require("../../factory");
const debug = createDebug('chevre-domain:service');
/**
 * 取引開始
 */
function start(params) {
    return (repos) => __awaiter(this, void 0, void 0, function* () {
        debug('starting transaction...', params);
        // 予約取引存在確認
        const reserveTransaction = yield repos.transaction.findById({
            typeOf: factory.transactionType.Reserve,
            id: params.object.transaction.id
        });
        const startParams = {
            typeOf: factory.transactionType.CancelReservation,
            agent: params.agent,
            object: {
                clientUser: params.object.clientUser,
                transaction: reserveTransaction
            },
            expires: params.expires
        };
        // 取引作成
        let transaction;
        try {
            transaction = yield repos.transaction.start(startParams);
        }
        catch (error) {
            // tslint:disable-next-line:no-single-line-block-comment
            /* istanbul ignore next */
            if (error.name === 'MongoError') {
                // no op
            }
            throw error;
        }
        // tslint:disable-next-line:no-suspicious-comment
        // TODO 予約ホールド
        // await Promise.all(reservations.map(async (r) => {
        //     await repos.reservation.reservationModel.create({ ...r, _id: r.id });
        // }));
        return transaction;
    });
}
exports.start = start;
/**
 * 取引確定
 */
function confirm(params) {
    return (repos) => __awaiter(this, void 0, void 0, function* () {
        debug(`confirming reserve transaction ${params.id}...`);
        // 取引存在確認
        const transaction = yield repos.transaction.findById({
            typeOf: factory.transactionType.CancelReservation,
            id: params.id
        });
        const reserveTransaction = transaction.object.transaction;
        // 予約アクション属性作成
        const cancelReservationActionAttributes = reserveTransaction.object.reservations.map((r) => {
            return {
                typeOf: factory.actionType.CancelAction,
                // description: transaction.object.notes,
                result: {},
                object: r,
                agent: transaction.agent,
                purpose: {
                    typeOf: transaction.typeOf,
                    id: transaction.id
                }
            };
        });
        const potentialActions = {
            cancelReservation: cancelReservationActionAttributes
        };
        // 取引確定
        const result = {};
        yield repos.transaction.confirm({
            typeOf: factory.transactionType.CancelReservation,
            id: transaction.id,
            result: result,
            potentialActions: potentialActions
        });
    });
}
exports.confirm = confirm;
/**
 * ひとつの取引のタスクをエクスポートする
 */
function exportTasks(status) {
    return (repos) => __awaiter(this, void 0, void 0, function* () {
        const transaction = yield repos.transaction.startExportTasks({
            typeOf: factory.transactionType.CancelReservation,
            status: status
        });
        if (transaction === null) {
            return;
        }
        // 失敗してもここでは戻さない(RUNNINGのまま待機)
        yield exportTasksById(transaction)(repos);
        yield repos.transaction.setTasksExportedById({ id: transaction.id });
    });
}
exports.exportTasks = exportTasks;
/**
 * ID指定で取引のタスク出力
 */
function exportTasksById(params) {
    return (repos) => __awaiter(this, void 0, void 0, function* () {
        const transaction = yield repos.transaction.findById({
            typeOf: factory.transactionType.CancelReservation,
            id: params.id
        });
        const potentialActions = transaction.potentialActions;
        const taskAttributes = [];
        switch (transaction.status) {
            case factory.transactionStatusType.Confirmed:
                // tslint:disable-next-line:no-single-line-block-comment
                /* istanbul ignore else */
                if (potentialActions !== undefined) {
                    // tslint:disable-next-line:no-single-line-block-comment
                    /* istanbul ignore else */
                    if (potentialActions.cancelReservation !== undefined) {
                        const cancelReservationTask = {
                            name: factory.taskName.CancelReservation,
                            status: factory.taskStatus.Ready,
                            runsAt: new Date(),
                            remainingNumberOfTries: 10,
                            lastTriedAt: null,
                            numberOfTried: 0,
                            executionResults: [],
                            data: {
                                actionAttributes: potentialActions.cancelReservation
                            }
                        };
                        taskAttributes.push(cancelReservationTask);
                    }
                }
                break;
            case factory.transactionStatusType.Canceled:
            case factory.transactionStatusType.Expired:
                // const cancelMoneyTransferTask: factory.task.cancelMoneyTransfer.IAttributes = {
                //     name: factory.taskName.CancelMoneyTransfer,
                //     status: factory.taskStatus.Ready,
                //     runsAt: new Date(), // なるはやで実行
                //     remainingNumberOfTries: 10,
                //     lastTriedAt: null,
                //     numberOfTried: 0,
                //     executionResults: [],
                //     data: {
                //         transaction: { typeOf: transaction.typeOf, id: transaction.id }
                //     }
                // };
                // taskAttributes.push(cancelMoneyTransferTask);
                break;
            default:
                throw new factory.errors.NotImplemented(`Transaction status "${transaction.status}" not implemented.`);
        }
        debug('taskAttributes prepared', taskAttributes);
        return Promise.all(taskAttributes.map((a) => __awaiter(this, void 0, void 0, function* () { return repos.task.save(a); })));
    });
}
exports.exportTasksById = exportTasksById;