@chevre/domain 20.2.0-alpha.2 → 20.2.0-alpha.21

package/example/src/chevre/aggregateEventReservation.ts

@@ -0,0 +1,37 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+import * as redis from 'redis';
+
+import { chevre } from '../../../lib/index';
+
+// const project = { id: <string>process.env.PROJECT_ID };
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI);
+    const client = redis.createClient({
+        host: process.env.REDIS_HOST,
+        port: Number(process.env.REDIS_PORT),
+        password: process.env.REDIS_KEY
+    });
+
+    // const now = new Date();
+    await chevre.service.aggregation.event.aggregateScreeningEvent({
+        id: 'alb35u7m4'
+    })({
+        event: new chevre.repository.Event(mongoose.connection),
+        eventAvailability: new chevre.repository.itemAvailability.ScreeningEvent(client),
+        offer: new chevre.repository.Offer(mongoose.connection),
+        offerRateLimit: new chevre.repository.rateLimit.Offer(client),
+        place: new chevre.repository.Place(mongoose.connection),
+        product: new chevre.repository.Product(mongoose.connection),
+        project: new chevre.repository.Project(mongoose.connection),
+        reservation: new chevre.repository.Reservation(mongoose.connection),
+        task: new chevre.repository.Task(mongoose.connection)
+    });
+}
+
+main()
+    .then(() => {
+        console.log('success!');
+    })
+    .catch(console.error);

package/example/src/chevre/aggregation/aggregateSystem.ts

@@ -0,0 +1,82 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../../lib/index';
+
+// const project = { id: <string>process.env.PROJECT_ID };
+const EXCLUDED_PROJECT_ID = process.env.EXCLUDED_PROJECT_ID;
+const AGGREGATE_DAYS = Number(process.env.AGGREGATE_DAYS);
+const AGGREGATE_CLIENT_IDS = (typeof process.env.AGGREGATE_CLIENT_IDS === 'string') ? process.env.AGGREGATE_CLIENT_IDS.split(',') : [];
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const aggregationRepo = new chevre.repository.Aggregation(mongoose.connection);
+    const transactionRepo = new chevre.repository.Transaction(mongoose.connection);
+    const reservationRepo = new chevre.repository.Reservation(mongoose.connection);
+    const orderRepo = new chevre.repository.Order(mongoose.connection);
+    const actionRepo = new chevre.repository.Action(mongoose.connection);
+
+    await chevre.service.aggregation.system.aggregatePlaceOrder({
+        aggregationDays: AGGREGATE_DAYS,
+        excludedProjectId: EXCLUDED_PROJECT_ID,
+        clientIds: AGGREGATE_CLIENT_IDS
+    })({
+        agregation: aggregationRepo,
+        transaction: transactionRepo
+    });
+
+    await chevre.service.aggregation.system.aggregateAuthorizeOrderAction({
+        aggregationDays: AGGREGATE_DAYS,
+        excludedProjectId: EXCLUDED_PROJECT_ID
+    })({
+        agregation: aggregationRepo,
+        action: actionRepo
+    });
+
+    await chevre.service.aggregation.system.aggregateAuthorizeEventServiceOfferAction({
+        aggregationDays: AGGREGATE_DAYS,
+        excludedProjectId: EXCLUDED_PROJECT_ID
+    })({
+        agregation: aggregationRepo,
+        action: actionRepo
+    });
+
+    await chevre.service.aggregation.system.aggregateAuthorizePaymentAction({
+        aggregationDays: AGGREGATE_DAYS,
+        excludedProjectId: EXCLUDED_PROJECT_ID
+    })({
+        agregation: aggregationRepo,
+        action: actionRepo
+    });
+
+    await chevre.service.aggregation.system.aggregateUseAction({
+        aggregationDays: AGGREGATE_DAYS,
+        excludedProjectId: EXCLUDED_PROJECT_ID
+    })({
+        agregation: aggregationRepo,
+        action: actionRepo
+    });
+
+    await chevre.service.aggregation.system.aggregateOrder({
+        aggregationDays: AGGREGATE_DAYS,
+        excludedProjectId: EXCLUDED_PROJECT_ID
+    })({
+        agregation: aggregationRepo,
+        order: orderRepo
+    });
+
+    await chevre.service.aggregation.system.aggregateReservation({
+        aggregationDays: AGGREGATE_DAYS,
+        excludedProjectId: EXCLUDED_PROJECT_ID
+    })({
+        agregation: aggregationRepo,
+        reservation: reservationRepo
+    });
+}
+
+main()
+    .then(() => {
+        console.log('success!');
+    })
+    .catch(console.error);

