@chevre/domain 26.0.0-alpha.9 → 26.0.0

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;

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

@@ -0,0 +1,39 @@
+import type { Connection } from 'mongoose';
+import { factory } from '../factory';
+interface IAggregationByStatus {
+    transactionCount: number;
+    avgDuration: number;
+    maxDuration: number;
+    minDuration: number;
+    percentilesDuration: {
+        name: string;
+        value: number;
+    }[];
+}
+interface IStatus {
+    status: factory.transactionStatusType;
+    aggregation: IAggregationByStatus;
+}
+export interface IAggregatePlaceOrder {
+    statuses: IStatus[];
+}
+/**
+ * 取引集計リポジトリ
+ */
+export declare class AggregateTransactionRepo {
+    private readonly transactionModel;
+    constructor(connection: Connection);
+    aggregatePlaceOrder(params: {
+        project?: {
+            id?: {
+                $ne?: string;
+            };
+        };
+        startFrom: Date;
+        startThrough: Date;
+        typeOf: factory.transactionType;
+        clientId?: string;
+    }): Promise<IAggregatePlaceOrder>;
+    private agggregateByStatus;
+}
+export {};

package/lib/chevre/repo/aggregateTransaction.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AggregateTransactionRepo = void 0;
+const factory_1 = require("../factory");
+const transaction_1 = require("./mongoose/schemas/transaction");
+/**
+ * 取引集計リポジトリ
+ */
+class AggregateTransactionRepo {
+    transactionModel;
+    constructor(connection) {
+        this.transactionModel = connection.model(transaction_1.modelName, (0, transaction_1.createSchema)());
+    }
+    async aggregatePlaceOrder(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.clientId === 'string')
+                    // customerIdentifierAll.push();
+                    ? {
+                        'agent.identifier': {
+                            $exists: true,
+                            $all: [{ name: 'clientId', value: params.clientId }]
+                        }
+                    }
+                    : 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'] },
+                    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'
+                }
+            }
+        ])
+            .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
+                        };
+                    })
+                    // totalPrice: 0,
+                    // maxPrice: 0,
+                    // minPrice: 0,
+                    // avgPrice: 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'
+                    // result: '$result',
+                    // price: {
+                    //     $cond: {
+                    //         if: { $isNumber: '$result.order.price' },
+                    //         then: '$result.order.price',
+                    //         else: 0
+                    //     }
+                    // }
+                }
+            },
+            { $sort: { duration: 1 } },
+            {
+                $group: {
+                    _id: '$typeOf',
+                    durations: { $push: '$duration' }
+                    // totalPrice: { $sum: '$price' },
+                    // maxPrice: { $max: '$price' },
+                    // minPrice: { $min: '$price' },
+                    // avgPrice: { $avg: '$price' }
+                }
+            },
+            {
+                $project: {
+                    _id: 0,
+                    percentilesDuration: ranks4percentile.map((rank) => {
+                        return {
+                            name: String(rank.percentile),
+                            value: { $arrayElemAt: ['$durations', rank.rank] }
+                        };
+                    })
+                    // totalPrice: '$totalPrice',
+                    // maxPrice: '$maxPrice',
+                    // minPrice: '$minPrice',
+                    // avgPrice: '$avgPrice'
+                }
+            }
+        ])
+            .exec();
+        return {
+            status: transactionStatus,
+            aggregation: {
+                ...aggregations[0],
+                ...aggregations2[0]
+            }
+        };
+    }
+}
+exports.AggregateTransactionRepo = AggregateTransactionRepo;

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

@@ -0,0 +1,35 @@
+import { Connection } from 'mongoose';
+import { factory } from '../factory';
+import type { IAggregateAction } from './aggregateAction';
+type IAvailableActionType = factory.actionType.UseAction;
+/**
+ * 予約使用アクション集計リポジトリ
+ */
+export declare class AggregateUseActionRepo {
+    private readonly useActionModel;
+    constructor(connection: Connection);
+    /**
+     * アクションタイプによる汎用的な集計
+     */
+    aggregateByTypeOf(params: {
+        project?: {
+            id?: {
+                $ne?: string;
+            };
+        };
+        startFrom: Date;
+        startThrough: Date;
+        typeOf: IAvailableActionType;
+    }): Promise<IAggregateAction>;
+    aggregateCheckMovieTicketAction(params: {
+        project?: {
+            id?: {
+                $ne?: string;
+            };
+        };
+        startFrom: Date;
+        startThrough: Date;
+    }): Promise<IAggregateAction>;
+    private agggregateByStatus;
+}
+export {};

