@chevre/domain 20.2.0-alpha.18 → 20.2.0-alpha.19

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

@@ -0,0 +1,72 @@
+// 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);
+
+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
+    })({
+        agregation: aggregationRepo,
+        transaction: transactionRepo
+    });
+
+    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/lib/chevre/repo/action.d.ts

@@ -144,5 +144,15 @@ export declare class MongoRepository {
         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

@@ -680,8 +680,8 @@ class MongoRepository {
     aggregateAuthorizeEventServiceOfferAction(params) {
         return __awaiter(this, void 0, void 0, function* () {
             const statuses = yield Promise.all([
-                factory.actionStatusType.CanceledActionStatus,
                 factory.actionStatusType.CompletedActionStatus,
+                factory.actionStatusType.CanceledActionStatus,
                 factory.actionStatusType.FailedActionStatus
             ].map((actionStatus) => __awaiter(this, void 0, void 0, function* () {
                 var _a, _b;
@@ -702,8 +702,8 @@ class MongoRepository {
     aggregateAuthorizePaymentAction(params) {
         return __awaiter(this, void 0, void 0, function* () {
             const statuses = yield Promise.all([
-                factory.actionStatusType.CanceledActionStatus,
                 factory.actionStatusType.CompletedActionStatus,
+                factory.actionStatusType.CanceledActionStatus,
                 factory.actionStatusType.FailedActionStatus
             ].map((actionStatus) => __awaiter(this, void 0, void 0, function* () {
                 var _a, _b;
@@ -721,6 +721,25 @@ class MongoRepository {
             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* () {

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

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

package/lib/chevre/repo/aggregation.js

@@ -1,7 +1,36 @@
 "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 = void 0;
+exports.MongoRepository = exports.AggregationType = void 0;
 const aggregation_1 = require("./mongoose/model/aggregation");
+var AggregationType;
+(function (AggregationType) {
+    AggregationType["AggregatePlaceOrder"] = "AggregatePlaceOrder";
+    AggregationType["AggregateAuthorizeEventServiceOfferAction"] = "AggregateAuthorizeEventServiceOfferAction";
+    AggregationType["AggregateAuthorizePaymentAction"] = "AggregateAuthorizePaymentAction";
+    AggregationType["AggregateOrder"] = "AggregateOrder";
+    AggregationType["AggregateReservation"] = "AggregateReservation";
+    AggregationType["AggregateUseAction"] = "AggregateUseAction";
+})(AggregationType = exports.AggregationType || (exports.AggregationType = {}));
 /**
  * 集計リポジトリ
  */
@@ -9,5 +38,26 @@ 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;

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

@@ -84,5 +84,5 @@ export declare class MongoRepository {
         maxPrice: number;
         minPrice: number;
         avgPrice: number;
-    }[]>;
+    }>;
 }

package/lib/chevre/repo/order.js

@@ -923,7 +923,7 @@ class MongoRepository {
     aggregateOrder(params) {
         var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
-            return this.orderModel.aggregate([
+            const aggregations = yield this.orderModel.aggregate([
                 {
                     $match: {
                         orderDate: {
@@ -951,9 +951,22 @@ class MongoRepository {
                         minPrice: { $min: '$price' },
                         avgPrice: { $avg: '$price' }
                     }
+                },
+                {
+                    $project: {
+                        _id: 0,
+                        acceptedOfferCount: '$acceptedOfferCount',
+                        avgAcceptedOfferCount: '$avgAcceptedOfferCount',
+                        orderCount: '$orderCount',
+                        totalPrice: '$totalPrice',
+                        maxPrice: '$maxPrice',
+                        minPrice: '$minPrice',
+                        avgPrice: '$avgPrice'
+                    }
                 }
             ])
                 .exec();
+            return aggregations[0];
         });
     }
 }

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

@@ -146,5 +146,15 @@ export declare class MongoRepository {
     findByIdAndDelete(params: {
         id: string;
     }): Promise<void>;
-    aggregatePlaceOrder(params: factory.transaction.placeOrder.ISearchConditions): Promise<IAggregatePlaceOrder>;
+    aggregatePlaceOrder(params: {
+        project?: {
+            id?: {
+                $ne?: string;
+            };
+        };
+        startFrom: Date;
+        startThrough: Date;
+        typeOf: factory.transactionType;
+    }): Promise<IAggregatePlaceOrder>;
+    private agggregateByStatus;
 }

package/lib/chevre/repo/transaction.js

@@ -600,140 +600,129 @@ class MongoRepository {
                 .exec();
         });
     }
-    // tslint:disable-next-line:max-func-body-length
     aggregatePlaceOrder(params) {
         return __awaiter(this, void 0, void 0, function* () {
             const statuses = yield Promise.all([
                 factory.transactionStatusType.Canceled,
                 factory.transactionStatusType.Expired,
                 factory.transactionStatusType.Confirmed
-                // tslint:disable-next-line:max-func-body-length
             ].map((transactionStatus) => __awaiter(this, void 0, void 0, function* () {
-                var _a, _b, _c, _d;
-                const matchConditions = {
-                    'project.id': Object.assign({}, (typeof ((_b = (_a = params.project) === null || _a === void 0 ? void 0 : _a.id) === null || _b === void 0 ? void 0 : _b.$ne) === 'string')
-                        ? { $ne: (_d = (_c = params.project) === null || _c === void 0 ? void 0 : _c.id) === null || _d === void 0 ? void 0 : _d.$ne }
-                        : undefined),
-                    startDate: {
+                var _a, _b;
+                const matchConditions = Object.assign({ startDate: {
                         $gte: params.startFrom,
                         $lte: params.startThrough
-                    },
-                    typeOf: { $eq: params.typeOf },
-                    status: {
-                        $in: [transactionStatus]
+                    }, typeOf: { $eq: params.typeOf }, status: { $eq: transactionStatus } }, (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, status: transactionStatus });
+            })));
+            return { statuses };
+        });
+    }
+    // tslint:disable-next-line:max-func-body-length
+    agggregateByStatus(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const matchConditions = params.matchConditions;
+            const transactionStatus = params.status;
+            const aggregations = yield this.transactionModel.aggregate([
+                {
+                    $match: matchConditions
+                },
+                {
+                    $project: {
+                        duration: { $subtract: ['$endDate', '$startDate'] },
+                        status: '$status',
+                        startDate: '$startDate',
+                        endDate: '$endDate',
+                        typeOf: '$typeOf'
                     }
-                };
-                const aggregations = yield this.transactionModel.aggregate([
-                    {
-                        $match: matchConditions
-                    },
-                    {
-                        $project: {
-                            duration: {
-                                $subtract: ['$endDate', '$startDate']
-                            },
-                            status: '$status',
-                            startDate: '$startDate',
-                            endDate: '$endDate',
-                            typeOf: '$typeOf'
-                        }
-                    },
-                    {
-                        $group: {
-                            _id: '$typeOf',
-                            transactionCount: { $sum: 1 },
-                            maxDuration: {
-                                $max: '$duration'
-                            },
-                            minDuration: {
-                                $min: '$duration'
-                            },
-                            avgDuration: {
-                                $avg: '$duration'
-                            }
-                        }
-                    },
-                    {
-                        $project: {
-                            _id: 0,
-                            transactionCount: '$transactionCount',
-                            avgDuration: '$avgDuration',
-                            maxDuration: '$maxDuration',
-                            minDuration: '$minDuration'
-                        }
+                },
+                {
+                    $group: {
+                        _id: '$typeOf',
+                        transactionCount: { $sum: 1 },
+                        maxDuration: { $max: '$duration' },
+                        minDuration: { $min: '$duration' },
+                        avgDuration: { $avg: '$duration' }
                     }
-                ])
-                    .exec();
-                // tslint:disable-next-line:no-magic-numbers
-                const percents = [50, 95, 99];
-                if (aggregations.length === 0) {
-                    return {
-                        status: transactionStatus,
-                        aggregation: {
-                            transactionCount: 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].transactionCount * percentile / 100)
-                    };
-                });
-                const aggregations2 = yield this.transactionModel.aggregate([
-                    {
-                        $match: matchConditions
-                    },
-                    {
-                        $project: {
-                            duration: {
-                                $subtract: ['$endDate', '$startDate']
-                            },
-                            status: '$status',
-                            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] }
-                                };
-                            })
-                        }
+                },
+                {
+                    $project: {
+                        _id: 0,
+                        transactionCount: '$transactionCount',
+                        avgDuration: '$avgDuration',
+                        maxDuration: '$maxDuration',
+                        minDuration: '$minDuration'
                     }
-                ])
-                    .exec();
+                }
+            ])
+                .exec();
+            // tslint:disable-next-line:no-magic-numbers
+            const percents = [50, 95, 99];
+            if (aggregations.length === 0) {
                 return {
                     status: transactionStatus,
-                    aggregation: Object.assign(Object.assign({}, aggregations[0]), aggregations2[0])
+                    aggregation: {
+                        transactionCount: 0,
+                        avgDuration: 0,
+                        maxDuration: 0,
+                        minDuration: 0,
+                        percentilesDuration: percents.map((percent) => {
+                            return {
+                                name: String(percent),
+                                value: 0
+                            };
+                        })
+                    }
                 };
-            })));
-            return { statuses };
+            }
+            const ranks4percentile = percents.map((percentile) => {
+                return {
+                    percentile,
+                    // tslint:disable-next-line:no-magic-numbers
+                    rank: Math.floor(aggregations[0].transactionCount * percentile / 100)
+                };
+            });
+            const aggregations2 = yield this.transactionModel.aggregate([
+                {
+                    $match: matchConditions
+                },
+                {
+                    $project: {
+                        duration: { $subtract: ['$endDate', '$startDate'] },
+                        status: '$status',
+                        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: transactionStatus,
+                aggregation: Object.assign(Object.assign({}, aggregations[0]), aggregations2[0])
+            };
         });
     }
 }

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

@@ -0,0 +1,66 @@
+import { MongoRepository as ActionRepo } from '../../repo/action';
+import { MongoRepository as AggregationRepo } from '../../repo/aggregation';
+import { MongoRepository as OrderRepo } from '../../repo/order';
+import { MongoRepository as ReservationRepo } from '../../repo/reservation';
+import { MongoRepository as TransactionRepo } from '../../repo/transaction';
+/**
+ * 注文取引集計
+ */
+declare function aggregatePlaceOrder(params: {
+    aggregationDays: number;
+    excludedProjectId?: string;
+}): (repos: {
+    agregation: AggregationRepo;
+    transaction: TransactionRepo;
+}) => Promise<void>;
+/**
+ * 興行オファー承認アクション集計
+ */
+declare function aggregateAuthorizeEventServiceOfferAction(params: {
+    aggregationDays: number;
+    excludedProjectId?: string;
+}): (repos: {
+    agregation: AggregationRepo;
+    action: ActionRepo;
+}) => Promise<void>;
+/**
+ * 決済承認アクション集計
+ */
+declare function aggregateAuthorizePaymentAction(params: {
+    aggregationDays: number;
+    excludedProjectId?: string;
+}): (repos: {
+    agregation: AggregationRepo;
+    action: ActionRepo;
+}) => Promise<void>;
+/**
+ * 使用アクション集計
+ */
+declare function aggregateUseAction(params: {
+    aggregationDays: number;
+    excludedProjectId?: string;
+}): (repos: {
+    agregation: AggregationRepo;
+    action: ActionRepo;
+}) => Promise<void>;
+/**
+ * 注文集計
+ */
+declare function aggregateOrder(params: {
+    aggregationDays: number;
+    excludedProjectId?: string;
+}): (repos: {
+    agregation: AggregationRepo;
+    order: OrderRepo;
+}) => Promise<void>;
+/**
+ * 予約集計
+ */
+declare function aggregateReservation(params: {
+    aggregationDays: number;
+    excludedProjectId?: string;
+}): (repos: {
+    agregation: AggregationRepo;
+    reservation: ReservationRepo;
+}) => Promise<void>;
+export { aggregateAuthorizeEventServiceOfferAction, aggregateAuthorizePaymentAction, aggregateOrder, aggregatePlaceOrder, aggregateReservation, aggregateUseAction };

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

@@ -0,0 +1,220 @@
+"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.aggregateUseAction = exports.aggregateReservation = exports.aggregatePlaceOrder = exports.aggregateOrder = exports.aggregateAuthorizePaymentAction = exports.aggregateAuthorizeEventServiceOfferAction = void 0;
+const createDebug = require("debug");
+const moment = require("moment-timezone");
+const factory = require("../../factory");
+const aggregation_1 = require("../../repo/aggregation");
+const debug = createDebug('chevre-domain:service:aggregation:system');
+/**
+ * 注文取引集計
+ */
+function aggregatePlaceOrder(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const aggregateDate = new Date();
+        const aggregateDuration = moment.duration(1, 'days')
+            .toISOString();
+        let i = -1;
+        while (i < params.aggregationDays) {
+            i += 1;
+            const startFrom = moment()
+                // .tz('Asia/Tokyo')
+                .add(-i, 'days')
+                .startOf('day')
+                .toDate();
+            const startThrough = moment()
+                // .tz('Asia/Tokyo')
+                .add(-i, 'days')
+                .endOf('day')
+                .toDate();
+            const aggregateResult = yield repos.transaction.aggregatePlaceOrder({
+                project: { id: { $ne: params.excludedProjectId } },
+                startFrom,
+                startThrough,
+                typeOf: factory.transactionType.PlaceOrder
+            });
+            debug('aggregatePlaceOrder:result', aggregateResult, (_a = aggregateResult.statuses[0]) === null || _a === void 0 ? void 0 : _a.aggregation.percentilesDuration, startFrom);
+            yield repos.agregation.saveAggregation(Object.assign({ typeOf: aggregation_1.AggregationType.AggregatePlaceOrder, project: { id: '*', typeOf: factory.organizationType.Project }, aggregateDuration, aggregateStart: startFrom, aggregateDate }, aggregateResult));
+        }
+    });
+}
+exports.aggregatePlaceOrder = aggregatePlaceOrder;
+/**
+ * 興行オファー承認アクション集計
+ */
+function aggregateAuthorizeEventServiceOfferAction(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const aggregateDate = new Date();
+        const aggregateDuration = moment.duration(1, 'days')
+            .toISOString();
+        let i = -1;
+        while (i < params.aggregationDays) {
+            i += 1;
+            const startFrom = moment()
+                // .tz('Asia/Tokyo')
+                .add(-i, 'days')
+                .startOf('day')
+                .toDate();
+            const startThrough = moment()
+                // .tz('Asia/Tokyo')
+                .add(-i, 'days')
+                .endOf('day')
+                .toDate();
+            const aggregateResult = yield repos.action.aggregateAuthorizeEventServiceOfferAction({
+                project: { id: { $ne: params.excludedProjectId } },
+                startFrom,
+                startThrough,
+                typeOf: factory.actionType.AuthorizeAction
+            });
+            debug('aggregateAuthorizeEventServiceOfferAction:result', aggregateResult, (_a = aggregateResult.statuses[0]) === null || _a === void 0 ? void 0 : _a.aggregation.percentilesDuration, startFrom);
+            yield repos.agregation.saveAggregation(Object.assign({ typeOf: aggregation_1.AggregationType.AggregateAuthorizeEventServiceOfferAction, project: { id: '*', typeOf: factory.organizationType.Project }, aggregateDuration, aggregateStart: startFrom, aggregateDate }, aggregateResult));
+        }
+    });
+}
+exports.aggregateAuthorizeEventServiceOfferAction = aggregateAuthorizeEventServiceOfferAction;
+/**
+ * 決済承認アクション集計
+ */
+function aggregateAuthorizePaymentAction(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const aggregateDate = new Date();
+        const aggregateDuration = moment.duration(1, 'days')
+            .toISOString();
+        let i = -1;
+        while (i < params.aggregationDays) {
+            i += 1;
+            const startFrom = moment()
+                // .tz('Asia/Tokyo')
+                .add(-i, 'days')
+                .startOf('day')
+                .toDate();
+            const startThrough = moment()
+                // .tz('Asia/Tokyo')
+                .add(-i, 'days')
+                .endOf('day')
+                .toDate();
+            const aggregateResult = yield repos.action.aggregateAuthorizePaymentAction({
+                project: { id: { $ne: params.excludedProjectId } },
+                startFrom,
+                startThrough,
+                typeOf: factory.actionType.AuthorizeAction
+            });
+            debug('aggregateAuthorizePaymentAction:result', aggregateResult, (_a = aggregateResult.statuses[0]) === null || _a === void 0 ? void 0 : _a.aggregation.percentilesDuration, startFrom);
+            yield repos.agregation.saveAggregation(Object.assign({ typeOf: aggregation_1.AggregationType.AggregateAuthorizePaymentAction, project: { id: '*', typeOf: factory.organizationType.Project }, aggregateDuration, aggregateStart: startFrom, aggregateDate }, aggregateResult));
+        }
+    });
+}
+exports.aggregateAuthorizePaymentAction = aggregateAuthorizePaymentAction;
+/**
+ * 使用アクション集計
+ */
+function aggregateUseAction(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const aggregateDate = new Date();
+        const aggregateDuration = moment.duration(1, 'days')
+            .toISOString();
+        let i = -1;
+        while (i < params.aggregationDays) {
+            i += 1;
+            const startFrom = moment()
+                // .tz('Asia/Tokyo')
+                .add(-i, 'days')
+                .startOf('day')
+                .toDate();
+            const startThrough = moment()
+                // .tz('Asia/Tokyo')
+                .add(-i, 'days')
+                .endOf('day')
+                .toDate();
+            const aggregateResult = yield repos.action.aggregateUseAction({
+                project: { id: { $ne: params.excludedProjectId } },
+                startFrom,
+                startThrough,
+                typeOf: factory.actionType.UseAction
+            });
+            debug('aggregateUseAction:result', aggregateResult, (_a = aggregateResult.statuses[0]) === null || _a === void 0 ? void 0 : _a.aggregation.percentilesDuration, startFrom);
+            yield repos.agregation.saveAggregation(Object.assign({ typeOf: aggregation_1.AggregationType.AggregateUseAction, project: { id: '*', typeOf: factory.organizationType.Project }, aggregateDuration, aggregateStart: startFrom, aggregateDate }, aggregateResult));
+        }
+    });
+}
+exports.aggregateUseAction = aggregateUseAction;
+/**
+ * 注文集計
+ */
+function aggregateOrder(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        const aggregateDate = new Date();
+        const aggregateDuration = moment.duration(1, 'days')
+            .toISOString();
+        let i = -1;
+        while (i < params.aggregationDays) {
+            i += 1;
+            const orderDateFrom = moment()
+                // .tz('Asia/Tokyo')
+                .add(-i, 'days')
+                .startOf('day')
+                .toDate();
+            const orderDateThrough = moment()
+                // .tz('Asia/Tokyo')
+                .add(-i, 'days')
+                .endOf('day')
+                .toDate();
+            const aggregateResult = yield repos.order.aggregateOrder({
+                orderDate: {
+                    $gte: orderDateFrom,
+                    $lte: orderDateThrough
+                }
+            });
+            debug('aggregateOrder:result', aggregateResult);
+            yield repos.agregation.saveAggregation(Object.assign({ typeOf: aggregation_1.AggregationType.AggregateOrder, project: { id: '*', typeOf: factory.organizationType.Project }, aggregateDuration, aggregateStart: orderDateFrom, aggregateDate }, aggregateResult));
+        }
+    });
+}
+exports.aggregateOrder = aggregateOrder;
+/**
+ * 予約集計
+ */
+function aggregateReservation(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        const aggregateDate = new Date();
+        const aggregateDuration = moment.duration(1, 'days')
+            .toISOString();
+        let i = -1;
+        while (i < params.aggregationDays) {
+            i += 1;
+            const bookingFrom = moment()
+                // .tz('Asia/Tokyo')
+                .add(-i, 'days')
+                .startOf('day')
+                .toDate();
+            const bookingThrough = moment()
+                // .tz('Asia/Tokyo')
+                .add(-i, 'days')
+                .endOf('day')
+                .toDate();
+            // i日前の予約検索
+            const reservationCount = yield repos.reservation.count({
+                typeOf: factory.reservationType.EventReservation,
+                reservationStatus: { $eq: factory.reservationStatusType.ReservationConfirmed },
+                bookingFrom,
+                bookingThrough
+            });
+            const aggregateResult = { reservationCount };
+            yield repos.agregation.saveAggregation(Object.assign({ typeOf: aggregation_1.AggregationType.AggregateReservation, project: { id: '*', typeOf: factory.organizationType.Project }, aggregateDuration, aggregateStart: bookingFrom, aggregateDate }, aggregateResult));
+        }
+    });
+}
+exports.aggregateReservation = aggregateReservation;

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

