@chevre/domain 15.65.0-alpha.8 → 20.0.0-alpha.0

package/lib/chevre/service/aggregation/event/importFromCOA.js

@@ -0,0 +1,104 @@
+"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.importFromCOA = void 0;
+/**
+ * COAイベント集計サービス
+ */
+const COA = require("@motionpicture/coa-service");
+const createDebug = require("debug");
+const moment = require("moment-timezone");
+const credentials_1 = require("../../../credentials");
+const event_1 = require("../../event");
+const debug = createDebug('chevre-domain:service');
+const coaAuthClient = new COA.auth.RefreshToken({
+    endpoint: credentials_1.credentials.coa.endpoint,
+    refreshToken: credentials_1.credentials.coa.refreshToken
+});
+/**
+ * イベント席数を更新する
+ */
+function importFromCOA(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        const reserveService = new COA.service.Reserve({
+            endpoint: credentials_1.credentials.coa.endpoint,
+            auth: coaAuthClient
+        }, { timeout: credentials_1.credentials.coa.timeout });
+        try {
+            // COAから空席状況取得
+            const countFreeSeatResult = yield reserveService.countFreeSeat({
+                theaterCode: params.locationBranchCode,
+                begin: moment(params.importFrom)
+                    .tz('Asia/Tokyo')
+                    .format('YYYYMMDD'),
+                end: moment(params.importThrough)
+                    .tz('Asia/Tokyo')
+                    .format('YYYYMMDD') // COAは日本時間で判断
+            });
+            debug('countFreeSeatResult:', countFreeSeatResult);
+            const bulkWriteOps = [];
+            if (Array.isArray(countFreeSeatResult.listDate)) {
+                for (const countFreeSeatDate of countFreeSeatResult.listDate) {
+                    if (Array.isArray(countFreeSeatDate.listPerformance)) {
+                        for (const countFreeSeatPerformance of countFreeSeatDate.listPerformance) {
+                            try {
+                                const eventId = (0, event_1.createScreeningEventIdFromCOA)({
+                                    theaterCode: countFreeSeatResult.theaterCode,
+                                    titleCode: countFreeSeatPerformance.titleCode,
+                                    titleBranchNum: countFreeSeatPerformance.titleBranchNum,
+                                    dateJouei: countFreeSeatDate.dateJouei,
+                                    screenCode: countFreeSeatPerformance.screenCode,
+                                    timeBegin: countFreeSeatPerformance.timeBegin
+                                });
+                                const remainingAttendeeCapacity = Math.max(0, Number(countFreeSeatPerformance.cntReserveFree));
+                                bulkWriteOps.push({
+                                    updateOne: {
+                                        filter: {
+                                            _id: eventId,
+                                            remainingAttendeeCapacity: { $ne: remainingAttendeeCapacity }
+                                        },
+                                        update: { remainingAttendeeCapacity: remainingAttendeeCapacity }
+                                    }
+                                });
+                            }
+                            catch (error) {
+                                // tslint:disable-next-line:no-console
+                                console.error('createScreeningEventIdFromCOA error:', error);
+                            }
+                        }
+                    }
+                }
+            }
+            debug(bulkWriteOps.length, 'ops writing...');
+            if (bulkWriteOps.length > 0) {
+                const res = yield repos.event.bulkWrite(bulkWriteOps);
+                // const res = await repos.event.eventModel.bulkWrite(bulkWriteOps, { ordered: false });
+                debug('bulkWrite res:', res);
+            }
+        }
+        catch (error) {
+            let throwsError = true;
+            // "name": "COAServiceError",
+            // "code": 500,
+            // "status": "",
+            // "message": "ESOCKETTIMEDOUT",
+            if (error.name === 'COAServiceError') {
+                if (error.message === 'ESOCKETTIMEDOUT') {
+                    throwsError = false;
+                }
+            }
+            if (throwsError) {
+                throw error;
+            }
+        }
+    });
+}
+exports.importFromCOA = importFromCOA;

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

@@ -0,0 +1,7 @@
+/**
+ * イベント集計サービス
+ */
+import { aggregateScreeningEvent } from './event/aggregateScreeningEvent';
+import { aggregateUseActionsOnEvent } from './event/aggregateUseActionsOnEvent';
+import { importFromCOA } from './event/importFromCOA';
+export { aggregateScreeningEvent, aggregateUseActionsOnEvent, importFromCOA };

