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

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

@@ -0,0 +1,102 @@
+import { Connection } from 'mongoose';
+import * as factory from '../factory';
+interface IAggregationByStatus {
+    actionCount: number;
+    avgDuration: number;
+    maxDuration: number;
+    minDuration: number;
+    percentilesDuration: {
+        name: string;
+        value: number;
+    }[];
+}
+interface IStatus {
+    status: factory.actionStatusType;
+    aggregation: IAggregationByStatus;
+}
+interface IAggregateAction {
+    statuses: IStatus[];
+}
+/**
+ * アクション集計リポジトリ
+ */
+export declare class AggregateActionRepo {
+    private readonly actionModel;
+    constructor(connection: Connection);
+    /**
+     * イベントと入場ゲート指定で予約使用アクションを集計する
+     * discontinue(2024-12-26~)
+     */
+    aggregateAuthorizeEventServiceOfferAction(params: {
+        project?: {
+            id?: {
+                $ne?: string;
+            };
+        };
+        startFrom: Date;
+        startThrough: Date;
+        typeOf: factory.actionType;
+    }): Promise<IAggregateAction>;
+    aggregateAuthorizePaymentAction(params: {
+        project?: {
+            id?: {
+                $ne?: string;
+            };
+        };
+        startFrom: Date;
+        startThrough: Date;
+        typeOf: factory.actionType;
+    }): Promise<IAggregateAction>;
+    aggregateAuthorizeOrderAction(params: {
+        project?: {
+            id?: {
+                $ne?: string;
+            };
+        };
+        startFrom: Date;
+        startThrough: Date;
+        typeOf: factory.actionType;
+    }): Promise<IAggregateAction>;
+    aggregateCancelReservationAction(params: {
+        project?: {
+            id?: {
+                $ne?: string;
+            };
+        };
+        startFrom: Date;
+        startThrough: Date;
+    }): Promise<IAggregateAction>;
+    /**
+     * アクションタイプによる汎用的な集計
+     */
+    aggregateByTypeOf(params: {
+        project?: {
+            id?: {
+                $ne?: string;
+            };
+        };
+        startFrom: Date;
+        startThrough: Date;
+        typeOf: factory.actionType;
+    }): Promise<IAggregateAction>;
+    aggregateCheckMovieTicketAction(params: {
+        project?: {
+            id?: {
+                $ne?: string;
+            };
+        };
+        startFrom: Date;
+        startThrough: Date;
+    }): Promise<IAggregateAction>;
+    aggregatePayMovieTicketAction(params: {
+        project?: {
+            id?: {
+                $ne?: string;
+            };
+        };
+        startFrom: Date;
+        startThrough: Date;
+    }): Promise<IAggregateAction>;
+    private agggregateByStatus;
+}
+export {};

package/lib/chevre/repo/aggregateAction.js

