@chevre/domain 20.2.0-alpha.8 → 20.2.0

package/lib/chevre/repo/assetTransaction.js

@@ -536,5 +536,153 @@ class MongoRepository {
                 .exec();
         });
     }
+    aggregateAssetTransaction(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const statuses = yield Promise.all([
+                factory.transactionStatusType.Confirmed,
+                factory.transactionStatusType.Canceled,
+                factory.transactionStatusType.Expired
+            ].map((transactionStatus) => __awaiter(this, void 0, void 0, function* () {
+                var _a, _b;
+                const matchConditions = Object.assign({ startDate: {
+                        $gte: params.startFrom,
+                        $lte: params.startThrough
+                    }, typeOf: { $eq: params.typeOf }, status: { $eq: transactionStatus } }, (typeof ((_b = (_a = params.project) === null || _a === void 0 ? void 0 : _a.id) === null || _b === void 0 ? void 0 : _b.$ne) === 'string')
+                    ? { 'project.id': { $ne: params.project.id.$ne } }
+                    : undefined);
+                return this.agggregateByStatus({ matchConditions, status: transactionStatus });
+            })));
+            return { statuses };
+        });
+    }
+    // tslint:disable-next-line:max-func-body-length
+    agggregateByStatus(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const matchConditions = params.matchConditions;
+            const transactionStatus = params.status;
+            const aggregations = yield this.transactionModel.aggregate([
+                {
+                    $match: matchConditions
+                },
+                {
+                    $project: {
+                        duration: { $subtract: ['$endDate', '$startDate'] },
+                        graceTime: {
+                            $cond: {
+                                if: { $eq: ['$typeOf', factory.assetTransactionType.Reserve] },
+                                then: { $subtract: ['$object.reservationFor.startDate', '$startDate'] },
+                                else: 0
+                            }
+                        },
+                        status: '$status',
+                        startDate: '$startDate',
+                        endDate: '$endDate',
+                        typeOf: '$typeOf',
+                        reservationCount: {
+                            $cond: {
+                                if: { $isArray: '$object.subReservation' },
+                                then: { $size: '$object.subReservation' },
+                                else: 0
+                            }
+                        }
+                    }
+                },
+                {
+                    $group: {
+                        _id: '$typeOf',
+                        transactionCount: { $sum: 1 },
+                        maxDuration: { $max: '$duration' },
+                        minDuration: { $min: '$duration' },
+                        avgDuration: { $avg: '$duration' },
+                        reservationCount: { $sum: '$reservationCount' },
+                        maxGraceTime: { $max: '$graceTime' },
+                        minGraceTime: { $min: '$graceTime' },
+                        avgGraceTime: { $avg: '$graceTime' }
+                    }
+                },
+                {
+                    $project: {
+                        _id: 0,
+                        transactionCount: '$transactionCount',
+                        avgDuration: '$avgDuration',
+                        maxDuration: '$maxDuration',
+                        minDuration: '$minDuration',
+                        reservationCount: '$reservationCount',
+                        avgGraceTime: '$avgGraceTime',
+                        maxGraceTime: '$maxGraceTime',
+                        minGraceTime: '$minGraceTime'
+                    }
+                }
+            ])
+                .exec();
+            // tslint:disable-next-line:no-magic-numbers
+            const percents = [50, 95, 99];
+            if (aggregations.length === 0) {
+                return {
+                    status: transactionStatus,
+                    aggregation: {
+                        transactionCount: 0,
+                        avgDuration: 0,
+                        maxDuration: 0,
+                        minDuration: 0,
+                        percentilesDuration: percents.map((percent) => {
+                            return {
+                                name: String(percent),
+                                value: 0
+                            };
+                        }),
+                        reservationCount: 0,
+                        avgGraceTime: 0,
+                        maxGraceTime: 0,
+                        minGraceTime: 0
+                    }
+                };
+            }
+            const ranks4percentile = percents.map((percentile) => {
+                return {
+                    percentile,
+                    // tslint:disable-next-line:no-magic-numbers
+                    rank: Math.floor(aggregations[0].transactionCount * percentile / 100)
+                };
+            });
+            const aggregations2 = yield this.transactionModel.aggregate([
+                {
+                    $match: matchConditions
+                },
+                {
+                    $project: {
+                        duration: { $subtract: ['$endDate', '$startDate'] },
+                        status: '$status',
+                        startDate: '$startDate',
+                        endDate: '$endDate',
+                        typeOf: '$typeOf'
+                    }
+                },
+                { $sort: { duration: 1 } },
+                {
+                    $group: {
+                        _id: '$typeOf',
+                        durations: { $push: '$duration' }
+                    }
+                },
+                {
+                    $project: {
+                        _id: 0,
+                        percentilesDuration: ranks4percentile.map((rank) => {
+                            return {
+                                name: String(rank.percentile),
+                                value: { $arrayElemAt: ['$durations', rank.rank] }
+                            };
+                        })
+                    }
+                }
+            ])
+                .exec();
+            return {
+                status: transactionStatus,
+                aggregation: Object.assign(Object.assign({}, aggregations[0]), aggregations2[0])
+            };
+        });
+    }
 }
 exports.MongoRepository = MongoRepository;

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

@@ -1,7 +1,7 @@
 import { Connection } from 'mongoose';
 import * as factory from '../factory';
 import { modelName } from './mongoose/model/authorization';