package/lib/chevre/service/aggregation/event.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.importFromCOA = exports.aggregateUseActionsOnEvent = exports.aggregateScreeningEvent = void 0;
+/**
+ * イベント集計サービス
+ */
+const aggregateScreeningEvent_1 = require("./event/aggregateScreeningEvent");
+Object.defineProperty(exports, "aggregateScreeningEvent", { enumerable: true, get: function () { return aggregateScreeningEvent_1.aggregateScreeningEvent; } });
+const aggregateUseActionsOnEvent_1 = require("./event/aggregateUseActionsOnEvent");
+Object.defineProperty(exports, "aggregateUseActionsOnEvent", { enumerable: true, get: function () { return aggregateUseActionsOnEvent_1.aggregateUseActionsOnEvent; } });
+const importFromCOA_1 = require("./event/importFromCOA");
+Object.defineProperty(exports, "importFromCOA", { enumerable: true, get: function () { return importFromCOA_1.importFromCOA; } });

package/lib/chevre/service/aggregation/project.js

@@ -0,0 +1,122 @@
+"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.aggregate = void 0;
+/**
+ * プロジェクト集計サービス
+ */
+const createDebug = require("debug");
+const moment = require("moment");
+const factory = require("../../factory");
+const debug = createDebug('chevre-domain:service');
+function aggregate(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        const now = new Date();
+        // 集計対象プロジェクト検索
+        const project = yield repos.project.findById(params.project);
+        // 予約集計
+        const { aggregateReservation } = yield aggregateReservationOnProject({
+            aggregateDate: now,
+            project: { id: project.id, typeOf: project.typeOf },
+            reservationFor: {
+                startFrom: moment(params.reservationFor.startFrom)
+                    .toDate(),
+                startThrough: moment(params.reservationFor.startThrough)
+                    .toDate()
+            }
+        })(repos);
+        debug('aggregated. aggregateReservation:', aggregateReservation);
+        // 値がundefinedの場合に更新しないように注意
+        // const update: any = {
+        //     $set: {
+        //         updatedAt: new Date(), // $setオブジェクトが空だとMongoエラーになるので
+        //         aggregateReservation: aggregateReservation
+        //     },
+        //     $unset: {
+        //         noExistingAttributeName: 1 // $unsetは空だとエラーになるので
+        //     }
+        // };
+        // debug('update:', update);
+        // 保管
+        yield repos.project.updateAggregateReservation({
+            id: project.id,
+            aggregateReservation
+        });
+        // await repos.project.projectModel.findOneAndUpdate(
+        //     { _id: project.id },
+        //     update,
+        //     { new: true }
+        // )
+        //     .exec();
+        // if (projectDoc !== null) {
+        //     project = projectDoc.toObject();
+        // }
+    });
+}
+exports.aggregate = aggregate;
+function aggregateReservationOnProject(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        let attendeeCount = 0;
+        let checkInCount = 0;
+        let reservationCount = 0;
+        const reservationForConditions = {
+            startFrom: moment(params.reservationFor.startFrom)
+                .add(-1, 'day')
+                .toDate()
+        };
+        while (reservationForConditions.startThrough === undefined
+            || moment(params.reservationFor.startThrough)
+                .isAfter(moment(reservationForConditions.startThrough))) {
+            reservationForConditions.startFrom = moment(reservationForConditions.startFrom)
+                .add(1, 'day')
+                .toDate();
+            reservationForConditions.startThrough = moment(reservationForConditions.startFrom)
+                .add(1, 'day')
+                .add(-1, 'millisecond')
+                .toDate();
+            debug('counting...', reservationForConditions);
+            reservationCount += yield repos.reservation.count({
+                project: { id: { $eq: params.project.id } },
+                typeOf: factory.reservationType.EventReservation,
+                reservationFor: reservationForConditions,
+                reservationStatuses: [factory.reservationStatusType.ReservationConfirmed]
+            });
+            attendeeCount += yield repos.reservation.count({
+                project: { id: { $eq: params.project.id } },
+                typeOf: factory.reservationType.EventReservation,
+                reservationFor: reservationForConditions,
+                // reservationStatuses: [factory.reservationStatusType.ReservationConfirmed],
+                attended: true
+            });
+            checkInCount += yield repos.reservation.count({
+                project: { id: { $eq: params.project.id } },
+                typeOf: factory.reservationType.EventReservation,
+                reservationFor: reservationForConditions,
+                // reservationStatuses: [factory.reservationStatusType.ReservationConfirmed],
+                checkedIn: true
+            });
+        }
+        return {
+            aggregateReservation: {
+                typeOf: 'AggregateReservation',
+                aggregateDate: params.aggregateDate,
+                reservationFor: {
+                    startDate: `${moment(params.reservationFor.startFrom)
+                        .toISOString()}/${moment(params.reservationFor.startThrough)
+                        .toISOString()}`
+                },
+                attendeeCount,
+                checkInCount,
+                reservationCount
+            }
+        };
+    });
+}