@@ -3,5 +3,7 @@
  */
 import * as EventAggregation from './aggregation/event';
 import * as ProjectAggregation from './aggregation/project';
+import * as SystemAggregation from './aggregation/system';
 export import event = EventAggregation;
 export import project = ProjectAggregation;
+export import system = SystemAggregation;

package/lib/chevre/service/aggregation.js

@@ -1,10 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.project = exports.event = void 0;
+exports.system = exports.project = exports.event = void 0;
 /**
  * 集計サービス
  */
 const EventAggregation = require("./aggregation/event");
 const ProjectAggregation = require("./aggregation/project");
+const SystemAggregation = require("./aggregation/system");
 exports.event = EventAggregation;
 exports.project = ProjectAggregation;
+exports.system = SystemAggregation;

package/package.json

@@ -120,5 +120,5 @@
     "postversion": "git push origin --tags",
     "prepublishOnly": "npm run clean && npm run build && npm test && npm run doc"
   },
-  "version": "20.2.0-alpha.18"
+  "version": "20.2.0-alpha.19"
 }

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

@@ -1,87 +0,0 @@
-// tslint:disable:no-console
-import * as moment from 'moment-timezone';
-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);
-
-interface IAggregation {
-    typeOf: 'AggregateAuthorizeEventServiceOfferAction';
-    project: { id: string; typeOf: chevre.factory.organizationType.Project };
-    aggregateDate: Date;
-    aggregateDuration: string;
-    aggregateStart: Date;
-}
-
-async function main() {
-    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
-
-    const now: Date = new Date();
-
-    const aggregationRepo = new chevre.repository.Aggregation(mongoose.connection);
-    const actionRepo = new chevre.repository.Action(mongoose.connection);
-
-    let i = 0;
-    // tslint:disable-next-line:no-magic-numbers
-    while (i < AGGREGATE_DAYS) {
-        i += 1;
-
-        const startFrom: Date = moment()
-            // .tz('Asia/Tokyo')
-            .add(-i, 'days')
-            .startOf('day')
-            .toDate();
-        const startThrough: Date = moment()
-            // .tz('Asia/Tokyo')
-            .add(-i, 'days')
-            .endOf('day')
-            .toDate();
-        const aggregateResult = await actionRepo.aggregateAuthorizeEventServiceOfferAction({
-            project: { id: <any>{ $ne: EXCLUDED_PROJECT_ID } },
-            startFrom,
-            startThrough,
-            typeOf: chevre.factory.actionType.AuthorizeAction
-        });
-        console.log('aggregateResult', aggregateResult, aggregateResult.statuses[0]?.aggregation.percentilesDuration, startFrom);
-
-        const aggregation: IAggregation = {
-            typeOf: 'AggregateAuthorizeEventServiceOfferAction',
-            project: { id: '*', typeOf: chevre.factory.organizationType.Project },
-            aggregateDuration: moment.duration(1, 'days')
-                .toISOString(),
-            aggregateStart: startFrom,
-            aggregateDate: now,
-            ...aggregateResult
-        };
-        const { typeOf, project, aggregateDuration, aggregateStart, ...setFields } = aggregation;
-        const doc = await aggregationRepo.aggregationModel.findOneAndUpdate(
-            {
-                typeOf: { $eq: aggregation.typeOf },
-                'project.id': { $eq: aggregation.project.id },
-                aggregateStart: { $eq: aggregation.aggregateStart },
-                aggregateDuration: { $eq: aggregation.aggregateDuration }
-            },
-            {
-                $setOnInsert: {
-                    typeOf: aggregation.typeOf,
-                    project: aggregation.project,
-                    aggregateDuration: aggregation.aggregateDuration,
-                    aggregateStart: aggregation.aggregateStart
-                },
-                $set: setFields
-            },
-            { upsert: true, new: true }
-        )
-            .exec();
-        console.log(doc);
-    }
-}
-
-main()
-    .then(() => {
-        console.log('success!');
-    })
-    .catch(console.error);

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

