@chevre/domain 20.2.0-alpha.22 → 20.2.0-alpha.24

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

@@ -13,36 +13,42 @@ async function main() {
 
     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 assetTransactionRepo = new chevre.repository.AssetTransaction(mongoose.connection);
     const actionRepo = new chevre.repository.Action(mongoose.connection);
+    const taskRepo = new chevre.repository.Task(mongoose.connection);
 
-    await chevre.service.aggregation.system.aggregatePlaceOrder({
+    await aggregationRepo.aggregationModel.deleteMany({
+        typeOf: { $in: ['AggregateOrder', 'AggregateReservation'] }
+    })
+        .exec();
+    await chevre.service.aggregation.system.aggregateReserveTransaction({
         aggregationDays: AGGREGATE_DAYS,
-        excludedProjectId: EXCLUDED_PROJECT_ID,
-        clientIds: AGGREGATE_CLIENT_IDS
+        excludedProjectId: EXCLUDED_PROJECT_ID
     })({
         agregation: aggregationRepo,
-        transaction: transactionRepo
+        assetTransaction: assetTransactionRepo
     });
 
-    await chevre.service.aggregation.system.aggregateAuthorizeOrderAction({
+    return;
+
+    await chevre.service.aggregation.system.aggregateTask({
         aggregationDays: AGGREGATE_DAYS,
         excludedProjectId: EXCLUDED_PROJECT_ID
     })({
         agregation: aggregationRepo,
-        action: actionRepo
+        task: taskRepo
     });
 
-    await chevre.service.aggregation.system.aggregateAuthorizeEventServiceOfferAction({
+    await chevre.service.aggregation.system.aggregatePlaceOrder({
         aggregationDays: AGGREGATE_DAYS,
-        excludedProjectId: EXCLUDED_PROJECT_ID
+        excludedProjectId: EXCLUDED_PROJECT_ID,
+        clientIds: AGGREGATE_CLIENT_IDS
     })({
         agregation: aggregationRepo,
-        action: actionRepo
+        transaction: transactionRepo
     });
 
-    await chevre.service.aggregation.system.aggregateAuthorizePaymentAction({
+    await chevre.service.aggregation.system.aggregateAuthorizeOrderAction({
         aggregationDays: AGGREGATE_DAYS,
         excludedProjectId: EXCLUDED_PROJECT_ID
     })({
@@ -50,7 +56,7 @@ async function main() {
         action: actionRepo
     });
 
-    await chevre.service.aggregation.system.aggregateUseAction({
+    await chevre.service.aggregation.system.aggregateAuthorizeEventServiceOfferAction({
         aggregationDays: AGGREGATE_DAYS,
         excludedProjectId: EXCLUDED_PROJECT_ID
     })({
@@ -58,20 +64,20 @@ async function main() {
         action: actionRepo
     });
 
-    await chevre.service.aggregation.system.aggregateOrder({
+    await chevre.service.aggregation.system.aggregateAuthorizePaymentAction({
         aggregationDays: AGGREGATE_DAYS,
         excludedProjectId: EXCLUDED_PROJECT_ID
     })({
         agregation: aggregationRepo,
-        order: orderRepo
+        action: actionRepo
     });
 
-    await chevre.service.aggregation.system.aggregateReservation({
+    await chevre.service.aggregation.system.aggregateUseAction({
         aggregationDays: AGGREGATE_DAYS,
         excludedProjectId: EXCLUDED_PROJECT_ID
     })({
         agregation: aggregationRepo,
-        reservation: reservationRepo
+        action: actionRepo
     });
 }
 

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

@@ -5,8 +5,8 @@ export declare enum AggregationType {
     AggregateAuthorizeEventServiceOfferAction = "AggregateAuthorizeEventServiceOfferAction",
     AggregateAuthorizeOrderAction = "AggregateAuthorizeOrderAction",
     AggregateAuthorizePaymentAction = "AggregateAuthorizePaymentAction",
-    AggregateOrder = "AggregateOrder",
-    AggregateReservation = "AggregateReservation",
+    AggregateReserve = "AggregateReserve",
+    AggregateTask = "AggregateTask",
     AggregateUseAction = "AggregateUseAction"
 }
 export interface IAggregationByClient {

package/lib/chevre/repo/aggregation.js

@@ -28,8 +28,8 @@ var AggregationType;
     AggregationType["AggregateAuthorizeEventServiceOfferAction"] = "AggregateAuthorizeEventServiceOfferAction";
     AggregationType["AggregateAuthorizeOrderAction"] = "AggregateAuthorizeOrderAction";
     AggregationType["AggregateAuthorizePaymentAction"] = "AggregateAuthorizePaymentAction";
-    AggregationType["AggregateOrder"] = "AggregateOrder";
-    AggregationType["AggregateReservation"] = "AggregateReservation";
+    AggregationType["AggregateReserve"] = "AggregateReserve";
+    AggregationType["AggregateTask"] = "AggregateTask";
     AggregationType["AggregateUseAction"] = "AggregateUseAction";
 })(AggregationType = exports.AggregationType || (exports.AggregationType = {}));
 /**

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>;
+    aggregateReserve(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,147 @@ class MongoRepository {
                 .exec();
         });
     }
+    aggregateReserve(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: { $subtract: ['$object.reservationFor.startDate', '$startDate'] },
+                        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: 1 },
+                        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/order.d.ts

@@ -76,13 +76,4 @@ export declare class MongoRepository {
             $in: string[];
         };
     }): Promise<(string)[]>;
-    aggregateOrder(params: factory.order.ISearchConditions): Promise<{
-        orderCount: number;
-        acceptedOfferCount: number;
-        avgAcceptedOfferCount: number;
-        totalPrice: number;
-        maxPrice: number;
-        minPrice: number;
-        avgPrice: number;
-    }>;
 }

package/lib/chevre/repo/order.js

@@ -920,54 +920,5 @@ class MongoRepository {
             return [...new Set(reservationNumbers)];
         });
     }
-    aggregateOrder(params) {
-        var _a, _b;
-        return __awaiter(this, void 0, void 0, function* () {
-            const aggregations = yield this.orderModel.aggregate([
-                {
-                    $match: {
-                        orderDate: {
-                            $gte: (_a = params.orderDate) === null || _a === void 0 ? void 0 : _a.$gte,
-                            $lte: (_b = params.orderDate) === null || _b === void 0 ? void 0 : _b.$lte
-                        }
-                    }
-                },
-                {
-                    $group: {
-                        _id: '$typeOf',
-                        acceptedOfferCount: {
-                            $sum: {
-                                $cond: { if: { $isArray: '$acceptedOffers' }, then: { $size: '$acceptedOffers' }, else: 0 }
-                            }
-                        },
-                        avgAcceptedOfferCount: {
-                            $avg: {
-                                $cond: { if: { $isArray: '$acceptedOffers' }, then: { $size: '$acceptedOffers' }, else: 0 }
-                            }
-                        },
-                        orderCount: { $sum: 1 },
-                        totalPrice: { $sum: '$price' },
-                        maxPrice: { $max: '$price' },
-                        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];
-        });
-    }
 }
 exports.MongoRepository = MongoRepository;

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

@@ -1,5 +1,22 @@
 import { Connection, Model } from 'mongoose';
 import * as factory from '../factory';
+interface IAggregationByStatus {
+    taskCount: number;
+    avgLatency: number;
+    maxLatency: number;
+    minLatency: number;
+    percentilesLatency: {
+        name: string;
+        value: number;
+    }[];
+}
+interface IStatus {
+    status: factory.taskStatus;
+    aggregation: IAggregationByStatus;
+}
+export interface IAggregateTask {
+    statuses: IStatus[];
+}
 /**
  * タスクリポジトリ
  */
@@ -39,4 +56,15 @@ export declare class MongoRepository {
             id: string;
         };
     }): Promise<void>;
+    aggregateTask(params: {
+        project?: {
+            id?: {
+                $ne?: string;
+            };
+        };
+        runsFrom: Date;
+        runsThrough: Date;
+    }): Promise<IAggregateTask>;
+    private agggregateByStatus;
 }
+export {};

package/lib/chevre/repo/task.js

@@ -307,5 +307,124 @@ class MongoRepository {
                 .exec();
         });
     }
+    aggregateTask(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const statuses = yield Promise.all([
+                factory.taskStatus.Executed,
+                factory.taskStatus.Aborted
+            ].map((taskStatus) => __awaiter(this, void 0, void 0, function* () {
+                var _a, _b;
+                const matchConditions = Object.assign({ runsAt: {
+                        $gte: params.runsFrom,
+                        $lte: params.runsThrough
+                    }, status: { $eq: taskStatus } }, (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: taskStatus });
+            })));
+            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 taskStatus = params.status;
+            const aggregations = yield this.taskModel.aggregate([
+                {
+                    $match: matchConditions
+                },
+                {
+                    $project: {
+                        latency: { $subtract: ['$lastTriedAt', '$runsAt'] },
+                        status: '$status',
+                        runsAt: '$runsAt',
+                        lastTriedAt: '$lastTriedAt'
+                    }
+                },
+                {
+                    $group: {
+                        _id: '$status',
+                        taskCount: { $sum: 1 },
+                        maxLatency: { $max: '$latency' },
+                        minLatency: { $min: '$latency' },
+                        avgLatency: { $avg: '$latency' }
+                    }
+                },
+                {
+                    $project: {
+                        _id: 0,
+                        taskCount: '$taskCount',
+                        avgLatency: '$avgLatency',
+                        maxLatency: '$maxLatency',
+                        minLatency: '$minLatency'
+                    }
+                }
+            ])
+                .exec();
+            // tslint:disable-next-line:no-magic-numbers
+            const percents = [50, 95, 99];
+            if (aggregations.length === 0) {
+                return {
+                    status: taskStatus,
+                    aggregation: {
+                        taskCount: 0,
+                        avgLatency: 0,
+                        maxLatency: 0,
+                        minLatency: 0,
+                        percentilesLatency: 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].taskCount * percentile / 100)
+                };
+            });
+            const aggregations2 = yield this.taskModel.aggregate([
+                {
+                    $match: matchConditions
+                },
+                {
+                    $project: {
+                        latency: { $subtract: ['$lastTriedAt', '$runsAt'] },
+                        status: '$status',
+                        runsAt: '$runsAt',
+                        lastTriedAt: '$lastTriedAt'
+                    }
+                },
+                { $sort: { latency: 1 } },
+                {
+                    $group: {
+                        _id: '$status',
+                        latencies: { $push: '$latency' }
+                    }
+                },
+                {
+                    $project: {
+                        _id: 0,
+                        percentilesLatency: ranks4percentile.map((rank) => {
+                            return {
+                                name: String(rank.percentile),
+                                value: { $arrayElemAt: ['$latencies', rank.rank] }
+                            };
+                        })
+                    }
+                }
+            ])
+                .exec();
+            return {
+                status: taskStatus,
+                aggregation: Object.assign(Object.assign({}, aggregations[0]), aggregations2[0])
+            };
+        });
+    }
 }
 exports.MongoRepository = MongoRepository;

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

@@ -11,6 +11,12 @@ interface IAggregationByStatus {
         name: string;
         value: number;
     }[];
+    acceptedOfferCount: number;
+    avgAcceptedOfferCount: number;
+    totalPrice: number;
+    maxPrice: number;
+    minPrice: number;
+    avgPrice: number;
 }
 interface IStatus {
     status: factory.transactionStatusType;

package/lib/chevre/repo/transaction.js

@@ -603,9 +603,9 @@ class MongoRepository {
     aggregatePlaceOrder(params) {
         return __awaiter(this, void 0, void 0, function* () {
             const statuses = yield Promise.all([
+                factory.transactionStatusType.Confirmed,
                 factory.transactionStatusType.Canceled,
-                factory.transactionStatusType.Expired,
-                factory.transactionStatusType.Confirmed
+                factory.transactionStatusType.Expired
             ].map((transactionStatus) => __awaiter(this, void 0, void 0, function* () {
                 var _a, _b;
                 const matchConditions = Object.assign(Object.assign({ startDate: {
@@ -680,7 +680,13 @@ class MongoRepository {
                                 name: String(percent),
                                 value: 0
                             };
-                        })
+                        }),
+                        acceptedOfferCount: 0,
+                        avgAcceptedOfferCount: 0,
+                        totalPrice: 0,
+                        maxPrice: 0,
+                        minPrice: 0,
+                        avgPrice: 0
                     }
                 };
             }
@@ -701,28 +707,52 @@ class MongoRepository {
                         status: '$status',
                         startDate: '$startDate',
                         endDate: '$endDate',
-                        typeOf: '$typeOf'
+                        typeOf: '$typeOf',
+                        // result: '$result',
+                        acceptedOffers: {
+                            $cond: {
+                                if: { $isArray: '$result.order.acceptedOffers' },
+                                then: '$result.order.acceptedOffers',
+                                else: []
+                            }
+                        },
+                        price: {
+                            $cond: {
+                                if: { $isNumber: '$result.order.price' },
+                                then: '$result.order.price',
+                                else: 0
+                            }
+                        }
                     }
                 },
                 { $sort: { duration: 1 } },
                 {
                     $group: {
                         _id: '$typeOf',
-                        durations: { $push: '$duration' }
+                        durations: { $push: '$duration' },
+                        acceptedOfferCount: { $sum: { $size: '$acceptedOffers' } },
+                        avgAcceptedOfferCount: { $avg: { $size: '$acceptedOffers' } },
+                        totalPrice: { $sum: '$price' },
+                        maxPrice: { $max: '$price' },
+                        minPrice: { $min: '$price' },
+                        avgPrice: { $avg: '$price' }
                     }
                 },
                 {
                     $project: {
                         _id: 0,
-                        avgSmallDuration: '$avgSmallDuration',
-                        avgMediumDuration: '$avgMediumDuration',
-                        avgLargeDuration: '$avgLargeDuration',
                         percentilesDuration: ranks4percentile.map((rank) => {
                             return {
                                 name: String(rank.percentile),
                                 value: { $arrayElemAt: ['$durations', rank.rank] }
                             };
-                        })
+                        }),
+                        acceptedOfferCount: '$acceptedOfferCount',
+                        avgAcceptedOfferCount: '$avgAcceptedOfferCount',
+                        totalPrice: '$totalPrice',
+                        maxPrice: '$maxPrice',
+                        minPrice: '$minPrice',
+                        avgPrice: '$avgPrice'
                     }
                 }
             ])

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

@@ -1,7 +1,7 @@
 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 AssetTransactionRepo } from '../../repo/assetTransaction';
+import { MongoRepository as TasKRepo } from '../../repo/task';
 import { MongoRepository as TransactionRepo } from '../../repo/transaction';
 /**
  * 注文取引集計
@@ -52,23 +52,20 @@ declare function aggregateUseAction(params: {
     action: ActionRepo;
 }) => Promise<void>;
 /**
- * 注文集計
+ * 予約集計
  */
-declare function aggregateOrder(params: {
+declare function aggregateReserveTransaction(params: {
     aggregationDays: number;
     excludedProjectId?: string;
 }): (repos: {
     agregation: AggregationRepo;
-    order: OrderRepo;
+    assetTransaction: AssetTransactionRepo;
 }) => Promise<void>;
-/**
- * 予約集計
- */
-declare function aggregateReservation(params: {
+declare function aggregateTask(params: {
     aggregationDays: number;
     excludedProjectId?: string;
 }): (repos: {
     agregation: AggregationRepo;
-    reservation: ReservationRepo;
+    task: TasKRepo;
 }) => Promise<void>;
-export { aggregateAuthorizeEventServiceOfferAction, aggregateAuthorizeOrderAction, aggregateAuthorizePaymentAction, aggregateOrder, aggregatePlaceOrder, aggregateReservation, aggregateUseAction };
+export { aggregateAuthorizeEventServiceOfferAction, aggregateAuthorizeOrderAction, aggregateAuthorizePaymentAction, aggregatePlaceOrder, aggregateReserveTransaction, aggregateTask, aggregateUseAction };

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

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.aggregateUseAction = exports.aggregateReservation = exports.aggregatePlaceOrder = exports.aggregateOrder = exports.aggregateAuthorizePaymentAction = exports.aggregateAuthorizeOrderAction = exports.aggregateAuthorizeEventServiceOfferAction = void 0;
+exports.aggregateUseAction = exports.aggregateTask = exports.aggregateReserveTransaction = exports.aggregatePlaceOrder = exports.aggregateAuthorizePaymentAction = exports.aggregateAuthorizeOrderAction = exports.aggregateAuthorizeEventServiceOfferAction = void 0;
 const createDebug = require("debug");
 const moment = require("moment-timezone");
 const factory = require("../../factory");
@@ -20,7 +20,7 @@ const debug = createDebug('chevre-domain:service:aggregation:system');
  */
 function aggregatePlaceOrder(params) {
     return (repos) => __awaiter(this, void 0, void 0, function* () {
-        var _a;
+        var _a, _b;
         const aggregateDate = new Date();
         const aggregateDuration = moment.duration(1, 'days')
             .toISOString();
@@ -43,19 +43,21 @@ function aggregatePlaceOrder(params) {
                 startThrough,
                 typeOf: factory.transactionType.PlaceOrder
             });
-            debug('aggregatePlaceOrder:result', aggregateResult, (_a = aggregateResult.statuses[0]) === null || _a === void 0 ? void 0 : _a.aggregation.percentilesDuration, startFrom);
+            debug('aggregatePlaceOrder:result', aggregateResult, (_a = aggregateResult.statuses[0]) === null || _a === void 0 ? void 0 : _a.aggregation, startFrom);
             const aggregateResultsByClientId = [];
             if (Array.isArray(params.clientIds)) {
                 for (const clientId of params.clientIds) {
+                    const aggregateResultByClientId = yield repos.transaction.aggregatePlaceOrder({
+                        project: { id: { $ne: params.excludedProjectId } },
+                        startFrom,
+                        startThrough,
+                        typeOf: factory.transactionType.PlaceOrder,
+                        clientId
+                    });
+                    debug('aggregateResultByClientId', aggregateResultByClientId, (_b = aggregateResultByClientId.statuses[0]) === null || _b === void 0 ? void 0 : _b.aggregation, clientId, startFrom);
                     aggregateResultsByClientId.push({
                         clientId,
-                        aggregation: yield repos.transaction.aggregatePlaceOrder({
-                            project: { id: { $ne: params.excludedProjectId } },
-                            startFrom,
-                            startThrough,
-                            typeOf: factory.transactionType.PlaceOrder,
-                            clientId
-                        })
+                        aggregation: aggregateResultByClientId
                     });
                 }
             }
@@ -198,69 +200,66 @@ function aggregateUseAction(params) {
 }
 exports.aggregateUseAction = aggregateUseAction;
 /**
- * 注文集計
+ * 予約集計
  */
-function aggregateOrder(params) {
+function aggregateReserveTransaction(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 orderDateFrom = moment()
+            const startFrom = moment()
                 // .tz('Asia/Tokyo')
                 .add(-i, 'days')
                 .startOf('day')
                 .toDate();
-            const orderDateThrough = moment()
+            const startThrough = moment()
                 // .tz('Asia/Tokyo')
                 .add(-i, 'days')
                 .endOf('day')
                 .toDate();
-            const aggregateResult = yield repos.order.aggregateOrder({
-                orderDate: {
-                    $gte: orderDateFrom,
-                    $lte: orderDateThrough
-                }
+            const aggregateResult = yield repos.assetTransaction.aggregateReserve({
+                project: { id: { $ne: params.excludedProjectId } },
+                startFrom,
+                startThrough,
+                typeOf: factory.assetTransactionType.Reserve
             });
-            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));
+            debug('aggregateReserveTransaction:result', aggregateResult, (_a = aggregateResult.statuses[0]) === null || _a === void 0 ? void 0 : _a.aggregation, startFrom);
+            yield repos.agregation.saveAggregation(Object.assign({ typeOf: aggregation_1.AggregationType.AggregateReserve, project: { id: '*', typeOf: factory.organizationType.Project }, aggregateDuration, aggregateStart: startFrom, aggregateDate }, aggregateResult));
         }
     });
 }
-exports.aggregateOrder = aggregateOrder;
-/**
- * 予約集計
- */
-function aggregateReservation(params) {
+exports.aggregateReserveTransaction = aggregateReserveTransaction;
+function aggregateTask(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 bookingFrom = moment()
+            const runsFrom = moment()
                 // .tz('Asia/Tokyo')
                 .add(-i, 'days')
                 .startOf('day')
                 .toDate();
-            const bookingThrough = moment()
+            const runsThrough = 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 = yield repos.task.aggregateTask({
+                project: { id: { $ne: params.excludedProjectId } },
+                runsFrom,
+                runsThrough
             });
-            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));
+            debug('aggregateTask:result', aggregateResult, (_a = aggregateResult.statuses[0]) === null || _a === void 0 ? void 0 : _a.aggregation, runsFrom);
+            yield repos.agregation.saveAggregation(Object.assign({ typeOf: aggregation_1.AggregationType.AggregateTask, project: { id: '*', typeOf: factory.organizationType.Project }, aggregateDuration, aggregateStart: runsFrom, aggregateDate }, aggregateResult));
         }
     });
 }
-exports.aggregateReservation = aggregateReservation;
+exports.aggregateTask = aggregateTask;

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.22"
+  "version": "20.2.0-alpha.24"
 }