package/lib/chevre/service/assetTransaction/cancelReservation/factory.d.ts

@@ -0,0 +1,14 @@
+import * as factory from '../../../factory';
+/**
+ * 取引開始パラメータ作成
+ */
+export declare function createStartParams(params: {
+    paramsWithoutDetail: factory.assetTransaction.cancelReservation.IStartParamsWithoutDetail;
+    project: factory.assetTransaction.IProject;
+    transactionNumber: string;
+    transaction?: factory.assetTransaction.ITransaction<factory.assetTransactionType.Reserve>;
+    reservations?: factory.reservation.IReservation<factory.reservationType.EventReservation>[];
+}): factory.assetTransaction.IStartParams<factory.assetTransactionType.CancelReservation>;
+export declare function createPotentialActions(params: {
+    transaction: factory.assetTransaction.ITransaction<factory.assetTransactionType.CancelReservation>;
+}): factory.assetTransaction.cancelReservation.IPotentialActions;

package/lib/chevre/service/assetTransaction/cancelReservation/factory.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPotentialActions = exports.createStartParams = void 0;
+const factory = require("../../../factory");
+/**
+ * 取引開始パラメータ作成
+ */
+function createStartParams(params) {
+    const cancelReservationObject = {
+        clientUser: params.paramsWithoutDetail.object.clientUser,
+        transaction: params.transaction,
+        reservations: params.reservations
+    };
+    return {
+        project: { id: params.project.id, typeOf: params.project.typeOf },
+        transactionNumber: params.transactionNumber,
+        typeOf: factory.assetTransactionType.CancelReservation,
+        agent: params.paramsWithoutDetail.agent,
+        object: cancelReservationObject,
+        expires: params.paramsWithoutDetail.expires
+    };
+}
+exports.createStartParams = createStartParams;
+function createPotentialActions(params) {
+    var _a, _b;
+    const transaction = params.transaction;
+    let targetReservations = [];
+    // 予約番号指定の取消取引であれば、予約取引から取消対象予約リストを作成する
+    const reservationForByReserveTransaction = (_a = transaction.object.transaction) === null || _a === void 0 ? void 0 : _a.object.reservationFor;
+    const subReservationByReserveTransaction = (_b = transaction.object.transaction) === null || _b === void 0 ? void 0 : _b.object.subReservation;
+    if (reservationForByReserveTransaction !== undefined && Array.isArray(subReservationByReserveTransaction)) {
+        targetReservations = subReservationByReserveTransaction.map((r) => {
+            return Object.assign(Object.assign({}, r), { reservationFor: reservationForByReserveTransaction });
+        });
+    }
+    else if (Array.isArray(transaction.object.reservations)) {
+        targetReservations = transaction.object.reservations;
+    }
+    // 予約取消アクション属性作成
+    const cancelReservationActionAttributes = targetReservations.map((reservation) => {
+        var _a;
+        // 最適化(2022-06-06~)
+        const cancelObject = {
+            typeOf: reservation.typeOf,
+            id: reservation.id,
+            issuedThrough: {
+                typeOf: (_a = reservation.issuedThrough) === null || _a === void 0 ? void 0 : _a.typeOf
+            },
+            reservationFor: {
+                typeOf: reservation.reservationFor.typeOf,
+                id: reservation.reservationFor.id
+            },
+            reservationNumber: reservation.reservationNumber,
+            // ReservationConfirmed->ReservationCancelledのみ処理されるように保証する
+            reservationStatus: factory.reservationStatusType.ReservationConfirmed
+        };
+        return {
+            project: transaction.project,
+            typeOf: factory.actionType.CancelAction,
+            // result: {},
+            object: cancelObject,
+            agent: transaction.project,
+            potentialActions: {},
+            purpose: {
+                typeOf: transaction.typeOf,
+                id: transaction.id
+            }
+        };
+    });
+    return {
+        cancelReservation: cancelReservationActionAttributes
+    };
+}
+exports.createPotentialActions = createPotentialActions;

package/lib/chevre/service/assetTransaction/cancelReservation.d.ts