@@ -1,87 +0,0 @@
-// tslint:disable:no-console
-import * as moment from 'moment-timezone';
-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);
-
-interface IAggregation {
-    typeOf: 'AggregateAuthorizePaymentAction';
-    project: { id: string; typeOf: chevre.factory.organizationType.Project };
-    aggregateDate: Date;
-    aggregateDuration: string;
-    aggregateStart: Date;
-}
-
-async function main() {
-    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
-
-    const now: Date = new Date();
-
-    const aggregationRepo = new chevre.repository.Aggregation(mongoose.connection);
-    const actionRepo = new chevre.repository.Action(mongoose.connection);
-
-    let i = 0;
-    // tslint:disable-next-line:no-magic-numbers
-    while (i < AGGREGATE_DAYS) {
-        i += 1;
-
-        const startFrom: Date = moment()
-            // .tz('Asia/Tokyo')
-            .add(-i, 'days')
-            .startOf('day')
-            .toDate();
-        const startThrough: Date = moment()
-            // .tz('Asia/Tokyo')
-            .add(-i, 'days')
-            .endOf('day')
-            .toDate();
-        const aggregateResult = await actionRepo.aggregateAuthorizePaymentAction({
-            project: { id: <any>{ $ne: EXCLUDED_PROJECT_ID } },
-            startFrom,
-            startThrough,
-            typeOf: chevre.factory.actionType.AuthorizeAction
-        });
-        console.log('aggregateResult', aggregateResult, aggregateResult.statuses[0]?.aggregation.percentilesDuration, startFrom);
-
-        const aggregation: IAggregation = {
-            typeOf: 'AggregateAuthorizePaymentAction',
-            project: { id: '*', typeOf: chevre.factory.organizationType.Project },
-            aggregateDuration: moment.duration(1, 'days')
-                .toISOString(),
-            aggregateStart: startFrom,
-            aggregateDate: now,
-            ...aggregateResult
-        };
-        const { typeOf, project, aggregateDuration, aggregateStart, ...setFields } = aggregation;
-        const doc = await aggregationRepo.aggregationModel.findOneAndUpdate(
-            {
-                typeOf: { $eq: aggregation.typeOf },
-                'project.id': { $eq: aggregation.project.id },
-                aggregateStart: { $eq: aggregation.aggregateStart },
-                aggregateDuration: { $eq: aggregation.aggregateDuration }
-            },
-            {
-                $setOnInsert: {
-                    typeOf: aggregation.typeOf,
-                    project: aggregation.project,
-                    aggregateDuration: aggregation.aggregateDuration,
-                    aggregateStart: aggregation.aggregateStart
-                },
-                $set: setFields
-            },
-            { upsert: true, new: true }
-        )
-            .exec();
-        console.log(doc);
-    }
-}
-
-main()
-    .then(() => {
-        console.log('success!');
-    })
-    .catch(console.error);

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

