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

package/lib/chevre/service/reserve/potentialActions/onReservationCheckedIn.js

@@ -0,0 +1,125 @@
+"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.onReservationCheckedIn = void 0;
+/**
+ * 予約発券時アクション
+ */
+const moment = require("moment");
+const factory = require("../../../factory");
+const settings_1 = require("../../../settings");
+const offer_1 = require("../../offer");
+const factory_1 = require("../factory");
+const informReservations = settings_1.settings.onReservationStatusChanged.informReservation;
+const INFORM_TASK_DELAY_IN_SECONDS = 30;
+// tslint:disable-next-line:max-func-body-length
+function onReservationCheckedIn(params) {
+    // tslint:disable-next-line:max-func-body-length
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const tasks = [];
+        const project = { id: params.project.id, typeOf: factory.organizationType.Project };
+        // inform galobally
+        if (Array.isArray(informReservations)) {
+            // やや遅延させる(確定通知が未達の可能性を考慮して)
+            const informTaskRunsAt = moment(params.now)
+                .add(INFORM_TASK_DELAY_IN_SECONDS, 'seconds')
+                .toDate();
+            informReservations.forEach((informReservation) => {
+                var _a;
+                const informUrl = String((_a = informReservation.recipient) === null || _a === void 0 ? void 0 : _a.url);
+                if (Array.isArray(params.object.ids) && params.object.ids.length > 0) {
+                    const reservations4inform = params.object.ids.map((reservationId) => {
+                        return {
+                            typeOf: factory.reservationType.EventReservation,
+                            project,
+                            id: reservationId,
+                            checkedIn: true,
+                            modifiedTime: params.now
+                        };
+                    });
+                    const informReservationAttributes = {
+                        agent: project,
+                        object: reservations4inform,
+                        project,
+                        recipient: {
+                            id: '',
+                            name: informUrl,
+                            typeOf: factory.creativeWorkType.WebApplication,
+                            url: informUrl
+                        },
+                        typeOf: factory.actionType.InformAction
+                    };
+                    const informReservationTask = {
+                        project,
+                        name: factory.taskName.TriggerWebhook,
+                        status: factory.taskStatus.Ready,
+                        runsAt: informTaskRunsAt,
+                        remainingNumberOfTries: factory_1.NUM_TRY_INFORM_RESERVATION,
+                        numberOfTried: 0,
+                        executionResults: [],
+                        data: informReservationAttributes
+                    };
+                    tasks.push(informReservationTask);
+                }
+                if (Array.isArray(params.object.reservationNumbers) && params.object.reservationNumbers.length > 0) {
+                    const reservations4inform = params.object.reservationNumbers.map((reservationNumber) => {
+                        return {
+                            typeOf: factory.reservationType.EventReservation,
+                            project,
+                            reservationNumber,
+                            checkedIn: true,
+                            modifiedTime: params.now
+                        };
+                    });
+                    const informReservationAttributes = {
+                        agent: project,
+                        object: reservations4inform,
+                        project,
+                        recipient: {
+                            id: '',
+                            name: informUrl,
+                            typeOf: factory.creativeWorkType.WebApplication,
+                            url: informUrl
+                        },
+                        typeOf: factory.actionType.InformAction
+                    };
+                    const informReservationTask = {
+                        project,
+                        name: factory.taskName.TriggerWebhook,
+                        status: factory.taskStatus.Ready,
+                        runsAt: informTaskRunsAt,
+                        remainingNumberOfTries: factory_1.NUM_TRY_INFORM_RESERVATION,
+                        numberOfTried: 0,
+                        executionResults: [],
+                        data: informReservationAttributes
+                    };
+                    tasks.push(informReservationTask);
+                }
+            });
+        }
+        if (tasks.length > 0) {
+            yield repos.task.saveMany(tasks);
+        }
+        // 冗長な作成を避ける
+        const reservationForIds = (_a = params.object.reservationFor) === null || _a === void 0 ? void 0 : _a.ids;
+        if (Array.isArray(reservationForIds)) {
+            // イベント集計タスクを追加
+            yield Promise.all(reservationForIds.map((reservationForId) => __awaiter(this, void 0, void 0, function* () {
+                yield (0, offer_1.createAggregateScreeningEventIfNotExist)({
+                    project: { id: params.project.id },
+                    reservationFor: { id: reservationForId }
+                })({ task: repos.task });
+            })));
+        }
+    });
+}
+exports.onReservationCheckedIn = onReservationCheckedIn;

