@chevre/domain 20.2.0-alpha.4 → 20.2.0-alpha.40

package/lib/chevre/repo/action.js

@@ -677,5 +677,214 @@ 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 };
+        });
+    }
+    aggregateCheckMovieTicketAction(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: factory.actionType.CheckAction }, 'object.typeOf': {
+                        $exists: true,
+                        $eq: factory.service.paymentService.PaymentServiceType.MovieTicket
+                    }, 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,37 @@
+import { Connection, Model } from 'mongoose';
+import * as factory from '../factory';
+export declare enum AggregationType {
+    AggregateAuthorizeEventServiceOfferAction = "AggregateAuthorizeEventServiceOfferAction",
+    AggregateAuthorizeOrderAction = "AggregateAuthorizeOrderAction",
+    AggregateAuthorizePaymentAction = "AggregateAuthorizePaymentAction",
+    AggregateCheckMovieTicketAction = "AggregateCheckMovieTicketAction",
+    AggregateEvent = "AggregateEvent",
+    AggregatePay = "AggregatePay",
+    AggregatePlaceOrder = "AggregatePlaceOrder",
+    AggregateReserve = "AggregateReserve",
+    AggregateTask = "AggregateTask",
+    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,67 @@
+"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["AggregateAuthorizeEventServiceOfferAction"] = "AggregateAuthorizeEventServiceOfferAction";
+    AggregationType["AggregateAuthorizeOrderAction"] = "AggregateAuthorizeOrderAction";
+    AggregationType["AggregateAuthorizePaymentAction"] = "AggregateAuthorizePaymentAction";
+    AggregationType["AggregateCheckMovieTicketAction"] = "AggregateCheckMovieTicketAction";
+    AggregationType["AggregateEvent"] = "AggregateEvent";
+    AggregationType["AggregatePay"] = "AggregatePay";
+    AggregationType["AggregatePlaceOrder"] = "AggregatePlaceOrder";
+    AggregationType["AggregateReserve"] = "AggregateReserve";
+    AggregationType["AggregateTask"] = "AggregateTask";
+    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;

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

@@ -2,6 +2,27 @@ import { Connection } from 'mongoose';
 import { modelName } from './mongoose/model/assetTransaction';
 import * as factory from '../factory';
 export { modelName };
+interface IAggregationByStatus {
+    transactionCount: number;
+    avgDuration: number;
+    maxDuration: number;
+    minDuration: number;
+    percentilesDuration: {
+        name: string;
+        value: number;
+    }[];
+    reservationCount: number;
+    avgGraceTime: number;
+    maxGraceTime: number;
+    minGraceTime: number;
+}
+interface IStatus {
+    status: factory.transactionStatusType;
+    aggregation: IAggregationByStatus;
+}
+export interface IAggregateReserve {
+    statuses: IStatus[];
+}
 /**
  * 資産取引リポジトリ
  */
@@ -123,4 +144,15 @@ export declare class MongoRepository {
     findByIdAndDelete(params: {
         id: string;
     }): Promise<void>;
+    aggregateAssetTransaction(params: {
+        project?: {
+            id?: {
+                $ne?: string;
+            };
+        };
+        startFrom: Date;
+        startThrough: Date;
+        typeOf: factory.assetTransactionType;
+    }): Promise<IAggregateReserve>;
+    private agggregateByStatus;
 }

package/lib/chevre/repo/assetTransaction.js

@@ -536,5 +536,153 @@ class MongoRepository {
                 .exec();
         });
     }
+    aggregateAssetTransaction(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const statuses = yield Promise.all([
+                factory.transactionStatusType.Confirmed,
+                factory.transactionStatusType.Canceled,
+                factory.transactionStatusType.Expired
+            ].map((transactionStatus) => __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 }, 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'] },
+                        graceTime: {
+                            $cond: {
+                                if: { $eq: ['$typeOf', factory.assetTransactionType.Reserve] },
+                                then: { $subtract: ['$object.reservationFor.startDate', '$startDate'] },
+                                else: 0
+                            }
+                        },
+                        status: '$status',
+                        startDate: '$startDate',
+                        endDate: '$endDate',
+                        typeOf: '$typeOf',
+                        reservationCount: {
+                            $cond: {
+                                if: { $isArray: '$object.subReservation' },
+                                then: { $size: '$object.subReservation' },
+                                else: 0
+                            }
+                        }
+                    }
+                },
+                {
+                    $group: {
+                        _id: '$typeOf',
+                        transactionCount: { $sum: 1 },
+                        maxDuration: { $max: '$duration' },
+                        minDuration: { $min: '$duration' },
+                        avgDuration: { $avg: '$duration' },
+                        reservationCount: { $sum: '$reservationCount' },
+                        maxGraceTime: { $max: '$graceTime' },
+                        minGraceTime: { $min: '$graceTime' },
+                        avgGraceTime: { $avg: '$graceTime' }
+                    }
+                },
+                {
+                    $project: {
+                        _id: 0,
+                        transactionCount: '$transactionCount',
+                        avgDuration: '$avgDuration',
+                        maxDuration: '$maxDuration',
+                        minDuration: '$minDuration',
+                        reservationCount: '$reservationCount',
+                        avgGraceTime: '$avgGraceTime',
+                        maxGraceTime: '$maxGraceTime',
+                        minGraceTime: '$minGraceTime'
+                    }
+                }
+            ])
+                .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
+                            };
+                        }),
+                        reservationCount: 0,
+                        avgGraceTime: 0,
+                        maxGraceTime: 0,
+                        minGraceTime: 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,
+                        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])
+            };
+        });
+    }
 }
 exports.MongoRepository = MongoRepository;

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

