@chevre/domain 26.0.0-alpha.3 → 26.0.0-alpha.30

package/lib/chevre/repo/adminTask.js

@@ -1,11 +1,14 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AdminTaskRepo = void 0;
+const moment_1 = __importDefault(require("moment"));
 const factory_1 = require("../factory");
 const settings_1 = require("../settings");
 const task_1 = require("./mongoose/schemas/task");
 const AVAILABLE_PROJECT_FIELDS = [
-    'alternateName',
     'identifier',
     'description',
     'project',
@@ -19,7 +22,7 @@ const AVAILABLE_PROJECT_FIELDS = [
     'executor',
     'data',
     'dateAborted',
-    'expires'
+    // 'expires' // 非同期アクションは移行につきexpires廃止(2026-08-05~)
 ];
 /**
  * タスク管理リポジトリ
@@ -65,12 +68,12 @@ class AdminTaskRepo {
         if (params.runsThrough instanceof Date) {
             andConditions.push({ runsAt: { $lte: params.runsThrough } });
         }
-        if (params.lastTriedFrom instanceof Date) {
-            andConditions.push({ lastTriedAt: { $type: 'date', $gte: params.lastTriedFrom } });
-        }
-        if (params.lastTriedThrough instanceof Date) {
-            andConditions.push({ lastTriedAt: { $type: 'date', $lte: params.lastTriedThrough } });
-        }
+        // if (params.lastTriedFrom instanceof Date) {
+        //     andConditions.push({ lastTriedAt: { $type: 'date', $gte: params.lastTriedFrom } });
+        // }
+        // if (params.lastTriedThrough instanceof Date) {
+        //     andConditions.push({ lastTriedAt: { $type: 'date', $lte: params.lastTriedThrough } });
+        // }
         const dateAbortedGte = params.dateAborted?.$gte;
         if (dateAbortedGte instanceof Date) {
             andConditions.push({ dateAborted: { $type: 'date', $gte: dateAbortedGte } });
@@ -79,30 +82,6 @@ class AdminTaskRepo {
         if (dateAbortedLte instanceof Date) {
             andConditions.push({ dateAborted: { $type: 'date', $lte: dateAbortedLte } });
         }
-        const objectIdEq = params.data?.object?.id?.$eq;
-        if (typeof objectIdEq === 'string') {
-            andConditions.push({ 'data.object.id': { $exists: true, $eq: objectIdEq } });
-        }
-        const objectOrderNumberEq = params.data?.object?.orderNumber?.$eq;
-        if (typeof objectOrderNumberEq === 'string') {
-            andConditions.push({ 'data.object.orderNumber': { $exists: true, $eq: objectOrderNumberEq } });
-        }
-        const objectTransactionNumberEq = params.data?.object?.transactionNumber?.$eq;
-        if (typeof objectTransactionNumberEq === 'string') {
-            andConditions.push({ 'data.object.transactionNumber': { $exists: true, $eq: objectTransactionNumberEq } });
-        }
-        const objectPurposeIdEq = params.data?.purpose?.id?.$eq;
-        if (typeof objectPurposeIdEq === 'string') {
-            andConditions.push({ 'data.purpose.id': { $exists: true, $eq: objectPurposeIdEq } });
-        }
-        const objectPurposeOrderNumberEq = params.data?.purpose?.orderNumber?.$eq;
-        if (typeof objectPurposeOrderNumberEq === 'string') {
-            andConditions.push({ 'data.purpose.orderNumber': { $exists: true, $eq: objectPurposeOrderNumberEq } });
-        }
-        const alternateNameRegex = params.alternateName?.$regex;
-        if (typeof alternateNameRegex === 'string' && alternateNameRegex.length > 0) {
-            andConditions.push({ alternateName: { $exists: true, $regex: new RegExp(alternateNameRegex) } });
-        }
         const identifierRegex = params.identifier?.$regex;
         if (typeof identifierRegex === 'string' && identifierRegex.length > 0) {
             andConditions.push({ identifier: { $exists: true, $regex: new RegExp(identifierRegex) } });
@@ -150,6 +129,26 @@ class AdminTaskRepo {
             .lean() // lean(2024-09-26~)
             .exec();
     }
+    /**
+     * cron:notifyLatency専用
+     */
+    async countDelayedTasks(params) {
+        const { limit } = params;
+        const runsAtLt = (0, moment_1.default)()
+            .add(-params.delayInSeconds, 'seconds')
+            .toDate();
+        const query = this.taskModel.countDocuments({
+            status: { $eq: factory_1.factory.taskStatus.Ready },
+            runsAt: { $lt: runsAtLt },
+            ...(Array.isArray(params.name.$nin)) ? { name: { $nin: params.name.$nin } } : undefined
+        });
+        if (typeof limit === 'number' && limit >= 0) {
+            query.limit(limit);
+        }
+        const count = await query.setOptions({ maxTimeMS: settings_1.MONGO_MAX_TIME_MS })
+            .exec();
+        return { count };
+    }
     getCursor(conditions, projection) {
         return this.taskModel.find(conditions, projection)
             .sort({ runsAt: factory_1.factory.sortType.Ascending })

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

@@ -0,0 +1,131 @@
+import type { Connection } from 'mongoose';
+import { factory } from '../factory';
+import { IDocType } from './mongoose/schemas/transaction';
+/**
+ * 取引管理リポジトリ
+ */
+export declare class AdminTransactionRepo {
+    private readonly transactionModel;
+    constructor(connection: Connection);
+    countPotentiallyExportTasks(params: {
+        endDate: {
+            $lt: Date;
+        };
+        limit?: number;
+    }): Promise<{
+        count: number;
+    }>;
+    /**
+     * tasksExportAction.actionStatusがActiveActionStatusのまま一定時間経過した取引について
+     * PotentialActionStatusに変更する
+     * 2025-03-10~
+     */
+    reExportAction(params: {
+        startDate: {
+            $lt: Date;
+        };
+    }): Promise<import("mongoose").UpdateWriteOpResult>;
+    /**
+     * add(2025-03-13~)
+     */
+    countPotentiallyExpired(params: {
+        expires: {
+            $lt: Date;
+        };
+        limit?: number;
+    }): Promise<{
+        count: number;
+    }>;
+    /**
+     * add(2025-03-03~)
+     */
+    makeOneExpiredIfExists(params: {
+        expires: {
+            $lt: Date;
+        };
+    }): Promise<Pick<factory.transaction.ITransaction<factory.transactionType>, 'id' | 'typeOf'> | undefined>;
+    findByIdAndDelete(params: {
+        id: string;
+    }): Promise<void>;
+    unsetUnnecessaryFields(params: {
+        filter: any;
+        $unset: any;
+    }): Promise<import("mongoose").UpdateWriteOpResult>;
+    getCursor(conditions: any, projection: any, sort?: factory.sortType): import("mongoose").Cursor<import("mongoose").Document<unknown, Record<string, never>, IDocType, import("./mongoose/virtuals").IVirtuals, {}> & (({
+        object: import("@chevre/factory/lib/chevre/transaction/placeOrder").IObject;
+        error?: any;
+        project: import("@chevre/factory/lib/chevre/transaction").IProject;
+        seller: import("@chevre/factory/lib/chevre/transaction/placeOrder").ISeller;
+        typeOf: factory.transactionType.PlaceOrder;
+        expires: Date;
+        result?: import("@chevre/factory/lib/chevre/transaction/placeOrder").IResult | undefined;
+        startDate: Date;
+        endDate?: Date | undefined;
+        instrument?: import("@chevre/factory/lib/chevre/transaction/placeOrder").IInstrument | undefined;
+        agent: import("@chevre/factory/lib/chevre/transaction/placeOrder").IAgent;
+        status: factory.transactionStatusType;
+        tasksExportAction?: import("@chevre/factory/lib/chevre/transaction").ITasksExportAction | undefined;
+        potentialActions?: undefined;
+    } & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }) | ({
+        object: import("@chevre/factory/lib/chevre/transaction/returnOrder").IObject;
+        error?: any;
+        project: import("@chevre/factory/lib/chevre/transaction").IProject;
+        seller: import("@chevre/factory/lib/chevre/transaction").ISeller;
+        typeOf: factory.transactionType.ReturnOrder;
+        expires: Date;
+        result?: import("@chevre/factory/lib/chevre/transaction/returnOrder").IResult | undefined;
+        startDate: Date;
+        endDate?: Date | undefined;
+        agent: import("@chevre/factory/lib/chevre/transaction").IAgent;
+        recipient?: undefined;
+        status: factory.transactionStatusType;
+        tasksExportAction?: import("@chevre/factory/lib/chevre/transaction").ITasksExportAction | undefined;
+        potentialActions?: import("@chevre/factory/lib/chevre/transaction/returnOrder").IPotentialActions | undefined;
+    } & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    })), import("mongoose").QueryOptions<IDocType>, (import("mongoose").Document<unknown, Record<string, never>, IDocType, import("./mongoose/virtuals").IVirtuals, {}> & (({
+        object: import("@chevre/factory/lib/chevre/transaction/placeOrder").IObject;
+        error?: any;
+        project: import("@chevre/factory/lib/chevre/transaction").IProject;
+        seller: import("@chevre/factory/lib/chevre/transaction/placeOrder").ISeller;
+        typeOf: factory.transactionType.PlaceOrder;
+        expires: Date;
+        result?: import("@chevre/factory/lib/chevre/transaction/placeOrder").IResult | undefined;
+        startDate: Date;
+        endDate?: Date | undefined;
+        instrument?: import("@chevre/factory/lib/chevre/transaction/placeOrder").IInstrument | undefined;
+        agent: import("@chevre/factory/lib/chevre/transaction/placeOrder").IAgent;
+        status: factory.transactionStatusType;
+        tasksExportAction?: import("@chevre/factory/lib/chevre/transaction").ITasksExportAction | undefined;
+        potentialActions?: undefined;
+    } & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }) | ({
+        object: import("@chevre/factory/lib/chevre/transaction/returnOrder").IObject;
+        error?: any;
+        project: import("@chevre/factory/lib/chevre/transaction").IProject;
+        seller: import("@chevre/factory/lib/chevre/transaction").ISeller;
+        typeOf: factory.transactionType.ReturnOrder;
+        expires: Date;
+        result?: import("@chevre/factory/lib/chevre/transaction/returnOrder").IResult | undefined;
+        startDate: Date;
+        endDate?: Date | undefined;
+        agent: import("@chevre/factory/lib/chevre/transaction").IAgent;
+        recipient?: undefined;
+        status: factory.transactionStatusType;
+        tasksExportAction?: import("@chevre/factory/lib/chevre/transaction").ITasksExportAction | undefined;
+        potentialActions?: import("@chevre/factory/lib/chevre/transaction/returnOrder").IPotentialActions | undefined;
+    } & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }))) | null>;
+}