@@ -0,0 +1,378 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AggregateActionRepo = void 0;
+const factory = __importStar(require("../factory"));
+// import { MONGO_MAX_TIME_MS } from '../../settings';
+const action_1 = require("./mongoose/schemas/action");
+/**
+ * アクション集計リポジトリ
+ */
+class AggregateActionRepo {
+    actionModel;
+    // private readonly actionRecipeModel: IActionRecipeModel;
+    constructor(connection) {
+        this.actionModel = connection.model(action_1.modelName, (0, action_1.createSchema)());
+    }
+    /**
+     * イベントと入場ゲート指定で予約使用アクションを集計する
+     * discontinue(2024-12-26~)
+     */
+    // public async countUseActionsByEntranceGate(params: {
+    //     event: { id: string };
+    //     entranceGateIdentifier: string;
+    // }): Promise<IUseActionCountByOffer[]> {
+    //     return this.actionModel.aggregate([
+    //         {
+    //             $match: {
+    //                 actionStatus: { $eq: factory.actionStatusType.CompletedActionStatus }
+    //             }
+    //         },
+    //         {
+    //             $match: {
+    //                 typeOf: { $eq: factory.actionType.UseAction }
+    //             }
+    //         },
+    //         {
+    //             $match: {
+    //                 'object.typeOf': {
+    //                     $exists: true,
+    //                     $eq: factory.reservationType.EventReservation
+    //                 }
+    //             }
+    //         },
+    //         {
+    //             $match: {
+    //                 'object.reservationFor.id': {
+    //                     $exists: true,
+    //                     $eq: params.event.id
+    //                 }
+    //             }
+    //         },
+    //         {
+    //             $match: {
+    //                 'location.identifier': {
+    //                     $exists: true,
+    //                     $eq: params.entranceGateIdentifier
+    //                 }
+    //             }
+    //         },
+    //         {
+    //             $group: {
+    //                 _id: '$object.id',
+    //                 object: { $first: '$object' }
+    //             }
+    //         },
+    //         {
+    //             $group: {
+    //                 _id: '$object.reservedTicket.ticketType.id',
+    //                 useActionCount: {
+    //                     $sum: 1
+    //                 }
+    //             }
+    //         }
+    //     ])
+    //         .exec();
+    // }
+    async aggregateAuthorizeEventServiceOfferAction(params) {
+        const statuses = await Promise.all([
+            factory.actionStatusType.CompletedActionStatus,
+            factory.actionStatusType.CanceledActionStatus,
+            factory.actionStatusType.FailedActionStatus
+        ].map(async (actionStatus) => {
+            const matchConditions = {
+                startDate: {
+                    $gte: params.startFrom,
+                    $lte: params.startThrough
+                },
+                typeOf: { $eq: params.typeOf },
+                actionStatus: { $eq: actionStatus },
+                'object.typeOf': {
+                    $exists: true,
+                    $eq: factory.action.authorize.offer.eventService.ObjectType.SeatReservation
+                },
+                ...(typeof params.project?.id?.$ne === 'string')
+                    ? { 'project.id': { $ne: params.project.id.$ne } }
+                    : undefined
+            };
+            return this.agggregateByStatus({ matchConditions, actionStatus });
+        }));
+        return { statuses };
+    }
+    async aggregateAuthorizePaymentAction(params) {
+        const statuses = await Promise.all([
+            factory.actionStatusType.CompletedActionStatus,
+            factory.actionStatusType.CanceledActionStatus,
+            factory.actionStatusType.FailedActionStatus
+        ].map(async (actionStatus) => {
+            const matchConditions = {
+                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 params.project?.id?.$ne === 'string')
+                    ? { 'project.id': { $ne: params.project.id.$ne } }
+                    : undefined
+            };
+            return this.agggregateByStatus({ matchConditions, actionStatus });
+        }));
+        return { statuses };
+    }
+    async aggregateAuthorizeOrderAction(params) {
+        const statuses = await Promise.all([
+            factory.actionStatusType.CompletedActionStatus,
+            factory.actionStatusType.CanceledActionStatus,
+            factory.actionStatusType.FailedActionStatus
+        ].map(async (actionStatus) => {
+            const matchConditions = {
+                startDate: {
+                    $gte: params.startFrom,
+                    $lte: params.startThrough
+                },
+                typeOf: { $eq: params.typeOf },
+                actionStatus: { $eq: actionStatus },
+                'object.typeOf': {
+                    $exists: true,
+                    $eq: factory.order.OrderType.Order
+                },
+                ...(typeof params.project?.id?.$ne === 'string')
+                    ? { 'project.id': { $ne: params.project.id.$ne } }
+                    : undefined
+            };
+            return this.agggregateByStatus({ matchConditions, actionStatus });
+        }));
+        return { statuses };
+    }
+    async aggregateCancelReservationAction(params) {
+        const statuses = await Promise.all([
+            factory.actionStatusType.CompletedActionStatus,
+            factory.actionStatusType.CanceledActionStatus,
+            factory.actionStatusType.FailedActionStatus
+        ].map(async (actionStatus) => {
+            const matchConditions = {
+                startDate: {
+                    $gte: params.startFrom,
+                    $lte: params.startThrough
+                },
+                typeOf: { $eq: factory.actionType.CancelAction },
+                actionStatus: { $eq: actionStatus },
+                'object.typeOf': {
+                    $exists: true,
+                    $in: [
+                        // factory.reservationType.BusReservation,
+                        factory.reservationType.EventReservation,
+                        factory.reservationType.ReservationPackage
+                    ]
+                },
+                ...(typeof params.project?.id?.$ne === 'string')
+                    ? { 'project.id': { $ne: params.project.id.$ne } }
+                    : undefined
+            };
+            return this.agggregateByStatus({ matchConditions, actionStatus });
+        }));
+        return { statuses };
+    }
+    /**
+     * アクションタイプによる汎用的な集計
+     */
+    async aggregateByTypeOf(params) {
+        const statuses = await Promise.all([
+            factory.actionStatusType.CompletedActionStatus,
+            factory.actionStatusType.CanceledActionStatus,
+            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.actionStatusType.CompletedActionStatus,
+            factory.actionStatusType.CanceledActionStatus,
+            factory.actionStatusType.FailedActionStatus
+        ].map(async (actionStatus) => {
+            const matchConditions = {
+                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 params.project?.id?.$ne === 'string')
+                    ? { 'project.id': { $ne: params.project.id.$ne } }
+                    : undefined
+            };
+            return this.agggregateByStatus({ matchConditions, actionStatus });
+        }));
+        return { statuses };
+    }
+    async aggregatePayMovieTicketAction(params) {
+        const statuses = await Promise.all([
+            factory.actionStatusType.CompletedActionStatus,
+            factory.actionStatusType.CanceledActionStatus,
+            factory.actionStatusType.FailedActionStatus
+        ].map(async (actionStatus) => {
+            const matchConditions = {
+                startDate: {
+                    $gte: params.startFrom,
+                    $lte: params.startThrough
+                },
+                typeOf: { $eq: factory.actionType.PayAction },
+                'object.typeOf': {
+                    $exists: true,
+                    $eq: 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.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();
+        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.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: {
+                ...aggregations[0],
+                ...aggregations2[0]
+            }
+        };
+    }
+}
+exports.AggregateActionRepo = AggregateActionRepo;

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

@@ -59,11 +59,15 @@ export declare class AggregateOfferRepo {
         };
         id: string;
     }): Promise<void>;
-    getCursor(conditions: any, projection: any): import("mongoose").Cursor<Document<unknown, {}, IAggregateOfferDocType> & IAggregateOfferDocType & Required<{
+    getCursor(conditions: any, projection: any): import("mongoose").Cursor<Document<unknown, {}, IAggregateOfferDocType, import("./mongoose/virtuals").IVirtuals, {}> & Omit<IAggregateOfferDocType & Required<{
         _id: string;
-    }>, import("mongoose").QueryOptions<Document<unknown, {}, IAggregateOfferDocType> & IAggregateOfferDocType & Required<{
+    }> & {
+        __v: number;
+    }, "id"> & import("./mongoose/virtuals").IVirtuals, import("mongoose").QueryOptions<IAggregateOfferDocType>, (Document<unknown, {}, IAggregateOfferDocType, import("./mongoose/virtuals").IVirtuals, {}> & Omit<IAggregateOfferDocType & Required<{
         _id: string;
-    }>>>;
+    }> & {
+        __v: number;
+    }, "id"> & import("./mongoose/virtuals").IVirtuals) | null>;
     unsetUnnecessaryFields(params: {
         filter: FilterQuery<factory.aggregateOffer.IAggregateOffer>;
         $unset: any;
@@ -80,11 +84,11 @@ export declare class AggregateOfferRepo {
          */
         productType: factory.product.ProductType;
     }): Promise<{
-        bulkWriteResult: BulkWriteResult;
-        modifiedOffers: {
+        bulkWriteResult?: BulkWriteResult;
+        modifiedOffers?: {
             id: string;
         }[];
-    } | void>;
+    }>;
     /**
      * sskts専用オファー保管
      */

package/lib/chevre/repo/aggregateOffer.js

@@ -707,6 +707,7 @@ class AggregateOfferRepo {
                 .exec();
             return { bulkWriteResult, modifiedOffers };
         }
+        return {};
     }
     /**
      * sskts専用オファー保管