package/example/src/chevre/importEventsFromCOA.ts

@@ -14,6 +14,7 @@ async function main() {
     const categoryCodeRepo = new chevre.repository.CategoryCode(mongoose.connection);
     const eventRepo = new chevre.repository.Event(mongoose.connection);
     const placeRepo = new chevre.repository.Place(mongoose.connection);
+    const sellerRepo = new chevre.repository.Seller(mongoose.connection);
 
     await chevre.service.event.importFromCOA({
         project: {
@@ -28,7 +29,13 @@ async function main() {
             .toDate(),
         saveMovieTheater: false,
         saveScreeningEventSeries: false
-    })({ action: actionRepo, categoryCode: categoryCodeRepo, event: eventRepo, place: placeRepo });
+    })({
+        action: actionRepo,
+        categoryCode: categoryCodeRepo,
+        event: eventRepo,
+        place: placeRepo,
+        seller: sellerRepo
+    });
     console.log('imported');
 }
 

package/example/src/chevre/migrateEventOffersItemOfferedAvailableChannel.ts

@@ -0,0 +1,90 @@
+// tslint:disable:no-console
+import * as moment from 'moment';
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+// const project = { id: String(process.env.PROJECT_ID) };
+
+const EXCLUDED_PROJECT_ID = process.env.EXCLUDED_PROJECT_ID;
+
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI);
+
+    const eventRepo = new chevre.repository.Event(mongoose.connection);
+
+    const cursor = eventRepo.getCursor(
+        {
+            // 'project.id': { $eq: project.id },
+            'project.id': { $ne: EXCLUDED_PROJECT_ID },
+            typeOf: { $eq: chevre.factory.eventType.ScreeningEvent },
+            startDate: {
+                $gte: moment()
+                    // tslint:disable-next-line:no-magic-numbers
+                    .add(-6, 'months')
+                    .toDate()
+            }
+            // _id: { $eq: 'al6aff83w' }
+        },
+        {
+            // _id: 1,
+        }
+    );
+    console.log('events found');
+
+    let i = 0;
+    let updateCount = 0;
+    await cursor.eachAsync(async (doc) => {
+        i += 1;
+        const event: chevre.factory.event.screeningEvent.IEvent = doc.toObject();
+
+        const eventOffers = <chevre.factory.event.screeningEvent.IOffer | undefined>event.offers;
+        if (eventOffers === undefined) {
+            throw new Error('event.offers undefined');
+        }
+
+        const availableChannel = eventOffers.itemOffered.availableChannel;
+
+        const alreadyMigrated = availableChannel?.typeOf === 'ServiceChannel';
+
+        if (alreadyMigrated) {
+            console.log(
+                'already exist...', event.project.id, event.id, event.startDate, availableChannel.serviceLocation.branchCode, i);
+        } else {
+            const newAvailableChannel: chevre.factory.reservation.IServiceChannel = {
+                typeOf: 'ServiceChannel',
+                serviceLocation: {
+                    typeOf: event.location.typeOf,
+                    branchCode: event.location.branchCode,
+                    name: event.location.name,
+                    containedInPlace: {
+                        typeOf: event.superEvent.location.typeOf,
+                        id: event.superEvent.location.id,
+                        branchCode: event.superEvent.location.branchCode,
+                        name: event.superEvent.location.name
+                    }
+                }
+            };
+            console.log(
+                'updating seller...', event.project.id, event.id, event.startDate, newAvailableChannel.serviceLocation.branchCode, i);
+            await eventRepo.updatePartiallyById({
+                id: event.id,
+                attributes: <any>{
+                    typeOf: event.typeOf,
+                    'offers.itemOffered.availableChannel': newAvailableChannel
+                }
+            });
+            updateCount += 1;
+            console.log(
+                'updated...', event.project.id, event.id, event.startDate, i);
+        }
+    });
+
+    console.log(i, 'events checked');
+    console.log(updateCount, 'events updated');
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/migrateEventOffersItemOfferedTypeOf.ts