package/lib/chevre/service/reserve/potentialActions/onReservationConfirmed.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 予約確定時アクション
+ */
+import * as factory from '../../../factory';
+import { MongoRepository as TaskRepo } from '../../../repo/task';
+declare type IEventReservation = factory.reservation.IReservation<factory.reservationType.EventReservation>;
+/**
+ * 予約確定後のアクション
+ */
+export declare function onReservationConfirmedByAction(actionAttributes: factory.action.reserve.IAttributes, confirmedReservation: IEventReservation): (repos: {
+    task: TaskRepo;
+}) => Promise<void>;
+export declare function onReservationConfirmed(confirmedReservations: IEventReservation[]): (repos: {
+    task: TaskRepo;
+}) => Promise<void>;
+export {};

package/lib/chevre/service/reserve/potentialActions/onReservationConfirmed.js

@@ -0,0 +1,94 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onReservationConfirmed = exports.onReservationConfirmedByAction = void 0;
+/**
+ * 予約確定時アクション
+ */
+const factory = require("../../../factory");
+const settings_1 = require("../../../settings");
+const offer_1 = require("../../offer");
+const factory_1 = require("../factory");
+const informReservations = settings_1.settings.onReservationStatusChanged.informReservation;
+/**
+ * 予約確定後のアクション
+ */
+function onReservationConfirmedByAction(actionAttributes, confirmedReservation) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        const potentialActions = actionAttributes.potentialActions;
+        const now = new Date();
+        const taskAttributes = [];
+        // tslint:disable-next-line:no-single-line-block-comment
+        /* istanbul ignore else */
+        if (potentialActions !== undefined) {
+            if (Array.isArray(potentialActions.moneyTransfer)) {
+                taskAttributes.push(...potentialActions.moneyTransfer.map((a) => {
+                    return {
+                        project: a.project,
+                        name: factory.taskName.MoneyTransfer,
+                        status: factory.taskStatus.Ready,
+                        runsAt: now,
+                        remainingNumberOfTries: 10,
+                        numberOfTried: 0,
+                        executionResults: [],
+                        data: a
+                    };
+                }));
+            }
+        }
+        // inform galobally
+        if (Array.isArray(informReservations)) {
+            const reservation4inform = (0, factory_1.maskUnderName)(confirmedReservation);
+            taskAttributes.push(...informReservations.map((informReservation) => {
+                var _a;
+                const informUrl = String((_a = informReservation.recipient) === null || _a === void 0 ? void 0 : _a.url);
+                const informReservationAttributes = {
+                    agent: confirmedReservation.project,
+                    object: [reservation4inform],
+                    project: confirmedReservation.project,
+                    recipient: {
+                        id: '',
+                        name: informUrl,
+                        typeOf: factory.creativeWorkType.WebApplication,
+                        url: informUrl
+                    },
+                    typeOf: factory.actionType.InformAction
+                };
+                return {
+                    project: actionAttributes.project,
+                    name: factory.taskName.TriggerWebhook,
+                    status: factory.taskStatus.Ready,
+                    runsAt: now,
+                    remainingNumberOfTries: factory_1.NUM_TRY_INFORM_RESERVATION,
+                    numberOfTried: 0,
+                    executionResults: [],
+                    data: informReservationAttributes
+                };
+            }));
+        }
+        // タスク保管
+        if (taskAttributes.length > 0) {
+            yield repos.task.saveMany(taskAttributes);
+        }
+    });
+}
+exports.onReservationConfirmedByAction = onReservationConfirmedByAction;
+function onReservationConfirmed(confirmedReservations) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        if (Array.isArray(confirmedReservations) && confirmedReservations.length > 0) {
+            yield (0, offer_1.createAggregateScreeningEventIfNotExist)({
+                project: confirmedReservations[0].project,
+                reservationFor: { id: confirmedReservations[0].reservationFor.id }
+            })({ task: repos.task });
+        }
+    });
+}
+exports.onReservationConfirmed = onReservationConfirmed;