@@ -0,0 +1,35 @@
+import * as factory from '../../factory';
+import { MongoRepository as AssetTransactionRepo } from '../../repo/assetTransaction';
+import { MongoRepository as ProjectRepo } from '../../repo/project';
+import { MongoRepository as ReservationRepo } from '../../repo/reservation';
+import { MongoRepository as TaskRepo } from '../../repo/task';
+export declare type IStartOperation<T> = (repos: {
+    project: ProjectRepo;
+    reservation: ReservationRepo;
+    assetTransaction: AssetTransactionRepo;
+}) => Promise<T>;
+export declare type ITaskAndTransactionOperation<T> = (repos: {
+    task: TaskRepo;
+    assetTransaction: AssetTransactionRepo;
+}) => Promise<T>;
+export declare type ITransactionOperation<T> = (repos: {
+    assetTransaction: AssetTransactionRepo;
+}) => Promise<T>;
+/**
+ * 取引開始
+ */
+export declare function start(params: factory.assetTransaction.cancelReservation.IStartParamsWithoutDetail): IStartOperation<factory.assetTransaction.cancelReservation.ITransaction>;
+/**
+ * 取引確定
+ */
+export declare function confirm(params: factory.assetTransaction.cancelReservation.IConfirmParams): ITransactionOperation<void>;
+/**
+ * 取引開始
+ */
+export declare function startAndConfirm(params: factory.assetTransaction.cancelReservation.IStartParamsWithoutDetail & {}): IStartOperation<factory.assetTransaction.cancelReservation.ITransaction>;
+/**
+ * 取引タスク出力
+ */
+export declare function exportTasksById(params: {
+    id: string;
+}): ITaskAndTransactionOperation<factory.task.ITask<factory.taskName>[]>;

package/lib/chevre/service/assetTransaction/cancelReservation.js