@@ -5,11 +5,6 @@ import * as mongoose from 'mongoose';
 import { chevre } from '../../../lib/index';
 
 // const project = { id: String(process.env.PROJECT_ID) };
-
-const POS_CLIENT_ID = process.env.POS_CLIENT_ID;
-if (typeof POS_CLIENT_ID !== 'string') {
-    throw new Error('set POS_CLIENT_ID');
-}
 const EXCLUDED_PROJECT_ID = process.env.EXCLUDED_PROJECT_ID;
 
 // tslint:disable-next-line:max-func-body-length

package/example/src/chevre/migratePaymentServicePaymentUrlExpiresInSeconds.ts

@@ -0,0 +1,77 @@
+// tslint:disable:no-console
+// import * as moment from 'moment';
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+// const project = { id: String(process.env.PROJECT_ID) };
+const EXCLUDED_PROJECT_ID = process.env.EXCLUDED_PROJECT_ID;
+
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const productRepo = new chevre.repository.Product(mongoose.connection);
+
+    const cursor = productRepo.getCursor(
+        {
+            // 'project.id': { $eq: project.id },
+            'project.id': { $ne: EXCLUDED_PROJECT_ID },
+            typeOf: { $eq: chevre.factory.service.paymentService.PaymentServiceType.CreditCard }
+        },
+        {
+            // _id: 1,
+        }
+    );
+    console.log('products found');
+
+    let i = 0;
+    let updateCount = 0;
+    // tslint:disable-next-line:max-func-body-length
+    await cursor.eachAsync(async (doc) => {
+        i += 1;
+        const paymentService: chevre.factory.service.paymentService.IService = doc.toObject();
+
+        const hasPaymentUrlExpiresInseconds = paymentService.provider?.some((provider) => {
+            return typeof (<any>provider).credentials?.paymentUrlExpiresInSeconds === 'number';
+        });
+
+        if (!hasPaymentUrlExpiresInseconds) {
+            console.log(
+                'no expiresInSeconds', paymentService.project.id, paymentService.id, paymentService.productID, i);
+
+            return;
+        }
+
+        const alreadyMigrated = paymentService.provider?.filter((provider) => {
+            return typeof (<any>provider).credentials?.paymentUrlExpiresInSeconds === 'number';
+        })
+            .every((provider) => {
+                return typeof provider.credentials?.paymentUrl?.expiresInSeconds === 'number';
+            });
+
+        if (alreadyMigrated) {
+            console.log(
+                'already exist...', paymentService.project.id, paymentService.id, paymentService.productID, i);
+        } else {
+            console.log(
+                'updating product...', paymentService.project.id, paymentService.id, paymentService.productID, i);
+            // await eventRepo.updatePartiallyById({
+            //     id: event.id,
+            //     attributes: <any>{
+            //         typeOf: event.typeOf,
+            //         'offers.itemOffered.availableChannel': newAvailableChannel
+            //     }
+            // });
+            updateCount += 1;
+            console.log(
+                'updated...', paymentService.project.id, paymentService.id, paymentService.productID, i);
+        }
+    });
+    console.log(i, 'products checked');
+    console.log(updateCount, 'products updated');
+}
+
+main()
+    .then()
+    .catch(console.error);

package/lib/chevre/repo/action.d.ts

@@ -7,6 +7,23 @@ export interface IUseActionCountByOffer {
     _id: string[];
     useActionCount?: number;
 }