package/lib/chevre/service/reserve/potentialActions/onReservationUsed.d.ts

@@ -0,0 +1,11 @@
+import * as factory from '../../../factory';
+import { MongoRepository as TaskRepo } from '../../../repo/task';
+declare type IEventReservation = factory.reservation.IReservation<factory.reservationType.EventReservation>;
+export declare type IUseReservationAction = factory.action.consume.use.reservation.IAction;
+/**
+ * 予約使用
+ */
+export declare function onReservationUsed(action: IUseReservationAction, attendedReservation: IEventReservation): (repos: {
+    task: TaskRepo;
+}) => Promise<void>;
+export {};

package/lib/chevre/service/reserve/potentialActions/onReservationUsed.js

@@ -0,0 +1,141 @@
+"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());
+    });
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onReservationUsed = void 0;
+/**
+ * 予約使用時アクション
+ */
+const moment = require("moment");
+const factory = require("../../../factory");
+const settings_1 = require("../../../settings");
+const offer_1 = require("../../offer");
+const factory_1 = require("../factory");
+const informReservations = settings_1.settings.onReservationStatusChanged.informReservation;
+const informUseReservations = (_a = settings_1.settings.onReservationUsed) === null || _a === void 0 ? void 0 : _a.informAction;
+const INFORM_TASK_DELAY_IN_SECONDS = 30;
+/**
+ * 予約使用
+ */
+function onReservationUsed(action, attendedReservation) {
+    // tslint:disable-next-line:max-func-body-length
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        // const reservation = action.object[0];
+        const tasks = [];
+        const now = new Date();
+        // アクション通知タスク作成
+        if (Array.isArray(informUseReservations)) {
+            informUseReservations.filter((informUseReservation) => {
+                var _a;
+                return typeof ((_a = informUseReservation.recipient) === null || _a === void 0 ? void 0 : _a.url) === 'string'
+                    && informUseReservation.recipient.url.length > 0;
+            })
+                .forEach((informUseReservation) => {
+                var _a, _b;
+                const triggerWebhookTask = {
+                    project: action.project,
+                    name: factory.taskName.TriggerWebhook,
+                    status: factory.taskStatus.Ready,
+                    runsAt: now,
+                    remainingNumberOfTries: 3,
+                    numberOfTried: 0,
+                    executionResults: [],
+                    data: {
+                        project: action.project,
+                        typeOf: factory.actionType.InformAction,
+                        agent: action.project,
+                        recipient: {
+                            typeOf: factory.personType.Person,
+                            id: String((_a = informUseReservation.recipient) === null || _a === void 0 ? void 0 : _a.url),
+                            url: String((_b = informUseReservation.recipient) === null || _b === void 0 ? void 0 : _b.url)
+                        },
+                        object: action
+                    }
+                };
+                tasks.push(triggerWebhookTask);
+            });
+        }
+        // inform galobally
+        if (Array.isArray(informReservations)) {
+            // やや遅延させる(確定通知が未達の可能性を考慮して)
+            const informTaskRunsAt = moment(now)
+                .add(INFORM_TASK_DELAY_IN_SECONDS, 'seconds')
+                .toDate();
+            const reservation4inform = {
+                typeOf: attendedReservation.typeOf,
+                project: attendedReservation.project,
+                id: attendedReservation.id,
+                attended: true,
+                modifiedTime: attendedReservation.modifiedTime,
+                reservedTicket: { dateUsed: attendedReservation.reservedTicket.dateUsed }
+            };
+            tasks.push(...informReservations.map((informReservation) => {
+                var _a;
+                const informUrl = String((_a = informReservation.recipient) === null || _a === void 0 ? void 0 : _a.url);
+                const informReservationAttributes = {
+                    agent: attendedReservation.project,
+                    object: [reservation4inform],
+                    project: attendedReservation.project,
+                    recipient: {
+                        id: '',
+                        name: informUrl,
+                        typeOf: factory.creativeWorkType.WebApplication,
+                        url: informUrl
+                    },
+                    typeOf: factory.actionType.InformAction
+                };
+                return {
+                    project: action.project,
+                    name: factory.taskName.TriggerWebhook,
+                    status: factory.taskStatus.Ready,
+                    runsAt: informTaskRunsAt,
+                    remainingNumberOfTries: factory_1.NUM_TRY_INFORM_RESERVATION,
+                    numberOfTried: 0,
+                    executionResults: [],
+                    data: informReservationAttributes
+                };
+            }));
+        }
+        // 使用アクション集計タスクを作成する(冗長な作成を避ける)
+        const readyAggregateUseActionsTaskDoc = yield repos.task.taskModel.findOne({
+            'project.id': { $eq: action.project.id },
+            name: { $eq: factory.taskName.AggregateUseActionsOnEvent },
+            status: { $eq: factory.taskStatus.Ready },
+            'data.id': { $exists: true, $eq: attendedReservation.reservationFor.id }
+        }, { _id: 1 })
+            .exec();
+        if (readyAggregateUseActionsTaskDoc === null) {
+            const aggregateUseActionsTask = {
+                project: attendedReservation.project,
+                name: factory.taskName.AggregateUseActionsOnEvent,
+                status: factory.taskStatus.Ready,
+                runsAt: now,
+                remainingNumberOfTries: 3,
+                numberOfTried: 0,
+                executionResults: [],
+                data: {
+                    typeOf: attendedReservation.reservationFor.typeOf,
+                    id: attendedReservation.reservationFor.id
+                }
+            };
+            tasks.push(aggregateUseActionsTask);
+        }
+        if (tasks.length > 0) {
+            yield repos.task.saveMany(tasks);
+        }
+        // 冗長な作成を避ける
+        yield (0, offer_1.createAggregateScreeningEventIfNotExist)({
+            project: attendedReservation.project,
+            reservationFor: { id: attendedReservation.reservationFor.id }
+        })({ task: repos.task });
+    });
+}
+exports.onReservationUsed = onReservationUsed;

