@chevre/domain 21.27.0-alpha.9 → 21.27.0

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

@@ -33,8 +33,8 @@ export interface IAttributes4patchUpdate<T extends factory.eventType> {
 export interface IUpdateAggregateReservationParams {
     $set: {
         updatedAt: Date;
-        aggregateReservation: factory.event.screeningEvent.IAggregateReservation;
-        aggregateOffer?: factory.event.screeningEvent.IAggregateOffer;
+        aggregateReservation: factory.event.event.IAggregateReservation;
+        aggregateOffer?: Pick<factory.event.event.IAggregateOffer, 'aggregateDate' | 'offerCount' | 'typeOf'>;
         maximumAttendeeCapacity?: number;
         remainingAttendeeCapacity?: number;
         checkInCount?: number;
@@ -46,15 +46,6 @@ export interface IUpdateAggregateReservationParams {
         remainingAttendeeCapacity?: '';
     };
 }
-export interface IUpdateAggregateUseActionsParams {
-    $set: {
-        updatedAt: Date;
-        aggregateEntranceGate: factory.event.screeningEvent.IAggregateEntranceGate;
-    };
-    $unset: {
-        noExistingAttributeName: 1;
-    };
-}
 export type ISearchConditions<T extends factory.eventType> = factory.event.ISearchConditions<T>;
 interface IAggregationByStatus {
     eventCount: number;
@@ -77,7 +68,7 @@ interface IStatus {
 interface IAggregateEvent {
     statuses: IStatus[];
 }
-type IKeyOfProjection<T extends factory.eventType> = keyof factory.event.IEvent<T> | '_id' | '__v' | 'createdAt' | 'updatedAt';
+type IKeyOfProjection<T extends factory.eventType> = keyof factory.event.IEvent<T> | '_id' | '__v' | 'createdAt' | 'updatedAt' | 'aggregateEntranceGate' | 'aggregateOffer';
 type IUnset<T extends factory.eventType> = {
     [key in keyof factory.event.IEvent<T>]?: 1;
 };
@@ -166,7 +157,7 @@ export declare class MongoRepository {
     /**
      * イベントを検索する
      */
-    search<T extends factory.eventType>(params: ISearchConditions<T>, inclusion: IKeyOfProjection<T>[], exclusion: IKeyOfProjection<T>[]): Promise<factory.event.IEvent<T>[]>;
+    search<T extends factory.eventType>(params: ISearchConditions<T>, inclusion: IKeyOfProjection<T>[], exclusion: IKeyOfProjection<T>[]): Promise<Omit<factory.event.IEvent<T>, 'aggregateEntranceGate' | 'aggregateOffer'>[]>;
     searchIds<T extends factory.eventType>(params: ISearchConditions<T>): Promise<string[]>;
     findMinimizedIndividualEventById<T extends factory.eventType.ScreeningEvent | factory.eventType.Event>(params: {
         id: string;
@@ -281,6 +272,17 @@ export declare class MongoRepository {
             $lte: Date;
         };
     }): Promise<import("mongodb").DeleteResult>;
+    deleteManyEndedByProject(params: {
+        typeOf: {
+            $in: factory.eventType[];
+        };
+        project: {
+            id: string;
+        };
+        endDate: {
+            $lte: Date;
+        };
+    }): Promise<import("mongodb").DeleteResult>;
     deleteByProject(params: {
         project: {
             id: string;
@@ -291,7 +293,7 @@ export declare class MongoRepository {
      */
     updateAggregationById<T extends factory.eventType>(params: {
         id: string;
-    }, update: IUpdateAggregateReservationParams | IUpdateAggregateUseActionsParams): Promise<factory.event.IEvent<T>>;
+    }, update: IUpdateAggregateReservationParams): Promise<Pick<factory.event.IEvent<T>, 'id' | 'typeOf' | 'project'>>;
     bulkWrite(bulkWriteOps: any[]): Promise<BulkWriteResult & {
         mongoose?: {
             validationErrors: import("mongoose").Error[];

package/lib/chevre/repo/event.js

@@ -812,9 +812,7 @@ class MongoRepository {
     /**
      * イベントを検索する
      */
-    search(params, 
-    // projection?: IProjection<T>
-    inclusion, exclusion) {
+    search(params, inclusion, exclusion) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
             const conditions = MongoRepository.CREATE_MONGO_CONDITIONS(params);
@@ -836,21 +834,7 @@ class MongoRepository {
                     });
                 }
             }
-            // const positiveProjectionExists: boolean = (projection !== undefined && projection !== null)
-            //     ? Object.values(projection)
-            //         .some((value) => value !== 0)
-            //     : false;
-            const query = this.eventModel.find({ $and: conditions }, projection
-            // :1対応(2023-01-25~)
-            // (positiveProjectionExists)
-            //     ? projection
-            //     : {
-            //         ...projection,
-            //         __v: 0,
-            //         createdAt: 0,
-            //         updatedAt: 0
-            //     }
-            );
+            const query = this.eventModel.find({ $and: conditions }, projection);
             if (typeof params.limit === 'number' && params.limit > 0) {
                 const page = (typeof params.page === 'number' && params.page > 0) ? params.page : 1;
                 query.limit(params.limit)
@@ -874,6 +858,45 @@ class MongoRepository {
                 .then((docs) => docs.map((doc) => doc.toObject()));
         });
     }
+    // イベント集計検索廃止(2024-03-28~)
+    // public async searchAggregations(
+    //     params: Pick<
+    //         ISearchConditions<factory.eventType.ScreeningEvent>,
+    //         'page' | 'limit' | 'sort' | 'project' | 'typeOf' | 'id' | 'startFrom' | 'startThrough' | 'organizer'
+    //     >,
+    //     inclusion: ('aggregateEntranceGate' | 'aggregateOffer' | 'aggregateReservation')[]
+    // ): Promise<Pick<
+    //     factory.event.IEvent<factory.eventType.ScreeningEvent>,
+    //     'aggregateEntranceGate' | 'aggregateOffer' | 'aggregateReservation' | 'id'
+    // >[]> {
+    //     const conditions = MongoRepository.CREATE_MONGO_CONDITIONS<factory.eventType.ScreeningEvent>(params);
+    //     let projection: IProjection<factory.eventType.ScreeningEvent> = {};
+    //     if (Array.isArray(inclusion) && inclusion.length > 0) {
+    //         inclusion.forEach((field) => {
+    //             projection[field] = 1;
+    //         });
+    //     } else {
+    //         projection = {
+    //             aggregateEntranceGate: 1,
+    //             aggregateOffer: 1,
+    //             aggregateReservation: 1
+    //         };
+    //     }
+    //     const query = this.eventModel.find({ $and: conditions }, projection);
+    //     if (typeof params.limit === 'number' && params.limit > 0) {
+    //         const page: number = (typeof params.page === 'number' && params.page > 0) ? params.page : 1;
+    //         query.limit(params.limit)
+    //             .skip(params.limit * (page - 1));
+    //     }
+    //     // tslint:disable-next-line:no-single-line-block-comment
+    //     /* istanbul ignore else */
+    //     if (params.sort?.startDate !== undefined) {
+    //         query.sort({ startDate: params.sort.startDate });
+    //     }
+    //     return query.setOptions({ maxTimeMS: MONGO_MAX_TIME_MS })
+    //         .exec()
+    //         .then((docs) => docs.map((doc) => doc.toObject()));
+    // }
     searchIds(params) {
         return __awaiter(this, void 0, void 0, function* () {
             const conditions = MongoRepository.CREATE_MONGO_CONDITIONS(params);
@@ -1038,6 +1061,16 @@ class MongoRepository {
                 .exec();
         });
     }
+    deleteManyEndedByProject(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.eventModel.deleteMany({
+                typeOf: { $in: params.typeOf.$in },
+                'project.id': { $eq: params.project.id },
+                endDate: { $lte: params.endDate.$lte }
+            })
+                .exec();
+        });
+    }
     deleteByProject(params) {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.eventModel.deleteMany({
@@ -1049,9 +1082,18 @@ class MongoRepository {
     /**
      * 集計属性を更新する
      */
-    updateAggregationById(params, update) {
+    updateAggregationById(params, update
+    // | IUpdateAggregateOfferParams // 廃止(2024-03-28)
+    // | IUpdateAggregateUseActionsParams // 廃止(2024-03-28)
+    ) {
         return __awaiter(this, void 0, void 0, function* () {
-            const doc = yield this.eventModel.findOneAndUpdate({ _id: params.id }, update, { new: true })
+            const doc = yield this.eventModel.findOneAndUpdate({ _id: params.id }, update, {
+                new: true,
+                projection: {
+                    typeOf: 1,
+                    project: 1
+                }
+            })
                 .exec();
             if (doc === null) {
                 throw new factory.errors.NotFound(this.eventModel.modelName);

package/lib/chevre/repo/mongoose/schemas/action.js

@@ -387,6 +387,24 @@ const indexes = [
                 'instrument.transactionNumber': { $exists: true }
             }
         }
+    ],
+    [
+        { 'instrument.typeOf': 1, startDate: -1 },
+        {
+            name: 'searchByInstrumentTypeOf',
+            partialFilterExpression: {
+                'instrument.typeOf': { $exists: true }
+            }
+        }
+    ],
+    [
+        { 'object.transactionNumber': 1, startDate: -1 },
+        {
+            name: 'searchByObjectTransactionNumber',
+            partialFilterExpression: {
+                'object.transactionNumber': { $exists: true }
+            }
+        }
     ]
 ];
 exports.indexes = indexes;

package/lib/chevre/repo/mongoose/schemas/aggregateReservation.d.ts

@@ -0,0 +1,5 @@
+import { IndexDefinition, IndexOptions, Schema } from 'mongoose';
+declare const modelName = "AggregateReservation";
+declare const indexes: [d: IndexDefinition, o: IndexOptions][];
+declare function createSchema(): Schema;
+export { modelName, indexes, createSchema };

package/lib/chevre/repo/mongoose/schemas/aggregateReservation.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSchema = exports.indexes = exports.modelName = void 0;
+const mongoose_1 = require("mongoose");
+const writeConcern_1 = require("../writeConcern");
+const settings_1 = require("../../../settings");
+const modelName = 'AggregateReservation';
+exports.modelName = modelName;
+const schemaDefinition = {
+    project: { type: mongoose_1.SchemaTypes.Mixed, required: true },
+    typeOf: { type: String, required: true },
+    reservationFor: { type: mongoose_1.SchemaTypes.Mixed, required: true },
+    aggregateEntranceGate: mongoose_1.SchemaTypes.Mixed,
+    aggregateOffer: mongoose_1.SchemaTypes.Mixed
+};
+const schemaOptions = {
+    autoIndex: settings_1.MONGO_AUTO_INDEX,
+    autoCreate: false,
+    collection: 'aggregateReservations',
+    id: true,
+    read: settings_1.MONGO_READ_PREFERENCE,
+    writeConcern: writeConcern_1.writeConcern,
+    strict: true,
+    strictQuery: false,
+    timestamps: {
+        createdAt: 'createdAt',
+        updatedAt: 'updatedAt'
+    },
+    toJSON: {
+        getters: false,
+        virtuals: false,
+        minimize: false,
+        versionKey: false
+    },
+    toObject: {
+        getters: false,
+        virtuals: true,
+        minimize: false,
+        versionKey: false
+    }
+};
+const indexes = [
+    [
+        { createdAt: 1 },
+        { name: 'searchByCreatedAt' }
+    ],
+    [
+        { updatedAt: 1 },
+        { name: 'searchByUpdatedAt' }
+    ],
+    [
+        { 'reservationFor.startDate': 1 },
+        { name: 'searchByReservationForStartDate' }
+    ],
+    [
+        { 'project.id': 1, 'reservationFor.startDate': 1 },
+        { name: 'searchByProjectId' }
+    ],
+    [
+        { 'reservationFor.id': 1, 'reservationFor.startDate': 1 },
+        { name: 'searchByReservationForId' }
+    ],
+    [
+        { 'reservationFor.typeOf': 1, 'reservationFor.startDate': 1 },
+        { name: 'searchByReservationForTypeOf' }
+    ]
+];
+exports.indexes = indexes;
+/**
+ * 予約集計スキーマ
+ */
+let schema;
+function createSchema() {
+    if (schema === undefined) {
+        schema = new mongoose_1.Schema(schemaDefinition, schemaOptions);
+        if (settings_1.MONGO_AUTO_INDEX) {
+            indexes.forEach((indexParams) => {
+                schema === null || schema === void 0 ? void 0 : schema.index(...indexParams);
+            });
+        }
+    }
+    return schema;
+}
+exports.createSchema = createSchema;

package/lib/chevre/repo/mongoose/schemas/event.js

@@ -46,7 +46,7 @@ const schemaDefinition = {
     remainingAttendeeCapacity: { type: Number },
     checkInCount: { type: Number },
     attendeeCount: { type: Number },
-    aggregateEntranceGate: mongoose_1.SchemaTypes.Mixed,
+    // aggregateEntranceGate: SchemaTypes.Mixed, // 廃止(2024-03-29~)
     aggregateReservation: mongoose_1.SchemaTypes.Mixed,
     aggregateOffer: mongoose_1.SchemaTypes.Mixed,
     coaInfo: mongoose_1.SchemaTypes.Mixed

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

@@ -35,6 +35,11 @@ export type IUnitPriceOfferFromAggregateOffer = factory.unitPriceOffer.IUnitPric
     parentOffer?: {
         id: string;
     };
+    /**
+     * 単価オファーID
+     * 検索レスポンスに必ず含まれる
+     */
+    id: string;
 };
 export interface IPriceSpecificationConditionsOnSearchWithSortIndex {
     appliesToMovieTicket?: {

package/lib/chevre/repository.d.ts

@@ -9,6 +9,7 @@ import type { MongoRepository as AccountTransactionRepo } from './repo/accountTr
 import type { MongoRepository as ActionRepo } from './repo/action';
 import type { MongoRepository as AdditionalPropertyRepo } from './repo/additionalProperty';
 import type { MongoRepository as AggregateOfferRepo } from './repo/aggregateOffer';
+import type { MongoRepository as AggregateReservationRepo } from './repo/aggregateReservation';
 import type { MongoRepository as AggregationRepo } from './repo/aggregation';
 import type { MongoRepository as AssetTransactionRepo } from './repo/assetTransaction';
 import type { MongoRepository as CategoryCodeRepo } from './repo/categoryCode';
@@ -87,6 +88,10 @@ export type AggregateOffer = AggregateOfferRepo;
 export declare namespace AggregateOffer {
     function createInstance(...params: ConstructorParameters<typeof AggregateOfferRepo>): Promise<AggregateOfferRepo>;
 }
+export type AggregateReservation = AggregateReservationRepo;
+export declare namespace AggregateReservation {
+    function createInstance(...params: ConstructorParameters<typeof AggregateReservationRepo>): Promise<AggregateReservationRepo>;
+}
 export type Aggregation = AggregationRepo;
 export declare namespace Aggregation {
     function createInstance(...params: ConstructorParameters<typeof AggregationRepo>): Promise<AggregationRepo>;

package/lib/chevre/repository.js

@@ -9,8 +9,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Telemetry = exports.Task = exports.StockHolder = exports.ServiceOutputIdentifier = exports.ServiceOutput = exports.SellerPaymentAccepted = exports.Seller = exports.Role = exports.Reservation = exports.ProjectMakesOffer = exports.Project = exports.ProductOffer = exports.Product = exports.PriceSpecification = exports.place = exports.Place = exports.Permit = exports.Person = exports.paymentMethod = exports.PaymentServiceProvider = exports.PaymentService = exports.OwnershipInfo = exports.OrderNumber = exports.OrderInTransaction = exports.Order = exports.Offer = exports.OfferItemCondition = exports.OfferCatalogItem = exports.OfferCatalog = exports.Note = exports.MerchantReturnPolicy = exports.Member = exports.Event = exports.EmailMessage = exports.Customer = exports.CreativeWork = exports.ConfirmationNumber = exports.Comment = exports.Code = exports.CategoryCode = exports.AssetTransaction = exports.Aggregation = exports.AggregateOffer = exports.AdditionalProperty = exports.Action = exports.AccountTransaction = exports.AccountTitle = exports.AccountingReport = exports.Account = exports.AcceptedOffer = void 0;
-exports.rateLimit = exports.Trip = exports.TransactionNumber = exports.Transaction = void 0;
+exports.Task = exports.StockHolder = exports.ServiceOutputIdentifier = exports.ServiceOutput = exports.SellerPaymentAccepted = exports.Seller = exports.Role = exports.Reservation = exports.ProjectMakesOffer = exports.Project = exports.ProductOffer = exports.Product = exports.PriceSpecification = exports.place = exports.Place = exports.Permit = exports.Person = exports.paymentMethod = exports.PaymentServiceProvider = exports.PaymentService = exports.OwnershipInfo = exports.OrderNumber = exports.OrderInTransaction = exports.Order = exports.Offer = exports.OfferItemCondition = exports.OfferCatalogItem = exports.OfferCatalog = exports.Note = exports.MerchantReturnPolicy = exports.Member = exports.Event = exports.EmailMessage = exports.Customer = exports.CreativeWork = exports.ConfirmationNumber = exports.Comment = exports.Code = exports.CategoryCode = exports.AssetTransaction = exports.Aggregation = exports.AggregateReservation = exports.AggregateOffer = exports.AdditionalProperty = exports.Action = exports.AccountTransaction = exports.AccountTitle = exports.AccountingReport = exports.Account = exports.AcceptedOffer = void 0;
+exports.rateLimit = exports.Trip = exports.TransactionNumber = exports.Transaction = exports.Telemetry = void 0;
 var AcceptedOffer;
 (function (AcceptedOffer) {
     let repo;
@@ -115,6 +115,19 @@ var AggregateOffer;
     }
     AggregateOffer.createInstance = createInstance;
 })(AggregateOffer = exports.AggregateOffer || (exports.AggregateOffer = {}));
+var AggregateReservation;
+(function (AggregateReservation) {
+    let repo;
+    function createInstance(...params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (repo === undefined) {
+                repo = (yield Promise.resolve().then(() => require('./repo/aggregateReservation'))).MongoRepository;
+            }
+            return new repo(...params);
+        });
+    }
+    AggregateReservation.createInstance = createInstance;
+})(AggregateReservation = exports.AggregateReservation || (exports.AggregateReservation = {}));
 var Aggregation;
 (function (Aggregation) {
     let repo;

package/lib/chevre/service/aggregation/event/aggregateOffers.d.ts

@@ -0,0 +1,31 @@
+import type { MongoRepository as AggregateReservationRepo } from '../../../repo/aggregateReservation';
+import { MongoRepository as EventRepo } from '../../../repo/event';
+import type { MongoRepository as OfferRepo } from '../../../repo/offer';
+import type { MongoRepository as OfferCatalogRepo } from '../../../repo/offerCatalog';
+import { MongoRepository as PlaceRepo } from '../../../repo/place';
+import type { MongoRepository as ProductRepo } from '../../../repo/product';
+import { RedisRepository as OfferRateLimitRepo } from '../../../repo/rateLimit/offer';
+import type { MongoRepository as ReservationRepo } from '../../../repo/reservation';
+import type { StockHolderRepository as StockHolderRepo } from '../../../repo/stockHolder';
+import type { MongoRepository as TaskRepo } from '../../../repo/task';
+import * as factory from '../../../factory';
+type IAggregateOffersOperation<T> = (repos: {
+    aggregateReservation: AggregateReservationRepo;
+    event: EventRepo;
+    stockHolder: StockHolderRepo;
+    offer: OfferRepo;
+    offerCatalog: OfferCatalogRepo;
+    offerRateLimit: OfferRateLimitRepo;
+    place: PlaceRepo;
+    product: ProductRepo;
+    reservation: ReservationRepo;
+    task: TaskRepo;
+}) => Promise<T>;
+/**
+ * イベントに対するオファー集計
+ */
+declare function aggregateOffers(params: {
+    id: string;
+    typeOf: factory.eventType.ScreeningEvent | factory.eventType.Event;
+}): IAggregateOffersOperation<void>;
+export { aggregateOffers };