@@ -1,113 +0,0 @@
-// tslint:disable:no-console
-import * as moment from 'moment-timezone';
-import * as mongoose from 'mongoose';
-
-import { chevre } from '../../../../lib/index';
-
-// const project = { id: <string>process.env.PROJECT_ID };
-interface IAggregation {
-    typeOf: 'AggregateOrder';
-    project: { id: string; typeOf: chevre.factory.organizationType.Project };
-    aggregateDate: Date;
-    aggregateDuration: string;
-    aggregateStart: Date;
-    orderCount: number;
-    acceptedOfferCount: number;
-    avgAcceptedOfferCount: number;
-    totalPrice: number;
-    maxPrice: number;
-    minPrice: number;
-    avgPrice: number;
-}
-
-async function main() {
-    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
-
-    const now: Date = new Date();
-
-    const aggregationRepo = new chevre.repository.Aggregation(mongoose.connection);
-    const orderRepo = new chevre.repository.Order(mongoose.connection);
-
-    let i = 0;
-    // tslint:disable-next-line:no-magic-numbers
-    while (i < 365) {
-        i += 1;
-
-        const orderDateFrom: Date = moment()
-            // .tz('Asia/Tokyo')
-            .add(-i, 'days')
-            .startOf('day')
-            .toDate();
-        const orderDateThrough: Date = moment()
-            // .tz('Asia/Tokyo')
-            .add(-i, 'days')
-            .endOf('day')
-            .toDate();
-        // console.log(bookingFrom, bookingThrough);
-
-        const aggregateResult = await orderRepo.aggregateOrder({
-            orderDate: {
-                $gte: orderDateFrom,
-                $lte: orderDateThrough
-            }
-        });
-        console.log('aggregateResult', aggregateResult);
-
-        const aggregation: IAggregation = {
-            typeOf: 'AggregateOrder',
-            project: { id: '*', typeOf: chevre.factory.organizationType.Project },
-            aggregateDuration: moment.duration(1, 'days')
-                .toISOString(),
-            aggregateStart: orderDateFrom,
-            aggregateDate: now,
-            orderCount: (aggregateResult.length > 0) ? aggregateResult[0].orderCount : 0,
-            acceptedOfferCount: (aggregateResult.length > 0) ? aggregateResult[0].acceptedOfferCount : 0,
-            avgAcceptedOfferCount: (aggregateResult.length > 0) ? aggregateResult[0].avgAcceptedOfferCount : 0,
-            totalPrice: (aggregateResult.length > 0) ? aggregateResult[0].totalPrice : 0,
-            maxPrice: (aggregateResult.length > 0) ? aggregateResult[0].maxPrice : 0,
-            minPrice: (aggregateResult.length > 0) ? aggregateResult[0].minPrice : 0,
-            avgPrice: (aggregateResult.length > 0) ? aggregateResult[0].avgPrice : 0
-        };
-        const {
-            avgAcceptedOfferCount,
-            totalPrice,
-            maxPrice,
-            minPrice,
-            avgPrice,
-            acceptedOfferCount,
-            orderCount,
-            aggregateDate,
-            ...setOnInsert
-        } = aggregation;
-        const doc = await aggregationRepo.aggregationModel.findOneAndUpdate(
-            {
-                typeOf: { $eq: aggregation.typeOf },
-                'project.id': { $eq: aggregation.project.id },
-                aggregateStart: { $eq: aggregation.aggregateStart },
-                aggregateDuration: { $eq: aggregation.aggregateDuration }
-            },
-            {
-                $setOnInsert: setOnInsert,
-                $set: {
-                    avgAcceptedOfferCount,
-                    totalPrice,
-                    maxPrice,
-                    minPrice,
-                    avgPrice,
-                    acceptedOfferCount,
-                    orderCount,
-                    aggregateDate
-                }
-            },
-            { upsert: true }
-        )
-            .exec();
-        console.log(doc);
-    }
-}
-
-main()
-    .then(() => {
-        console.log('success!');
-    })
-    .catch(console.error);

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