package/lib/chevre/service/reserve/useReservation.d.ts

@@ -0,0 +1,35 @@
+/**
+ * 予約サービス
+ */
+import * as factory from '../../factory';
+import { MongoRepository as ActionRepo } from '../../repo/action';
+import { MongoRepository as OrderRepo } from '../../repo/order';
+import { MongoRepository as ReservationRepo } from '../../repo/reservation';
+import { MongoRepository as TaskRepo } from '../../repo/task';
+import { IUseReservationAction } from './potentialActions/onReservationUsed';
+/**
+ * 予約使用
+ */
+export declare function useReservation(params: {
+    project: {
+        id: string;
+    };
+    agent: factory.action.consume.use.reservation.IAgent;
+    object: {
+        /**
+         * 予約ID
+         */
+        id: string;
+    };
+    instrument?: {
+        token?: string;
+    };
+    location?: {
+        identifier?: string;
+    };
+}): (repos: {
+    action: ActionRepo;
+    order: OrderRepo;
+    reservation: ReservationRepo;
+    task: TaskRepo;
+}) => Promise<IUseReservationAction>;

package/lib/chevre/service/reserve/useReservation.js

@@ -0,0 +1,121 @@
+"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.useReservation = void 0;
+/**
+ * 予約サービス
+ */
+const factory = require("../../factory");
+const code_1 = require("../code");
+const factory_1 = require("./factory");
+const onReservationUsed_1 = require("./potentialActions/onReservationUsed");
+function verifyToken4reservation(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        const payload = yield (0, code_1.verifyToken)({
+            project: params.project,
+            agent: params.agent,
+            token: params.token
+        })({});
+        switch (payload.typeOf) {
+            case factory.order.OrderType.Order:
+                // 注文検索
+                const order = yield repos.order.findByOrderNumber({ orderNumber: payload.orderNumber });
+                // ステータス検証
+                switch (order.orderStatus) {
+                    case factory.orderStatus.OrderDelivered:
+                        break;
+                    default:
+                        throw new factory.errors.Argument('token', `invalid orderStatus '${order.orderStatus}'`);
+                }
+                const acceptedOffers = (Array.isArray(order.acceptedOffers)) ? order.acceptedOffers : [];
+                const reservationExistsInOrder = acceptedOffers.some((offer) => {
+                    return offer.itemOffered.typeOf === factory.reservationType.EventReservation
+                        && offer.itemOffered.id === params.reservationId;
+                });
+                if (!reservationExistsInOrder) {
+                    throw new factory.errors.NotFound('AcceptedOffer');
+                }
+                break;
+            default:
+                throw new factory.errors.NotImplemented(`Payload type ${payload.typeOf} not implemented`);
+        }
+    });
+}
+/**
+ * 予約使用
+ */
+// export function useReservation(actionAttributes: factory.action.consume.use.reservation.IAttributes) {
+function useReservation(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c;
+        const now = new Date();
+        // 予約検索
+        let reservation = yield repos.reservation.findById({ id: params.object.id });
+        // instrument?.tokenを検証
+        const token = (_a = params === null || params === void 0 ? void 0 : params.instrument) === null || _a === void 0 ? void 0 : _a.token;
+        if (typeof token === 'string') {
+            yield verifyToken4reservation({
+                project: { id: params.project.id },
+                agent: params.agent,
+                reservationId: params.object.id,
+                token
+            })({ order: repos.order });
+        }
+        // UseActionを作成する
+        const actionAttributes = Object.assign({ project: reservation.project, typeOf: factory.actionType.UseAction, agent: params.agent, instrument: Object.assign(Object.assign({}, (typeof token === 'string') ? { token } : undefined), {
+                typeOf: factory.action.check.token.ObjectType.Ticket
+            }), 
+            // どの予約を
+            // mask
+            object: [(0, factory_1.maskUnderName)(reservation)] }, (typeof ((_b = params.location) === null || _b === void 0 ? void 0 : _b.identifier) === 'string')
+            ? {
+                location: {
+                    typeOf: factory.placeType.Place,
+                    identifier: params.location.identifier
+                }
+            }
+            : undefined
+        // purpose: params.purpose
+        );
+        let action = yield repos.action.start(actionAttributes);
+        // ひとまず予約数:1に限定する
+        if (actionAttributes.object.length !== 1) {
+            throw new factory.errors.Argument('object', 'number of using reservations must be 1');
+        }
+        reservation = actionAttributes.object[0];
+        try {
+            reservation = (yield repos.reservation.attend({ id: reservation.id, now }));
+            // 使用日時がなければ追加
+            if (((_c = reservation.reservedTicket) === null || _c === void 0 ? void 0 : _c.dateUsed) === undefined) {
+                reservation = yield repos.reservation.updatePartiallyById({
+                    id: reservation.id,
+                    update: { 'reservedTicket.dateUsed': now }
+                });
+            }
+        }
+        catch (error) {
+            // actionにエラー結果を追加
+            try {
+                const actionError = Object.assign(Object.assign({}, error), { message: error.message, name: error.name });
+                yield repos.action.giveUp({ typeOf: action.typeOf, id: action.id, error: actionError });
+            }
+            catch (__) {
+                // 失敗したら仕方ない
+            }
+            throw error;
+        }
+        // アクション完了
+        action = (yield repos.action.complete({ typeOf: action.typeOf, id: action.id, result: {} }));
+        yield (0, onReservationUsed_1.onReservationUsed)(action, reservation)({ task: repos.task });
+        return action;
+    });
+}
+exports.useReservation = useReservation;

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