+interface IAggregationByStatus {
+    actionCount: number;
+    avgDuration: number;
+    maxDuration: number;
+    minDuration: number;
+    percentilesDuration: {
+        name: string;
+        value: number;
+    }[];
+}
+interface IStatus {
+    status: factory.actionStatusType;
+    aggregation: IAggregationByStatus;
+}
+interface IAggregateAction {
+    statuses: IStatus[];
+}
 export { modelName };
 /**
  * アクションリポジトリ
@@ -107,4 +124,45 @@ export declare class MongoRepository {
     deleteEndDatePassedCertainPeriod(params: {
         $lt: Date;
     }): Promise<void>;
+    aggregateAuthorizeEventServiceOfferAction(params: {
+        project?: {
+            id?: {
+                $ne?: string;
+            };
+        };
+        startFrom: Date;
+        startThrough: Date;
+        typeOf: factory.actionType;
+    }): Promise<IAggregateAction>;
+    aggregateAuthorizePaymentAction(params: {
+        project?: {
+            id?: {
+                $ne?: string;
+            };
+        };
+        startFrom: Date;
+        startThrough: Date;
+        typeOf: factory.actionType;
+    }): Promise<IAggregateAction>;
+    aggregateAuthorizeOrderAction(params: {
+        project?: {
+            id?: {
+                $ne?: string;
+            };
+        };
+        startFrom: Date;
+        startThrough: Date;
+        typeOf: factory.actionType;
+    }): Promise<IAggregateAction>;
+    aggregateUseAction(params: {
+        project?: {
+            id?: {
+                $ne?: string;
+            };
+        };
+        startFrom: Date;
+        startThrough: Date;
+        typeOf: factory.actionType;
+    }): Promise<IAggregateAction>;
+    private agggregateByStatus;
 }

package/lib/chevre/repo/action.js

@@ -677,5 +677,192 @@ class MongoRepository {
                 .exec();
         });
     }
+    aggregateAuthorizeEventServiceOfferAction(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const statuses = yield Promise.all([
+                factory.actionStatusType.CompletedActionStatus,
+                factory.actionStatusType.CanceledActionStatus,
+                factory.actionStatusType.FailedActionStatus
+            ].map((actionStatus) => __awaiter(this, void 0, void 0, function* () {
+                var _a, _b;
+                const matchConditions = Object.assign({ startDate: {
+                        $gte: params.startFrom,
+                        $lte: params.startThrough
+                    }, typeOf: { $eq: params.typeOf }, actionStatus: { $eq: actionStatus }, 'object.typeOf': {
+                        $exists: true,
+                        $eq: factory.action.authorize.offer.seatReservation.ObjectType.SeatReservation
+                    } }, (typeof ((_b = (_a = params.project) === null || _a === void 0 ? void 0 : _a.id) === null || _b === void 0 ? void 0 : _b.$ne) === 'string')
+                    ? { 'project.id': { $ne: params.project.id.$ne } }
+                    : undefined);
+                return this.agggregateByStatus({ matchConditions, actionStatus });
+            })));
+            return { statuses };
+        });
+    }
+    aggregateAuthorizePaymentAction(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const statuses = yield Promise.all([
+                factory.actionStatusType.CompletedActionStatus,
+                factory.actionStatusType.CanceledActionStatus,
+                factory.actionStatusType.FailedActionStatus
+            ].map((actionStatus) => __awaiter(this, void 0, void 0, function* () {
+                var _a, _b;
+                const matchConditions = Object.assign({ startDate: {
+                        $gte: params.startFrom,
+                        $lte: params.startThrough
+                    }, typeOf: { $eq: params.typeOf }, actionStatus: { $eq: actionStatus }, 'object.typeOf': {
+                        $exists: true,
+                        $eq: factory.action.authorize.paymentMethod.any.ResultType.Payment
+                    } }, (typeof ((_b = (_a = params.project) === null || _a === void 0 ? void 0 : _a.id) === null || _b === void 0 ? void 0 : _b.$ne) === 'string')
+                    ? { 'project.id': { $ne: params.project.id.$ne } }
+                    : undefined);
+                return this.agggregateByStatus({ matchConditions, actionStatus });
+            })));
+            return { statuses };
+        });
+    }
+    aggregateAuthorizeOrderAction(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const statuses = yield Promise.all([
+                factory.actionStatusType.CompletedActionStatus,
+                factory.actionStatusType.CanceledActionStatus,
+                factory.actionStatusType.FailedActionStatus
+            ].map((actionStatus) => __awaiter(this, void 0, void 0, function* () {
+                var _a, _b;
+                const matchConditions = Object.assign({ startDate: {
+                        $gte: params.startFrom,
+                        $lte: params.startThrough
+                    }, typeOf: { $eq: params.typeOf }, actionStatus: { $eq: actionStatus }, 'object.typeOf': {
+                        $exists: true,
+                        $eq: factory.order.OrderType.Order
+                    } }, (typeof ((_b = (_a = params.project) === null || _a === void 0 ? void 0 : _a.id) === null || _b === void 0 ? void 0 : _b.$ne) === 'string')
+                    ? { 'project.id': { $ne: params.project.id.$ne } }
+                    : undefined);
+                return this.agggregateByStatus({ matchConditions, actionStatus });
+            })));
+            return { statuses };
+        });
+    }
+    aggregateUseAction(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const statuses = yield Promise.all([
+                factory.actionStatusType.CompletedActionStatus,
+                factory.actionStatusType.CanceledActionStatus,
+                factory.actionStatusType.FailedActionStatus
+            ].map((actionStatus) => __awaiter(this, void 0, void 0, function* () {
+                var _a, _b;
+                const matchConditions = Object.assign({ startDate: {
+                        $gte: params.startFrom,
+                        $lte: params.startThrough
+                    }, typeOf: { $eq: params.typeOf }, actionStatus: { $eq: actionStatus } }, (typeof ((_b = (_a = params.project) === null || _a === void 0 ? void 0 : _a.id) === null || _b === void 0 ? void 0 : _b.$ne) === 'string')
+                    ? { 'project.id': { $ne: params.project.id.$ne } }
+                    : undefined);
+                return this.agggregateByStatus({ matchConditions, actionStatus });
+            })));
+            return { statuses };
+        });
+    }
+    // tslint:disable-next-line:max-func-body-length
+    agggregateByStatus(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const aggregations = yield this.actionModel.aggregate([
+                { $match: params.matchConditions },
+                {
+                    $project: {
+                        duration: { $subtract: ['$endDate', '$startDate'] },
+                        actionStatus: '$actionStatus',
+                        startDate: '$startDate',
+                        endDate: '$endDate',
+                        typeOf: '$typeOf'
+                    }
+                },
+                {
+                    $group: {
+                        _id: '$typeOf',
+                        actionCount: { $sum: 1 },
+                        maxDuration: { $max: '$duration' },
+                        minDuration: { $min: '$duration' },
+                        avgDuration: { $avg: '$duration' }
+                    }
+                },
+                {
+                    $project: {
+                        _id: 0,
+                        actionCount: '$actionCount',
+                        avgDuration: '$avgDuration',
+                        maxDuration: '$maxDuration',
+                        minDuration: '$minDuration'
+                    }
+                }
+            ])
+                .exec();
+            // tslint:disable-next-line:no-magic-numbers
+            const percents = [50, 95, 99];
+            if (aggregations.length === 0) {
+                return {
+                    status: params.actionStatus,
+                    aggregation: {
+                        actionCount: 0,
+                        avgDuration: 0,
+                        maxDuration: 0,
+                        minDuration: 0,
+                        percentilesDuration: percents.map((percent) => {
+                            return {
+                                name: String(percent),
+                                value: 0
+                            };
+                        })
+                    }
+                };
+            }
+            const ranks4percentile = percents.map((percentile) => {
+                return {
+                    percentile,
+                    // tslint:disable-next-line:no-magic-numbers
+                    rank: Math.floor(aggregations[0].actionCount * percentile / 100)
+                };
+            });
+            const aggregations2 = yield this.actionModel.aggregate([
+                {
+                    $match: params.matchConditions
+                },
+                {
+                    $project: {
+                        duration: { $subtract: ['$endDate', '$startDate'] },
+                        actionStatus: '$actionStatus',
+                        startDate: '$startDate',
+                        endDate: '$endDate',
+                        typeOf: '$typeOf'
+                    }
+                },
+                { $sort: { duration: 1 } },
+                {
+                    $group: {
+                        _id: '$typeOf',
+                        durations: { $push: '$duration' }
+                    }
+                },
+                {
+                    $project: {
+                        _id: 0,
+                        avgSmallDuration: '$avgSmallDuration',
+                        avgMediumDuration: '$avgMediumDuration',
+                        avgLargeDuration: '$avgLargeDuration',
+                        percentilesDuration: ranks4percentile.map((rank) => {
+                            return {
+                                name: String(rank.percentile),
+                                value: { $arrayElemAt: ['$durations', rank.rank] }
+                            };
+                        })
+                    }
+                }
+            ])
+                .exec();
+            return {
+                status: params.actionStatus,
+                aggregation: Object.assign(Object.assign({}, aggregations[0]), aggregations2[0])
+            };
+        });
+    }
 }
 exports.MongoRepository = MongoRepository;

package/lib/chevre/repo/aggregation.d.ts

@@ -0,0 +1,34 @@
+import { Connection, Model } from 'mongoose';
+import * as factory from '../factory';
+export declare enum AggregationType {
+    AggregatePlaceOrder = "AggregatePlaceOrder",
+    AggregateAuthorizeEventServiceOfferAction = "AggregateAuthorizeEventServiceOfferAction",
+    AggregateAuthorizeOrderAction = "AggregateAuthorizeOrderAction",
+    AggregateAuthorizePaymentAction = "AggregateAuthorizePaymentAction",
+    AggregateOrder = "AggregateOrder",
+    AggregateReservation = "AggregateReservation",
+    AggregateUseAction = "AggregateUseAction"
+}
+export interface IAggregationByClient {
+    clientId: string;
+    aggregation: any;
+}
+export interface IAggregation {
+    typeOf: AggregationType;
+    project: {
+        id: string;
+        typeOf: factory.organizationType.Project;
+    };
+    aggregateDate: Date;
+    aggregateDuration: string;
+    aggregateStart: Date;
+    aggregationByClient?: IAggregationByClient[];
+}
+/**
+ * 集計リポジトリ
+ */
+export declare class MongoRepository {
+    readonly aggregationModel: typeof Model;
+    constructor(connection: Connection);
+    saveAggregation(params: IAggregation): Promise<any>;
+}