package/lib/chevre/repo/adminTransaction.js

@@ -0,0 +1,237 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdminTransactionRepo = void 0;
+const transaction_1 = require("../eventEmitter/transaction");
+const factory_1 = require("../factory");
+const settings_1 = require("../settings");
+const transaction_2 = require("./mongoose/schemas/transaction");
+/**
+ * 取引管理リポジトリ
+ */
+class AdminTransactionRepo {
+    transactionModel;
+    constructor(connection) {
+        this.transactionModel = connection.model(transaction_2.modelName, (0, transaction_2.createSchema)());
+    }
+    async countPotentiallyExportTasks(params) {
+        const { endDate, limit } = params;
+        const endDateLt = endDate?.$lt;
+        if (!(endDateLt instanceof Date)) {
+            throw new factory_1.factory.errors.Argument('endDate.$lt', 'must be Date');
+        }
+        const query = this.transactionModel.countDocuments({
+            status: {
+                $in: [
+                    factory_1.factory.transactionStatusType.Canceled,
+                    factory_1.factory.transactionStatusType.Confirmed,
+                    factory_1.factory.transactionStatusType.Expired
+                ]
+            },
+            'tasksExportAction.actionStatus': {
+                $exists: true,
+                $eq: factory_1.factory.actionStatusType.PotentialActionStatus
+            },
+            endDate: { $exists: true, $lt: endDateLt }
+        });
+        if (typeof limit === 'number' && limit >= 0) {
+            query.limit(limit);
+        }
+        const count = await query.setOptions({ maxTimeMS: settings_1.MONGO_MAX_TIME_MS })
+            .exec();
+        return { count };
+    }
+    /**
+     * tasksExportAction.actionStatusがActiveActionStatusのまま一定時間経過した取引について
+     * PotentialActionStatusに変更する
+     * 2025-03-10~
+     */
+    async reExportAction(params) {
+        const { startDate } = params;
+        if (!(startDate.$lt instanceof Date)) {
+            throw new factory_1.factory.errors.Argument('startDate.$lt', 'must be Date');
+        }
+        return this.transactionModel.updateMany({
+            'tasksExportAction.actionStatus': {
+                $exists: true,
+                $eq: factory_1.factory.actionStatusType.ActiveActionStatus
+            },
+            'tasksExportAction.startDate': {
+                $exists: true,
+                $lt: startDate.$lt
+            }
+        }, {
+            $set: {
+                tasksExportAction: {
+                    actionStatus: factory_1.factory.actionStatusType.PotentialActionStatus
+                }
+            }
+        })
+            .exec();
+    }
+    // /**
+    //  * タスクエクスポートの遅延している取引について明示的にemitTransactionStatusChangedを実行する
+    //  */
+    // public async exportTasksMany(params: {
+    //     now: Date;
+    //     delayInSeconds: number;
+    //     status: {
+    //         $in: factory.transactionStatusType[];
+    //     };
+    //     limit: number;
+    // }) {
+    //     const delayedTransactions = await this.transactionModel.find({
+    //         status: { $in: params.status.$in },
+    //         'tasksExportAction.actionStatus': {
+    //             $exists: true,
+    //             $eq: factory.actionStatusType.PotentialActionStatus
+    //         },
+    //         endDate: {
+    //             $exists: true,
+    //             $lt: moment(params.now)
+    //                 .add(-params.delayInSeconds, 'seconds')
+    //                 .toDate()
+    //         }
+    //     })
+    //         .select({
+    //             _id: 0,
+    //             id: { $toString: '$_id' },
+    //             typeOf: 1,
+    //             status: 1
+    //         })
+    //         .limit(params.limit)
+    //         .setOptions({ maxTimeMS: MONGO_MAX_TIME_MS })
+    //         .lean<Pick<factory.transaction.ITransaction<factory.transactionType>, 'id' | 'status' | 'typeOf'>[]>()
+    //         .exec();
+    //     if (delayedTransactions.length > 0) {
+    //         delayedTransactions.forEach((delayedTransaction) => {
+    //             transactionEventEmitter.emitTransactionStatusChanged({
+    //                 id: delayedTransaction.id,
+    //                 typeOf: delayedTransaction.typeOf,
+    //                 status: delayedTransaction.status
+    //             });
+    //         });
+    //     }
+    //     return delayedTransactions;
+    // }
+    /**
+     * add(2025-03-13~)
+     */
+    async countPotentiallyExpired(params) {
+        const { expires, limit } = params;
+        const query = this.transactionModel.countDocuments({
+            status: { $eq: factory_1.factory.transactionStatusType.InProgress },
+            expires: { $lt: expires.$lt }
+        });
+        if (typeof limit === 'number' && limit >= 0) {
+            query.limit(limit);
+        }
+        const count = await query.setOptions({ maxTimeMS: settings_1.MONGO_MAX_TIME_MS })
+            .exec();
+        return { count };
+    }
+    /**
+     * add(2025-03-03~)
+     */
+    async makeOneExpiredIfExists(params) {
+        const endDate = new Date();
+        const sort = {
+            expires: factory_1.factory.sortType.Ascending
+        };
+        const doc = await this.transactionModel.findOneAndUpdate({
+            status: { $eq: factory_1.factory.transactionStatusType.InProgress },
+            expires: { $lt: params.expires.$lt }
+        }, {
+            status: factory_1.factory.transactionStatusType.Expired,
+            endDate
+        }, {
+            new: true,
+            projection: {
+                _id: 0,
+                id: { $toString: '$_id' },
+                typeOf: 1
+            }
+        })
+            .sort(sort)
+            .lean()
+            .exec();
+        if (doc === null) {
+            // no op
+            return;
+        }
+        else {
+            transaction_1.transactionEventEmitter.emitTransactionStatusChanged({
+                id: doc.id,
+                typeOf: doc.typeOf,
+                status: factory_1.factory.transactionStatusType.Expired
+            });
+            return doc;
+        }
+    }
+    // /**
+    //  * 取引を期限切れにする
+    //  */
+    // public async makeExpired(params: {
+    //     expires: { $lt: Date };
+    //     limit: number; // add limit(2025-02-27~)
+    // }): Promise<Pick<factory.transaction.ITransaction<factory.transactionType>, 'id' | 'typeOf'>[]> {
+    //     if (typeof params.limit !== 'number' || params.limit === 0) {
+    //         throw new factory.errors.ArgumentNull('limit');
+    //     }
+    //     const sort: { [key in keyof factory.transaction.ITransaction<factory.transactionType>]?: factory.sortType } = {
+    //         expires: factory.sortType.Ascending
+    //     };
+    //     // IDをemitしたいのでまずリスト検索(2023-04-27~)
+    //     const expiringTransactions =
+    //         await this.transactionModel.find({
+    //             status: { $eq: factory.transactionStatusType.InProgress },
+    //             expires: { $lt: params.expires.$lt }
+    //         })
+    //             .select({
+    //                 _id: 0,
+    //                 id: { $toString: '$_id' },
+    //                 typeOf: 1
+    //             })
+    //             .limit(params.limit)
+    //             .sort(sort) // sort(2025-03-03~)
+    //             .setOptions({ maxTimeMS: MONGO_MAX_TIME_MS })
+    //             .lean<Pick<factory.transaction.ITransaction<factory.transactionType>, 'id' | 'typeOf'>[]>()
+    //             .exec();
+    //     if (expiringTransactions.length > 0) {
+    //         // ステータスと期限を見て更新
+    //         await this.transactionModel.updateMany(
+    //             {
+    //                 _id: { $in: expiringTransactions.map((t) => t.id) },
+    //                 status: { $eq: factory.transactionStatusType.InProgress },
+    //                 expires: { $lt: params.expires.$lt }
+    //             },
+    //             {
+    //                 status: factory.transactionStatusType.Expired,
+    //                 endDate: new Date()
+    //             }
+    //         )
+    //             .exec();
+    //         expiringTransactions.forEach((expiringTransaction) => {
+    //             transactionEventEmitter.emitTransactionStatusChanged({
+    //                 id: expiringTransaction.id,
+    //                 typeOf: expiringTransaction.typeOf,
+    //                 status: factory.transactionStatusType.Expired
+    //             });
+    //         });
+    //     }
+    //     return expiringTransactions;
+    // }
+    async findByIdAndDelete(params) {
+        await this.transactionModel.findByIdAndDelete(params.id)
+            .exec();
+    }
+    async unsetUnnecessaryFields(params) {
+        return this.transactionModel.updateMany(params.filter, { $unset: params.$unset }, { timestamps: false })
+            .exec();
+    }
+    getCursor(conditions, projection, sort) {
+        return this.transactionModel.find(conditions, projection)
+            .sort({ startDate: (sort === factory_1.factory.sortType.Ascending) ? sort : factory_1.factory.sortType.Descending })
+            .cursor();
+    }
+}
+exports.AdminTransactionRepo = AdminTransactionRepo;

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