@@ -0,0 +1,9 @@
+/**
+ * 予約サービス
+ */
+import { maskUnderName } from './reserve/factory';
+import { cancelPendingReservation, cancelReservation } from './reserve/cancelReservation';
+import { checkInRerservation } from './reserve/checkInReservation';
+import { confirmReservation } from './reserve/confirmReservation';
+import { useReservation } from './reserve/useReservation';
+export { maskUnderName, cancelPendingReservation, cancelReservation, checkInRerservation, confirmReservation, useReservation };

package/lib/chevre/service/reserve.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useReservation = exports.confirmReservation = exports.checkInRerservation = exports.cancelReservation = exports.cancelPendingReservation = exports.maskUnderName = void 0;
+/**
+ * 予約サービス
+ */
+const factory_1 = require("./reserve/factory");
+Object.defineProperty(exports, "maskUnderName", { enumerable: true, get: function () { return factory_1.maskUnderName; } });
+const cancelReservation_1 = require("./reserve/cancelReservation");
+Object.defineProperty(exports, "cancelPendingReservation", { enumerable: true, get: function () { return cancelReservation_1.cancelPendingReservation; } });
+Object.defineProperty(exports, "cancelReservation", { enumerable: true, get: function () { return cancelReservation_1.cancelReservation; } });
+const checkInReservation_1 = require("./reserve/checkInReservation");
+Object.defineProperty(exports, "checkInRerservation", { enumerable: true, get: function () { return checkInReservation_1.checkInRerservation; } });
+const confirmReservation_1 = require("./reserve/confirmReservation");
+Object.defineProperty(exports, "confirmReservation", { enumerable: true, get: function () { return confirmReservation_1.confirmReservation; } });
+const useReservation_1 = require("./reserve/useReservation");
+Object.defineProperty(exports, "useReservation", { enumerable: true, get: function () { return useReservation_1.useReservation; } });

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