@@ -1,84 +0,0 @@
-// tslint:disable:no-console
-import * as moment from 'moment-timezone';
-import * as mongoose from 'mongoose';
-
-import { chevre } from '../../../../lib/index';
-
-// const project = { id: <string>process.env.PROJECT_ID };
-interface IAggregation {
-    typeOf: 'AggregateReservation';
-    project: { id: string; typeOf: chevre.factory.organizationType.Project };
-    aggregateDate: Date;
-    aggregateDuration: string;
-    aggregateStart: Date;
-    // bookingTime: Date;
-    reservationCount: number;
-}
-
-async function main() {
-    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
-
-    const now: Date = new Date();
-
-    const aggregationRepo = new chevre.repository.Aggregation(mongoose.connection);
-    const reservationRepo = new chevre.repository.Reservation(mongoose.connection);
-
-    let i = 0;
-    // tslint:disable-next-line:no-magic-numbers
-    while (i < 365) {
-        i += 1;
-
-        const bookingFrom: Date = moment()
-            // .tz('Asia/Tokyo')
-            .add(-i, 'days')
-            .startOf('day')
-            .toDate();
-        const bookingThrough: Date = moment()
-            // .tz('Asia/Tokyo')
-            .add(-i, 'days')
-            .endOf('day')
-            .toDate();
-        // console.log(bookingFrom, bookingThrough);
-
-        // i日前の予約検索
-        const searchReservationCountResult = await reservationRepo.count({
-            typeOf: chevre.factory.reservationType.EventReservation,
-            reservationStatus: { $eq: chevre.factory.reservationStatusType.ReservationConfirmed },
-            bookingFrom,
-            bookingThrough
-        });
-
-        const aggregation: IAggregation = {
-            typeOf: 'AggregateReservation',
-            project: { id: '*', typeOf: chevre.factory.organizationType.Project },
-            aggregateDuration: moment.duration(1, 'days')
-                .toISOString(),
-            aggregateStart: bookingFrom,
-            aggregateDate: now,
-            reservationCount: searchReservationCountResult
-        };
-        console.log(aggregation);
-        const { reservationCount, aggregateDate, ...setOnInsert } = aggregation;
-        const doc = await aggregationRepo.aggregationModel.findOneAndUpdate(
-            {
-                typeOf: { $eq: aggregation.typeOf },
-                'project.id': { $eq: aggregation.project.id },
-                aggregateStart: { $eq: aggregation.aggregateStart },
-                aggregateDuration: { $eq: aggregation.aggregateDuration }
-            },
-            {
-                $setOnInsert: setOnInsert,
-                $set: { aggregateDate, reservationCount }
-            },
-            { upsert: true }
-        )
-            .exec();
-        console.log(doc);
-    }
-}
-
-main()
-    .then(() => {
-        console.log('success!');
-    })
-    .catch(console.error);

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