package/lib/chevre/repo/aggregateUseAction.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AggregateUseActionRepo = void 0;
+const factory_1 = require("../factory");
+const use_1 = require("./mongoose/schemas/action/use");
+/**
+ * 予約使用アクション集計リポジトリ
+ */
+class AggregateUseActionRepo {
+    useActionModel;
+    constructor(connection) {
+        this.useActionModel = connection.model(use_1.modelName, (0, use_1.createSchema)());
+    }
+    /**
+     * アクションタイプによる汎用的な集計
+     */
+    async aggregateByTypeOf(params) {
+        const statuses = await Promise.all([
+            factory_1.factory.actionStatusType.CompletedActionStatus,
+            factory_1.factory.actionStatusType.CanceledActionStatus,
+            factory_1.factory.actionStatusType.FailedActionStatus
+        ].map(async (actionStatus) => {
+            const matchConditions = {
+                startDate: {
+                    $gte: params.startFrom,
+                    $lte: params.startThrough
+                },
+                typeOf: { $eq: params.typeOf },
+                actionStatus: { $eq: actionStatus },
+                ...(typeof params.project?.id?.$ne === 'string')
+                    ? { 'project.id': { $ne: params.project.id.$ne } }
+                    : undefined
+            };
+            return this.agggregateByStatus({ matchConditions, actionStatus });
+        }));
+        return { statuses };
+    }
+    async aggregateCheckMovieTicketAction(params) {
+        const statuses = await Promise.all([
+            factory_1.factory.actionStatusType.CompletedActionStatus,
+            factory_1.factory.actionStatusType.CanceledActionStatus,
+            factory_1.factory.actionStatusType.FailedActionStatus
+        ].map(async (actionStatus) => {
+            const matchConditions = {
+                startDate: {
+                    $gte: params.startFrom,
+                    $lte: params.startThrough
+                },
+                typeOf: { $eq: factory_1.factory.actionType.CheckAction },
+                'object.typeOf': {
+                    $exists: true,
+                    $eq: factory_1.factory.service.paymentService.PaymentServiceType.MovieTicket
+                },
+                actionStatus: { $eq: actionStatus },
+                ...(typeof params.project?.id?.$ne === 'string')
+                    ? { 'project.id': { $ne: params.project.id.$ne } }
+                    : undefined
+            };
+            return this.agggregateByStatus({ matchConditions, actionStatus });
+        }));
+        return { statuses };
+    }
+    async agggregateByStatus(params) {
+        const aggregations = await this.useActionModel.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();
+        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,
+                rank: Math.floor(aggregations[0].actionCount * percentile / 100)
+            };
+        });
+        const aggregations2 = await this.useActionModel.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: {
+                ...aggregations[0],
+                ...aggregations2[0]
+            }
+        };
+    }
+}
+exports.AggregateUseActionRepo = AggregateUseActionRepo;

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

@@ -22,14 +22,6 @@ export declare class AggregationRepo {
             $lte?: Date;
         };
     }): Promise<IAggregation[]>;
-    /**
-     * 不要な集計を削除する
-     */
-    deleteAggregateStartPassedCertainPeriod(params: {
-        aggregateStart: {
-            $lt: Date;
-        };
-    }): Promise<import("mongodb").DeleteResult>;
     unsetUnnecessaryFields(params: {
         filter: any;
         $unset: any;

package/lib/chevre/repo/aggregation.js

@@ -47,16 +47,6 @@ class AggregationRepo {
             .sort({ aggregateStart: factory_1.factory.sortType.Ascending })
             .exec();
     }
-    /**
-     * 不要な集計を削除する
-     */
-    async deleteAggregateStartPassedCertainPeriod(params) {
-        const filter = {
-            aggregateStart: { $lt: params.aggregateStart.$lt }
-        };
-        return this.aggregationModel.deleteMany(filter)
-            .exec();
-    }
     async unsetUnnecessaryFields(params) {
         return this.aggregationModel.updateMany(params.filter, { $unset: params.$unset }, { timestamps: false })
             .exec();