-export declare type IData = any;
+export declare type IObject = factory.authorization.IObject;
 export declare type ICode = string;
 export { modelName };
 /**
@@ -19,7 +19,7 @@ export declare class MongoRepository {
             id: string;
             typeOf: factory.organizationType.Project;
         };
-        data: IData;
+        object: IObject;
         validFrom: Date;
         expiresInSeconds: number;
     }[]): Promise<factory.authorization.IAuthorization[]>;
@@ -32,22 +32,9 @@ export declare class MongoRepository {
             typeOf: factory.organizationType.Project;
         };
         code: ICode;
-    }): Promise<IData>;
+    }): Promise<IObject>;
     count(params: factory.authorization.ISearchConditions): Promise<number>;
     search(params: factory.authorization.ISearchConditions): Promise<factory.authorization.IAuthorization[]>;
-    /**
-     * コードを保管する
-     */
-    save(params: {
-        project: {
-            id: string;
-            typeOf: factory.organizationType.Project;
-        };
-        code: ICode;
-        data: IData;
-        validFrom: Date;
-        expiresInSeconds: number;
-    }[]): Promise<factory.authorization.IAuthorization[]>;
     deleteByCode(params: {
         code: string;
     }): Promise<{
@@ -55,4 +42,14 @@ export declare class MongoRepository {
         ok?: number;
         deletedCount?: number;
     } | null>;
+    /**
+     * 有効期限を一定期間過ぎた承認を削除する
+     */
+    deleteValidUntilPassedCertainPeriod(params: {
+        $lt: Date;
+    }): Promise<void>;
+    /**
+     * コードを保管する
+     */
+    private save;
 }

package/lib/chevre/repo/code.js

@@ -134,7 +134,7 @@ class MongoRepository {
                 return {
                     project: p.project,
                     code: code,
-                    data: p.data,
+                    object: p.object,
                     validFrom: p.validFrom,
                     expiresInSeconds: p.expiresInSeconds
                 };
@@ -204,6 +204,37 @@ class MongoRepository {
                 .then((docs) => docs.map((doc) => doc.toObject()));
         });
     }
+    deleteByCode(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.authorizationModel.deleteOne({
+                code: { $exists: true, $eq: params.code }
+            })
+                .exec()
+                .then((result) => {
+                return {
+                    n: result === null || result === void 0 ? void 0 : result.n,
+                    // opTime: result.opTime,
+                    ok: result === null || result === void 0 ? void 0 : result.ok,
+                    // operationTime,
+                    deletedCount: result === null || result === void 0 ? void 0 : result.deletedCount
+                };
+            });
+        });
+    }
+    /**
+     * 有効期限を一定期間過ぎた承認を削除する
+     */
+    deleteValidUntilPassedCertainPeriod(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.authorizationModel.deleteMany({
+                validUntil: {
+                    $exists: true,
+                    $lt: params.$lt
+                }
+            })
+                .exec();
+        });
+    }
     /**
      * コードを保管する
      */
@@ -218,7 +249,7 @@ class MongoRepository {
                         project: p.project,
                         typeOf: 'Authorization',
                         code: p.code,
-                        object: p.data,
+                        object: p.object,
                         validFrom: p.validFrom,
                         validUntil: validUntil
                     };
@@ -234,22 +265,5 @@ class MongoRepository {
             }
         });
     }
-    deleteByCode(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.authorizationModel.deleteOne({
-                code: { $exists: true, $eq: params.code }
-            })
-                .exec()
-                .then((result) => {
-                return {
-                    n: result === null || result === void 0 ? void 0 : result.n,
-                    // opTime: result.opTime,
-                    ok: result === null || result === void 0 ? void 0 : result.ok,
-                    // operationTime,
-                    deletedCount: result === null || result === void 0 ? void 0 : result.deletedCount
-                };
-            });
-        });
-    }
 }
 exports.MongoRepository = MongoRepository;

package/lib/chevre/repo/creativeWork.js

@@ -33,7 +33,7 @@ class MongoRepository {
     }
     // tslint:disable-next-line:max-func-body-length
     static CREATE_MONGO_CONDITIONS(params) {
-        var _a, _b, _c, _d, _e, _f;
+        var _a, _b, _c, _d, _e, _f, _g, _h;
         // MongoDB検索条件
         const andConditions = [
             {
@@ -69,20 +69,21 @@ class MongoRepository {
         if (typeof params.identifier === 'string') {
             if (params.identifier.length > 0) {
                 andConditions.push({
-                    identifier: {
-                        $exists: true,
-                        $regex: new RegExp(params.identifier)
-                    }
+                    identifier: { $regex: new RegExp(params.identifier) }
                 });
             }
         }
-        else if (params.identifier !== undefined && params.identifier !== null) {
-            if (typeof params.identifier.$eq === 'string') {
+        else {
+            const identifierEq = (_f = params.identifier) === null || _f === void 0 ? void 0 : _f.$eq;
+            if (typeof identifierEq === 'string') {
                 andConditions.push({
-                    identifier: {
-                        $exists: true,
-                        $eq: params.identifier.$eq
-                    }
+                    identifier: { $eq: identifierEq }
+                });
+            }
+            const identifierIn = (_g = params.identifier) === null || _g === void 0 ? void 0 : _g.$in;
+            if (Array.isArray(identifierIn)) {
+                andConditions.push({
+                    identifier: { $in: identifierIn }
                 });
             }
         }
@@ -155,7 +156,7 @@ class MongoRepository {
                 });
             }
         }
-        const additionalPropertyElemMatch = (_f = params.additionalProperty) === null || _f === void 0 ? void 0 : _f.$elemMatch;
+        const additionalPropertyElemMatch = (_h = params.additionalProperty) === null || _h === void 0 ? void 0 : _h.$elemMatch;
         if (additionalPropertyElemMatch !== undefined && additionalPropertyElemMatch !== null) {
             andConditions.push({
                 additionalProperty: {

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

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