@@ -1,104 +0,0 @@
-// tslint:disable:no-console
-import * as moment from 'moment-timezone';
-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);
-
-interface IAggregation {
-    typeOf: 'AggregatePlaceOrder';
-    project: { id: string; typeOf: chevre.factory.organizationType.Project };
-    aggregateDate: Date;
-    aggregateDuration: string;
-    aggregateStart: Date;
-    // transactionCount: number;
-    // avgDuration: number;
-    // maxDuration: number;
-    // minDuration: number;
-}
-
-async function main() {
-    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
-
-    const now: Date = new Date();
-
-    const aggregationRepo = new chevre.repository.Aggregation(mongoose.connection);
-    const transactionRepo = new chevre.repository.Transaction(mongoose.connection);
-
-    let i = 0;
-    // tslint:disable-next-line:no-magic-numbers
-    while (i < AGGREGATE_DAYS) {
-        i += 1;
-
-        const startFrom: Date = moment()
-            // .tz('Asia/Tokyo')
-            .add(-i, 'days')
-            .startOf('day')
-            .toDate();
-        const startThrough: Date = moment()
-            // .tz('Asia/Tokyo')
-            .add(-i, 'days')
-            .endOf('day')
-            .toDate();
-
-        const aggregateResult = await transactionRepo.aggregatePlaceOrder({
-            project: { id: <any>{ $ne: EXCLUDED_PROJECT_ID } },
-            startFrom,
-            startThrough,
-            typeOf: chevre.factory.transactionType.PlaceOrder
-        });
-        console.log('aggregateResult', aggregateResult, aggregateResult.statuses[0]?.aggregation.percentilesDuration, startFrom);
-
-        const aggregation: IAggregation = {
-            typeOf: 'AggregatePlaceOrder',
-            project: { id: '*', typeOf: chevre.factory.organizationType.Project },
-            aggregateDuration: moment.duration(1, 'days')
-                .toISOString(),
-            aggregateStart: startFrom,
-            aggregateDate: now,
-            ...aggregateResult
-        };
-        const { typeOf, project, aggregateDuration, aggregateStart, ...setFields } = aggregation;
-        const doc = await aggregationRepo.aggregationModel.findOneAndUpdate(
-            {
-                typeOf: { $eq: aggregation.typeOf },
-                'project.id': { $eq: aggregation.project.id },
-                aggregateStart: { $eq: aggregation.aggregateStart },
-                aggregateDuration: { $eq: aggregation.aggregateDuration }
-            },
-            {
-                $setOnInsert: {
-                    typeOf: aggregation.typeOf,
-                    project: aggregation.project,
-                    aggregateDuration: aggregation.aggregateDuration,
-                    aggregateStart: aggregation.aggregateStart
-                },
-                $set: setFields,
-                $unset: {
-                    avgLargeDuration: 1,
-                    avgMediumDuration: 1,
-                    avgSmallDuration: 1,
-                    stdDevDuration: 1,
-                    transactionCountByStatus: 1,
-                    transactionCount: 12,
-                    avgDuration: 1,
-                    maxDuration: 1,
-                    minDuration: 1,
-                    percentilesDuration: 1
-                }
-            },
-            { upsert: true, new: true }
-        )
-            .exec();
-        console.log(doc);
-    }
-}
-
-main()
-    .then(() => {
-        console.log('success!');
-    })
-    .catch(console.error);