package/lib/chevre/repo/aggregation.js

@@ -0,0 +1,64 @@
+"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 __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoRepository = exports.AggregationType = void 0;
+const aggregation_1 = require("./mongoose/model/aggregation");
+var AggregationType;
+(function (AggregationType) {
+    AggregationType["AggregatePlaceOrder"] = "AggregatePlaceOrder";
+    AggregationType["AggregateAuthorizeEventServiceOfferAction"] = "AggregateAuthorizeEventServiceOfferAction";
+    AggregationType["AggregateAuthorizeOrderAction"] = "AggregateAuthorizeOrderAction";
+    AggregationType["AggregateAuthorizePaymentAction"] = "AggregateAuthorizePaymentAction";
+    AggregationType["AggregateOrder"] = "AggregateOrder";
+    AggregationType["AggregateReservation"] = "AggregateReservation";
+    AggregationType["AggregateUseAction"] = "AggregateUseAction";
+})(AggregationType = exports.AggregationType || (exports.AggregationType = {}));
+/**
+ * 集計リポジトリ
+ */
+class MongoRepository {
+    constructor(connection) {
+        this.aggregationModel = connection.model(aggregation_1.modelName);
+    }
+    saveAggregation(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { typeOf, project, aggregateDuration, aggregateStart } = params, setFields = __rest(params, ["typeOf", "project", "aggregateDuration", "aggregateStart"]);
+            const doc = yield this.aggregationModel.findOneAndUpdate({
+                typeOf: { $eq: params.typeOf },
+                'project.id': { $eq: params.project.id },
+                aggregateStart: { $eq: params.aggregateStart },
+                aggregateDuration: { $eq: params.aggregateDuration }
+            }, {
+                $setOnInsert: {
+                    typeOf: params.typeOf,
+                    project: params.project,
+                    aggregateDuration: params.aggregateDuration,
+                    aggregateStart: params.aggregateStart
+                },
+                $set: setFields
+            }, { upsert: true, new: true })
+                .exec();
+            return doc.toObject();
+        });
+    }
+}
+exports.MongoRepository = MongoRepository;