@@ -1,5 +1,6 @@
 import { Connection } from 'mongoose';
 import * as factory from '../factory';
+import * as EventFactory from '../factory/event';
 export interface IAttributes4patchUpdate<T extends factory.eventType> {
     typeOf: T;
     eventStatus?: factory.eventStatusType;
@@ -30,6 +31,32 @@ export interface IUpdateAggregateUseActionsParams {
     };
 }
 export declare type ISearchConditions<T extends factory.eventType> = factory.event.ISearchConditions<T>;
+interface IAggregationByStatus {
+    eventCount: number;
+    reservationCount: number;
+    avgOfferCount: number;
+    maximumAttendeeCapacity: number;
+    remainingAttendeeCapacity: number;
+    avgRemainingCapacityRate: number;
+    maxRemainingCapacityRate: number;
+    minRemainingCapacityRate: number;
+    percentilesRemainingCapacityRate: {
+        name: string;
+        value: number;
+    }[];
+}
+interface IStatus {
+    status: factory.eventStatusType;
+    aggregation: IAggregationByStatus;
+}
+export interface IAggregateEvent {
+    statuses: IStatus[];
+}
+interface IProjection {
+    [key: string]: number;
+}
+export import IMinimizedIndividualEvent = EventFactory.IMinimizedIndividualEvent;
+export declare const PROJECTION_MINIMIZED_EVENT: IProjection;
 /**
  * イベントリポジトリ
  */
@@ -40,7 +67,19 @@ export declare class MongoRepository {
     /**
      * 複数イベントを作成する
      */
-    createMany<T extends factory.eventType>(params: factory.event.IAttributes<T>[]): Promise<factory.event.IEvent<T>[]>;
+    createMany<T extends factory.eventType>(params: {
+        attributes: factory.event.IAttributes<T>[];
+        expectsNoContent: boolean;
+    }): Promise<factory.event.IEvent<T>[] | void>;
+    /**
+     * 特定の追加特性をキーにして、なければ作成する(複数対応)
+     */
+    createIfNotExistMany<T extends factory.eventType.ScreeningEvent>(params: {
+        attributes: factory.event.IAttributes<T>;
+        filter: {
+            name: string;
+        };
+    }[]): Promise<void>;
     /**
      * イベント部分更新
      */
@@ -54,36 +93,31 @@ export declare class MongoRepository {
     save<T extends factory.eventType>(params: {
         id?: string;
         attributes: factory.event.IAttributes<T>;
-        $unset?: {
-            [key: string]: number;
-        };
+        $unset?: IProjection;
         upsert?: boolean;
     }): Promise<factory.event.IEvent<T>>;
     saveMany<T extends factory.eventType>(params: {
-        id?: string;
+        id: string;
         attributes: factory.event.IAttributes<T>;
-        $unset?: {
-            [key: string]: number;
-        };
-        upsert?: boolean;
+        $unset?: IProjection;
+        upsert: boolean;
     }[]): Promise<void>;
     save4ttts(params: {
         oldEventId: string;
         attributes: factory.event.IAttributes<factory.eventType.ScreeningEvent>;
-        useOldEventId: boolean;
     }): Promise<factory.event.IEvent<factory.eventType.ScreeningEvent>>;
     count<T extends factory.eventType>(params: ISearchConditions<T>): Promise<number>;
     /**
      * イベントを検索する
      */
-    search<T extends factory.eventType>(params: ISearchConditions<T>, projection?: {
-        [key: string]: number;
-    }): Promise<factory.event.IEvent<T>[]>;
+    search<T extends factory.eventType>(params: ISearchConditions<T>, projection?: IProjection): Promise<factory.event.IEvent<T>[]>;
+    searchIds<T extends factory.eventType>(params: ISearchConditions<T>): Promise<string[]>;
     findById<T extends factory.eventType>(params: {
         id: string;
-    }, projection?: {
-        [key: string]: number;
-    }): Promise<factory.event.IEvent<T>>;
+    }, projection?: IProjection): Promise<factory.event.IEvent<T>>;
+    findMinimizedIndividualEventById<T extends factory.eventType.ScreeningEvent | factory.eventType.Event>(params: {
+        id: string;
+    }): Promise<IMinimizedIndividualEvent<T>>;
     /**
      * イベントをキャンセルする
      */
@@ -109,4 +143,16 @@ export declare class MongoRepository {
     deleteUnnecessaryProjectAttributesById(params: {
         id: string;
     }): Promise<void>;
+    aggregateEvent(params: {
+        project?: {
+            id?: {
+                $ne?: string;
+            };
+        };
+        startFrom: Date;
+        startThrough: Date;
+        typeOf: factory.eventType;
+    }): Promise<IAggregateEvent>;
+    private agggregateByStatus;
 }
+export {};