@@ -0,0 +1,243 @@
+"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.exportTasksById = exports.startAndConfirm = exports.confirm = exports.start = void 0;
+/**
+ * 予約取消取引サービス
+ */
+const createDebug = require("debug");
+const moment = require("moment");
+const mongoose = require("mongoose");
+const factory = require("../../factory");
+const settings_1 = require("../../settings");
+const factory_1 = require("./cancelReservation/factory");
+const debug = createDebug('chevre-domain:service');
+function validateStartParams(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        let reserveTransaction;
+        let reservations;
+        // 予約番号で取引存在確認
+        if (typeof ((_a = params.object.reservation) === null || _a === void 0 ? void 0 : _a.reservationNumber) === 'string') {
+            const transactions = yield repos.assetTransaction.search({
+                limit: 1,
+                page: 1,
+                typeOf: factory.assetTransactionType.Reserve,
+                object: { reservationNumber: { $eq: params.object.reservation.reservationNumber } }
+            });
+            reserveTransaction = transactions.shift();
+            // ここでReservationConfirmedでない予約をスルーしても、
+            // ReservationRepo.cancel()で冪等性を保証しているのでvalidation不要か(2022-05-12~)
+            // 予約ステータス確認
+            // const unconfirmedReservations = await repos.reservation.search({
+            //     limit: 1,
+            //     page: 1,
+            //     typeOf: factory.reservationType.EventReservation,
+            //     reservationNumber: { $eq: params.object.reservation.reservationNumber },
+            //     reservationStatus: { $ne: factory.reservationStatusType.ReservationConfirmed }
+            // });
+            // if (unconfirmedReservations.length > 0) {
+            // tslint:disable-next-line:max-line-length
+            //     throw new factory.errors.Argument('object.reservation.reservationNumber', `Reservation ${unconfirmedReservations[0].id} not confirmed`);
+            // }
+        }
+        // 取引指定が確認できなければ、予約指定を確認
+        if (reserveTransaction === undefined) {
+            // 予約存在確認
+            if (typeof ((_b = params.object.reservation) === null || _b === void 0 ? void 0 : _b.id) === 'string') {
+                const reservation = yield repos.reservation.findById({
+                    id: params.object.reservation.id
+                });
+                reservations = [reservation];
+                // 予約ステータス確認
+                if (reservation.reservationStatus !== factory.reservationStatusType.ReservationConfirmed) {
+                    throw new factory.errors.Argument('object.reservation.id', `Reservation ${reservation.id} not confirmed`);
+                }
+            }
+        }
+        if (reserveTransaction === undefined && reservations === undefined) {
+            throw new factory.errors.Argument('object', 'Transaction or reservation must be specified');
+        }
+        return {
+            reserveTransaction,
+            reservations
+        };
+    });
+}
+/**
+ * 取引開始
+ */
+function start(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        const project = yield repos.project.findById({ id: params.project.id });
+        const { reserveTransaction, reservations } = yield validateStartParams(params)(repos);
+        const transactionNumber = params.transactionNumber;
+        if (typeof transactionNumber !== 'string' || transactionNumber.length === 0) {
+            throw new factory.errors.ArgumentNull('transactionNumber');
+        }
+        const startParams = (0, factory_1.createStartParams)({
+            project: { id: project.id, typeOf: project.typeOf },
+            paramsWithoutDetail: params,
+            transactionNumber,
+            transaction: reserveTransaction,
+            reservations: reservations
+        });
+        // 予約ホールドする？要検討...
+        // await Promise.all(reservations.map(async (r) => {
+        //     await repos.reservation.reservationModel.create({ ...r, _id: r.id });
+        // }));
+        // 取引作成
+        return repos.assetTransaction.start(startParams);
+    });
+}
+exports.start = start;
+/**
+ * 取引確定
+ */
+function confirm(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        // 取引存在確認
+        const transaction = yield repos.assetTransaction.findById({
+            typeOf: factory.assetTransactionType.CancelReservation,
+            id: params.id
+        });
+        const potentialActions = (0, factory_1.createPotentialActions)({
+            transaction: transaction
+            // confirmParams: params
+        });
+        // 取引確定
+        const result = {};
+        yield repos.assetTransaction.confirm({
+            typeOf: factory.assetTransactionType.CancelReservation,
+            id: transaction.id,
+            result: result,
+            potentialActions: potentialActions
+        });
+    });
+}
+exports.confirm = confirm;
+/**
+ * 取引開始
+ */
+function startAndConfirm(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        const project = yield repos.project.findById({ id: params.project.id });
+        const { reserveTransaction, reservations } = yield validateStartParams(params)(repos);
+        const transactionNumber = params.transactionNumber;
+        if (typeof transactionNumber !== 'string' || transactionNumber.length === 0) {
+            throw new factory.errors.ArgumentNull('transactionNumber');
+        }
+        const startParams = (0, factory_1.createStartParams)({
+            project: { id: project.id, typeOf: project.typeOf },
+            paramsWithoutDetail: params,
+            transactionNumber,
+            transaction: reserveTransaction,
+            reservations: reservations
+        });
+        const transactionId = new mongoose.Types.ObjectId().toHexString();
+        const transaction = Object.assign(Object.assign({}, startParams), { id: transactionId, startDate: new Date(), status: factory.transactionStatusType.InProgress, tasksExportationStatus: factory.transactionTasksExportationStatus.Unexported });
+        // 事前に取引IDだけ発行
+        const potentialActions = (0, factory_1.createPotentialActions)({
+            transaction: transaction
+            // confirmParams: {
+            //     id: transactionId,
+            //     potentialActions: params.potentialActions
+            // }
+        });
+        const result = {};
+        // 取引作成
+        return repos.assetTransaction.startAndConfirm(Object.assign(Object.assign({}, startParams), { id: transactionId, result: result, potentialActions: potentialActions }));
+    });
+}
+exports.startAndConfirm = startAndConfirm;
+/**
+ * 取引タスク出力
+ */
+function exportTasksById(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        const transaction = yield repos.assetTransaction.findById({
+            typeOf: factory.assetTransactionType.CancelReservation,
+            id: params.id
+        });
+        const potentialActions = transaction.potentialActions;
+        const taskAttributes = [];
+        // 資産取引削除タスクを作成
+        const deleteTransactionTask = {
+            project: transaction.project,
+            name: factory.taskName.DeleteAssetTransaction,
+            status: factory.taskStatus.Ready,
+            runsAt: moment(transaction.endDate)
+                .add(settings_1.ASSET_TRANSACTION_STORAGE_PERIOD_IN_DAYS, 'days')
+                .toDate(),
+            remainingNumberOfTries: 3,
+            numberOfTried: 0,
+            executionResults: [],
+            data: {
+                object: {
+                    project: transaction.project,
+                    id: transaction.id,
+                    transactionNumber: transaction.transactionNumber,
+                    typeOf: transaction.typeOf
+                }
+            }
+        };
+        taskAttributes.push(deleteTransactionTask);
+        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 cancelReservationTasks = potentialActions.cancelReservation.map((a) => {
+                            return {
+                                project: transaction.project,
+                                name: factory.taskName.CancelReservation,
+                                status: factory.taskStatus.Ready,
+                                runsAt: new Date(),
+                                remainingNumberOfTries: 10,
+                                numberOfTried: 0,
+                                executionResults: [],
+                                data: {
+                                    actionAttributes: [a]
+                                }
+                            };
+                        });
+                        taskAttributes.push(...cancelReservationTasks);
+                    }
+                }
+                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 repos.task.saveMany(taskAttributes);
+        // return Promise.all(taskAttributes.map(async (a) => repos.task.save(a)));
+    });
+}
+exports.exportTasksById = exportTasksById;