@@ -0,0 +1,31 @@
+"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 account_1 = require("../../repo/account");
+const accountAction_1 = require("../../repo/accountAction");
+const accountTransaction_1 = require("../../repo/accountTransaction");
+const AccountService = require("../account");
+// tslint:disable-next-line:no-single-line-block-comment
+/* istanbul ignore next */
+function call(data) {
+    return (settings) => __awaiter(this, void 0, void 0, function* () {
+        const accountRepo = new account_1.MongoRepository(settings.connection);
+        const accountActionRepo = new accountAction_1.MongoRepository(settings.connection);
+        const accountTransactionRepo = new accountTransaction_1.MongoRepository(settings.connection);
+        yield AccountService.transferMoney(data.actionAttributes)({
+            account: accountRepo,
+            accountAction: accountActionRepo,
+            accountTransaction: accountTransactionRepo
+        });
+    });
+}
+exports.call = call;

package/lib/chevre/service/task/aggregateScreeningEvent.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 event_1 = require("../../repo/event");
+const screeningEvent_1 = require("../../repo/itemAvailability/screeningEvent");
+const offer_1 = require("../../repo/offer");
+const place_1 = require("../../repo/place");
+const product_1 = require("../../repo/product");
+const project_1 = require("../../repo/project");
+const offer_2 = require("../../repo/rateLimit/offer");
+const reservation_1 = require("../../repo/reservation");
+const task_1 = require("../../repo/task");
+const AggregationService = require("../aggregation");
+/**
+ * タスク実行関数
+ */
+function call(data) {
+    return (settings) => __awaiter(this, void 0, void 0, function* () {
+        if (settings.redisClient === undefined) {
+            throw new factory.errors.Argument('settings', 'redisClient required');
+        }
+        yield AggregationService.event.aggregateScreeningEvent(data)({
+            event: new event_1.MongoRepository(settings.connection),
+            eventAvailability: new screeningEvent_1.RedisRepository(settings.redisClient),
+            offer: new offer_1.MongoRepository(settings.connection),
+            offerRateLimit: new offer_2.RedisRepository(settings.redisClient),
+            place: new place_1.MongoRepository(settings.connection),
+            product: new product_1.MongoRepository(settings.connection),
+            project: new project_1.MongoRepository(settings.connection),
+            reservation: new reservation_1.MongoRepository(settings.connection),
+            task: new task_1.MongoRepository(settings.connection)
+        });
+    });
+}
+exports.call = call;