@@ -0,0 +1,43 @@
+import type { Connection } from 'mongoose';
+import { factory } from '../factory';
+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[];
+}
+/**
+ * 資産取引集計リポジトリ
+ */
+export declare class AggregateAssetTransactionRepo {
+    private readonly transactionModel;
+    constructor(connection: Connection);
+    aggregateAssetTransaction(params: {
+        project?: {
+            id?: {
+                $eq?: string;
+                $ne?: string;
+            };
+        };
+        startFrom: Date;
+        startThrough: Date;
+        typeOf: factory.assetTransactionType;
+    }): Promise<IAggregateReserve>;
+    private agggregateByStatus;
+}
+export {};

package/lib/chevre/repo/aggregateAssetTransaction.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AggregateAssetTransactionRepo = void 0;
+const assetTransaction_1 = require("./mongoose/schemas/assetTransaction");
+const factory_1 = require("../factory");
+/**
+ * 資産取引集計リポジトリ
+ */
+class AggregateAssetTransactionRepo {
+    transactionModel;
+    constructor(connection) {
+        this.transactionModel = connection.model(assetTransaction_1.modelName, (0, assetTransaction_1.createSchema)());
+    }
+    async aggregateAssetTransaction(params) {
+        const statuses = await Promise.all([
+            factory_1.factory.transactionStatusType.Confirmed,
+            factory_1.factory.transactionStatusType.Canceled,
+            factory_1.factory.transactionStatusType.Expired
+        ].map(async (transactionStatus) => {
+            const matchConditions = {
+                startDate: {
+                    $gte: params.startFrom,
+                    $lte: params.startThrough
+                },
+                typeOf: { $eq: params.typeOf },
+                status: { $eq: transactionStatus },
+                ...(typeof params.project?.id?.$ne === 'string')
+                    ? { 'project.id': { $ne: params.project.id.$ne } }
+                    : undefined,
+                ...(typeof params.project?.id?.$eq === 'string')
+                    ? { 'project.id': { $eq: params.project.id.$eq } }
+                    : undefined
+            };
+            return this.agggregateByStatus({ matchConditions, status: transactionStatus });
+        }));
+        return { statuses };
+    }
+    async agggregateByStatus(params) {
+        const matchConditions = params.matchConditions;
+        const transactionStatus = params.status;
+        const aggregations = await this.transactionModel.aggregate([
+            {
+                $match: matchConditions
+            },
+            {
+                $project: {
+                    duration: { $subtract: ['$endDate', '$startDate'] },
+                    graceTime: {
+                        $cond: {
+                            if: { $eq: ['$typeOf', factory_1.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();
+        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,
+                rank: Math.floor(aggregations[0].transactionCount * percentile / 100)
+            };
+        });
+        const aggregations2 = await 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: {
+                ...aggregations[0],
+                ...aggregations2[0]
+            }
+        };
+    }
+}
+exports.AggregateAssetTransactionRepo = AggregateAssetTransactionRepo;