@chevre/domain 22.9.0-alpha.97 → 22.9.0-alpha.99

package/example/src/chevre/investigateEvents.ts

@@ -0,0 +1,86 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+// const project = { id: String(process.env.PROJECT_ID) };
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const eventRepo = await chevre.repository.Event.createInstance(mongoose.connection);
+
+    const cursor = eventRepo.getCursor(
+        {
+            'project.id': {
+                $nin: [
+                    'sskts-test',
+                    'sskts-production'
+                ]
+            },
+            startDate: { $gte: new Date('2025-04-10T00:00:00Z') }
+        },
+        {
+            offers: 1,
+            project: 1,
+            typeOf: 1,
+            startDate: 1,
+            location: 1,
+            aggregateReservation: 1
+        }
+    );
+    console.log('docs found');
+
+    let i = 0;
+    let hasNoSeatsCount = 0;
+    let tooManyReservationCount = 0;
+    let maxReservationCount = 0;
+    const targetIds: string[] = [];
+    const projectIds: string[] = [];
+    await cursor.eachAsync(async (doc) => {
+        i += 1;
+        const event: Pick<
+            chevre.factory.event.screeningEvent.IEvent, 'id' | 'offers' | 'startDate' | 'typeOf' | 'location' | 'project' | 'aggregateReservation'
+        > = doc.toObject();
+
+        // const hasMax = typeof event.location.maximumAttendeeCapacity === 'number';
+        const hasSeats = event.offers.itemOffered.serviceOutput?.reservedTicket?.ticketedSeat?.typeOf === chevre.factory.placeType.Seat;
+        if (!hasSeats) {
+            hasNoSeatsCount += 1;
+            targetIds.push(event.id);
+            projectIds.push(event.project.id);
+            console.log(
+                'hasNoSeatsCount:', hasNoSeatsCount,
+                event.id, event.project.id, event.startDate, i);
+        } else {
+            console.log(
+                'no', hasNoSeatsCount,
+                event.id, event.project.id, event.startDate, i);
+        }
+
+        const reservationCount = event.aggregateReservation?.reservationCount;
+        if (typeof reservationCount === 'number') {
+            maxReservationCount = Math.max(reservationCount, maxReservationCount);
+        }
+        const tooManyReservation = typeof event.aggregateReservation?.reservationCount === 'number'
+            // tslint:disable-next-line:no-magic-numbers
+            && event.aggregateReservation?.reservationCount > 2000;
+        if (tooManyReservation) {
+            tooManyReservationCount += 1;
+            console.log(
+                'tooManyReservationCount:', tooManyReservationCount,
+                event.id, event.project.id, event.startDate, i);
+        }
+
+    });
+
+    console.log(targetIds);
+    console.log(i, 'docs checked');
+    console.log(hasNoSeatsCount, 'docs hasNoSeatsCount');
+    console.log('projectIds:', [...new Set(projectIds)]);
+    console.log('maxReservationCount:', maxReservationCount);
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/investigateTransaction.ts

@@ -4,7 +4,7 @@ import * as mongoose from 'mongoose';
 
 import { chevre } from '../../../lib/index';
 
-// const project = { id: String(process.env.PROJECT_ID) };
+const project = { id: String(process.env.PROJECT_ID) };
 
 async function main() {
     await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
@@ -13,40 +13,52 @@ async function main() {
 
     const cursor = transactionRepo.getCursor(
         {
-            // typeOf: { $eq: chevre.factory.actionType.AuthorizeAction },
-            status: { $eq: chevre.factory.transactionStatusType.Confirmed },
+            'project.id': { $eq: project.id },
+            typeOf: { $eq: chevre.factory.transactionType.PlaceOrder },
+            status: {
+                $in: [
+                    chevre.factory.transactionStatusType.Canceled,
+                    chevre.factory.transactionStatusType.Expired
+                ]
+            },
             startDate: {
-                $gte: moment()
-                    // tslint:disable-next-line:no-magic-numbers
-                    .add(-1, 'days')
+                $gte: moment('2025-04-10T15:00:00Z')
+                    .toDate(),
+                $lte: moment('2025-04-11T01:00:00Z')
                     .toDate()
             }
         },
         {
-            // project: 1,
-            // typeOf: 1,
-            // startDate: 1,
-            // object: 1,
-            // result: 1
+            project: 1,
+            typeOf: 1,
+            startDate: 1,
+            object: 1,
+            result: 1,
+            agent: 1
         }
     );
     console.log('transactions found');
 
     let i = 0;
+    let transactionByMemberCount = 0;
     await cursor.eachAsync(async (doc) => {
         i += 1;
-        const transaction: chevre.factory.transaction.ITransaction<chevre.factory.transactionType> = doc.toObject();
-
-        const size = JSON.stringify(transaction).length;
-        // tslint:disable-next-line:no-magic-numbers
-        if (size > 4000) {
-            console.log(
-                'size:', JSON.stringify(transaction).length,
-                transaction.typeOf, transaction.project.id, transaction.startDate, transaction.id, i);
+        const transaction: Pick<
+            chevre.factory.transaction.ITransaction<chevre.factory.transactionType.PlaceOrder>,
+            'project' | 'object' | 'startDate' | 'result' | 'typeOf' | 'agent'
+        > = doc.toObject();
+
+        if (transaction.agent.id === '28v3ml7b8f74h2dqdvni7ntf25') {
+            const publishedPaymentMethodId = transaction.object.paymentMethods?.paymentMethodId;
+            if (typeof publishedPaymentMethodId === 'string') {
+                console.log(transaction.project.id, transaction.agent.id, publishedPaymentMethodId, transaction.startDate, i);
+                transactionByMemberCount += 1;
+            }
         }
     });
 
     console.log(i, 'transactions checked');
+    console.log(transactionByMemberCount, 'transactionByMember found');
 }
 
 main()

package/example/src/chevre/playAroundStockHolder.ts

@@ -0,0 +1,269 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+import * as redis from 'redis';
+// import { StockHolderAsAggregateReservationRepo } from '../../../lib/chevre/repo/stockHolderAsAggregateReservation';
+import { chevre } from '../../../lib/index';
+
+const project = { id: String(process.env.PROJECT_ID) };
+const eventId = 'sampleEventId';
+const eventStartDate = new Date('2025-05-01T00:00:00Z');
+const seatSection = 'SampleSectionNameXXXXXXXXXXXXXXXXXXX';
+// tslint:disable-next-line:no-magic-numbers prefer-array-literal
+const allSeatNumbers = [...Array(10000)].map((__, seatKey) => `SampleSeatNumber-${seatKey}`);
+const OPERATION_INTERVAL = 2000;
+
+mongoose.Model.on('index', (...args) => {
+    console.error('******** index event emitted. ********\n', args);
+});
+
+async function sleep(waitTime: number): Promise<void> {
+    return new Promise<void>((resolve) => {
+        setTimeout(
+            () => {
+                resolve();
+            },
+            waitTime
+        );
+    });
+}
+
+const client = redis.createClient<redis.RedisDefaultModules, Record<string, never>, Record<string, never>>({
+    socket: {
+        port: Number(<string>process.env.REDIS_PORT),
+        host: <string>process.env.REDIS_HOST
+    },
+    password: <string>process.env.REDIS_KEY
+})
+    .on('error', (err) => {
+        // eslint-disable-next-line no-console
+        console.error('createDefaultRedisClient: client onError:', err);
+        // reject(err);
+    });
+client.connect();
+mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+// tslint:disable-next-line:max-func-body-length
+async function lockSeatsForcibly() {
+    const stockHolderRepo = await chevre.repository.StockHolder.createInstance(client, mongoose.connection);
+    // const stockHolderAsAggregateReservationRepo = new StockHolderAsAggregateReservationRepo(mongoose.connection);
+
+    // const size = await stockHolderAsAggregateReservationRepo.getSize({
+    //     project: {
+    //         id: project.id
+    //     },
+    //     eventId,
+    //     startDate: eventStartDate,
+    //     hasTicketedSeat: true
+    // });
+    // console.log('size:', size);
+
+    // const newHolder = Date.now()
+    //     .toString();
+    // const lockResult = await stockHolderAsAggregateReservationRepo.lock({
+    //     project: {
+    //         id: project.id
+    //     },
+    //     eventId,
+    //     startDate: eventStartDate,
+    //     hasTicketedSeat: true,
+    //     // tslint:disable-next-line:prefer-array-literal
+    //     offers: [...Array(10000)].map((__, seatKey) => ({ seatSection, seatNumber: `A-${seatKey}` })),
+    //     expires: new Date(),
+    //     holder: newHolder
+    // });
+    // console.log('lockResult:', lockResult);
+
+    // return;
+
+    // const cursor = mongoStockHolderRepo.getCursor(
+    //     {
+    //         'reservationFor.id': { $eq: eventId }
+    //     },
+    //     {
+    //         _id: 1,
+    //         numSeats: 1,
+    //         subReservation: 1
+    //     }
+    // );
+    // console.log('docs found');
+
+    // await cursor.eachAsync(async (doc) => {
+    //     const stockHolder = doc.toObject();
+    //     if (stockHolder.numSeats !== stockHolder.subReservation.length) {
+    //         throw new Error(`${stockHolder._id} invalid`);
+    //     }
+
+    // });
+    // return;
+
+    console.log('counting unavailableOffers...');
+    const countUnavailableOffersMustBeZero = await stockHolderRepo.countUnavailableOffers({
+        event: {
+            id: 'xxxxxxxxx',
+            startDate: eventStartDate,
+            hasTicketedSeat: true
+        }
+    });
+    console.log('countUnavailableOffersMustBeZero:', countUnavailableOffersMustBeZero);
+
+    console.log('counting unavailableOffers...');
+    let countUnavailableOffersResult = await stockHolderRepo.countUnavailableOffers({
+        event: {
+            id: eventId,
+            startDate: eventStartDate,
+            hasTicketedSeat: true
+        }
+    });
+    console.log('countUnavailableOffersResult:', countUnavailableOffersResult);
+
+    await sleep(OPERATION_INTERVAL);
+    console.log('counting searching holders...');
+    const searchHoldersResult = await stockHolderRepo.searchHolders({
+        project: {
+            id: project.id
+        },
+        eventId,
+        startDate: eventStartDate,
+        hasTicketedSeat: true,
+        offers: [
+            // tslint:disable-next-line:no-magic-numbers
+            ...allSeatNumbers.slice(0, 100)
+                .map((seatNumber) => ({ seatSection, seatNumber }))
+            // { seatNumber: 'invalid', seatSection: 'invalid' }
+        ]
+    });
+    // console.log('searchHoldersResult:', searchHoldersResult);
+    console.log('searchHoldersResult.length:', searchHoldersResult.length);
+
+    // select 2 seats
+    // tslint:disable-next-line:insecure-random
+    const seatNumber1 = allSeatNumbers[Math.floor(allSeatNumbers.length * Math.random())];
+    const seatNumber2 = allSeatNumbers.filter((seatNumber) => seatNumber !== seatNumber1)[
+        // tslint:disable-next-line:insecure-random
+        Math.floor((allSeatNumbers.length - 1) * Math.random())
+    ];
+
+    const seatNumbers = [seatNumber1, seatNumber2];
+    console.log('seats selected.', seatNumbers);
+
+    let locked = false;
+    while (!locked) {
+        await sleep(OPERATION_INTERVAL);
+        const currentHolders: string[] = [];
+        for (const seatNumber of seatNumbers) {
+            const currentHolder = await stockHolderRepo.getHolder({
+                project: {
+                    id: project.id
+                },
+                eventId,
+                startDate: eventStartDate,
+                hasTicketedSeat: true,
+                offer: { seatSection, seatNumber }
+            });
+            if (typeof currentHolder === 'string') {
+                currentHolders.push(currentHolder);
+            }
+        }
+        console.log('currentHolders:', currentHolders);
+
+        try {
+            await sleep(OPERATION_INTERVAL);
+            const newHolder = Date.now()
+                .toString();
+            console.log('locking...', newHolder, seatSection, seatNumbers);
+            const lockResult = await stockHolderRepo.lock({
+                project: {
+                    id: project.id
+                },
+                eventId,
+                startDate: eventStartDate,
+                hasTicketedSeat: true,
+                offers: seatNumbers.map((seatNumber) => ({ seatSection, seatNumber })),
+                expires: new Date(),
+                holder: newHolder
+            });
+            // const lockResult = await stockHolderRepo.lockIfNotLimitExceeded(
+            //     {
+            //         project: {
+            //             id: project.id
+            //         },
+            //         eventId,
+            //         startDate: eventStartDate,
+            //         hasTicketedSeat: true,
+            //         offers: seatNumbers.map((seatNumber) => ({ seatSection, seatNumber })),
+            //         expires: new Date(),
+            //         holder: newHolder
+            //     },
+            //     // tslint:disable-next-line:no-magic-numbers
+            //     8
+            // );
+            console.log('lockResult:', lockResult, newHolder);
+            locked = true;
+        } catch (error) {
+            if (error instanceof chevre.factory.errors.AlreadyInUse) {
+                console.log('lockResult:', error.name, error.message);
+            } else {
+                console.error(error);
+            }
+        }
+
+        const holder = currentHolders[0];
+        if (typeof holder === 'string') {
+            for (const seatNumber of seatNumbers) {
+                await sleep(OPERATION_INTERVAL);
+                console.log('unlocking...', holder, seatSection, seatNumber);
+                const unlockResult = await stockHolderRepo.unlock({
+                    project: {
+                        id: project.id
+                    },
+                    eventId,
+                    startDate: eventStartDate,
+                    hasTicketedSeat: true,
+                    offer: { seatSection, seatNumber },
+                    holder
+                });
+                console.log('unlockResult:', unlockResult);
+            }
+        }
+    }
+
+    await sleep(OPERATION_INTERVAL);
+    countUnavailableOffersResult = await stockHolderRepo.countUnavailableOffers({
+        event: {
+            id: eventId,
+            startDate: eventStartDate,
+            hasTicketedSeat: true
+        }
+    });
+    console.log('countUnavailableOffersResult:', countUnavailableOffersResult);
+
+}
+
+const NUM_LOCK = 1;
+// const NUM_LOCK = 1000;
+const LOCK_INTERVAL = 1000;
+let i = 0;
+let lockedCount = 0;
+let timeout: NodeJS.Timeout;
+const processStartDate = new Date();
+function onSeatsLocked() {
+    lockedCount += 1;
+    console.log(lockedCount, 'lockSeatsForcibly executed!');
+    console.log('processed.', processStartDate, '~', new Date());
+}
+
+timeout = setInterval(
+    () => {
+        if (i >= NUM_LOCK) {
+            clearInterval(timeout);
+
+            return;
+        }
+
+        i += 1;
+        lockSeatsForcibly()
+            .then(onSeatsLocked)
+            .catch(console.error);
+    },
+    LOCK_INTERVAL
+);

package/example/src/chevre/publishConfimationNumber.ts

@@ -0,0 +1,27 @@
+// tslint:disable:no-console
+import * as redis from 'redis';
+import { chevre } from '../../../lib/index';
+
+// const project = { id: String(process.env.PROJECT_ID) };
+
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    const client = redis.createClient<redis.RedisDefaultModules, Record<string, never>, Record<string, never>>({
+        socket: {
+            port: Number(<string>process.env.REDIS_PORT),
+            host: <string>process.env.REDIS_HOST
+        },
+        password: <string>process.env.REDIS_KEY
+    });
+    await client.connect();
+
+    const confirmationNumberRepo = await chevre.repository.ConfirmationNumber.createInstance(client);
+    const result = await confirmationNumberRepo.publish({ orderDate: new Date() });
+    console.log(result);
+}
+
+main()
+    .then(() => {
+        console.log('success!');
+    })
+    .catch(console.error);

package/example/src/moment.ts

@@ -1,21 +1,22 @@
 // tslint:disable:no-console
-import * as moment from 'moment-timezone';
+import * as moment from 'moment';
 
-const importFrom = '2024-04-23T22:45:00.414Z';
-const importThrough = '2024-04-25T22:45:00.414Z';
-const targetImportFrom = moment(importFrom)
-    .tz('Asia/Tokyo')
-    .startOf('day');
-const targetImportThrough = moment(importThrough)
-    .tz('Asia/Tokyo')
-    .endOf('day');
-console.log(targetImportFrom.toDate(), targetImportThrough.toDate());
+const eventStartDate = '2025-04-10T01:00:00Z';
+// const timeFormat = 'HH:mm:ssZ';
+const time = '00:00:00+09:00';
+// const time = '00:00:00Z';
 
-const targetImportFrom2 = moment(`${moment(importFrom)
-    .tz('Asia/Tokyo')
-    .format('YYYY-MM-DD')}T00:00:00+09:00`);
-const targetImportThrough2 = moment(`${moment(importThrough)
-    .tz('Asia/Tokyo')
-    .format('YYYY-MM-DD')}T00:00:00+09:00`)
-    .add(1, 'day');
-console.log(targetImportFrom2.toDate(), targetImportThrough2.toDate());
+// tslint:disable-next-line:no-magic-numbers
+const offset = time.slice(8);
+console.log('offset:', offset);
+
+// const opensMoment = moment(time, timeFormat, true);
+// const utcOffset = opensMoment.utcOffset();
+
+// const eventStartDateMoment = moment.utc(eventStartDate);
+const eventStartDateMoment = moment(eventStartDate, true);
+console.log(eventStartDateMoment);
+console.log(eventStartDateMoment.utcOffset(offset));
+
+const usageDate = moment(`${eventStartDateMoment.format('YYYY-MM-DD')}T${time}`, true);
+console.log(usageDate);

package/example/src/mongoConnectionList.ts

@@ -0,0 +1,81 @@
+
+// tslint:disable:no-console no-magic-numbers no-null-keyword
+import * as mongoose from 'mongoose';
+
+const MONGOLAB_URI = String(process.env.MONGOLAB_URI);
+
+interface IConnectionByAppName {
+    connection: mongoose.Connection;
+    isReady: boolean;
+}
+const uniqueConnections: Record<string, IConnectionByAppName> = {};
+export async function getUniqueConnectionByAppName(params: { appName: string }): Promise<mongoose.Connection> {
+    const { appName } = params;
+    if (uniqueConnections[appName] === undefined) {
+        uniqueConnections[appName] = {
+            connection: mongoose.createConnection(MONGOLAB_URI, { appName }),
+            isReady: false
+        };
+        uniqueConnections[appName].connection.on('connected', () => console.log('connected'));
+        uniqueConnections[appName].connection.on('open', () => console.log('open'));
+        uniqueConnections[appName].connection.on('disconnected', () => console.log('disconnected'));
+        uniqueConnections[appName].connection.on('reconnected', () => console.log('reconnected'));
+        uniqueConnections[appName].connection.on('disconnecting', () => console.log('disconnecting'));
+        uniqueConnections[appName].connection.on('close', () => console.log('close'));
+    }
+    const conectionByAppName = uniqueConnections[appName];
+
+    if (!conectionByAppName.isReady) {
+        console.log('connecting(asPromise)...');
+        await conectionByAppName.connection.asPromise();
+        conectionByAppName.isReady = true;
+    } else {
+        console.log('is ready.');
+    }
+
+    return conectionByAppName.connection;
+}
+
+async function main() {
+    console.log(mongoose.connections.length, 'mongoose.connections found');
+
+    mongoose.connection.on('connected', () => console.log('connected'));
+    mongoose.connection.on('open', () => console.log('open'));
+    mongoose.connection.on('disconnected', () => console.log('disconnected'));
+    mongoose.connection.on('reconnected', () => console.log('reconnected'));
+    mongoose.connection.on('disconnecting', () => console.log('disconnecting'));
+    mongoose.connection.on('close', () => console.log('close'));
+    // await mongoose.connect(MONGOLAB_URI);
+
+    // const firstConnection = mongoose.createConnection(<string>process.env.MONGOLAB_URI);
+    // firstConnection.on('connected', () => console.log('connected'));
+    // firstConnection.on('open', () => console.log('open'));
+    // firstConnection.on('disconnected', () => console.log('disconnected'));
+    // firstConnection.on('reconnected', () => console.log('reconnected'));
+    // firstConnection.on('disconnecting', () => console.log('disconnecting'));
+    // firstConnection.on('close', () => console.log('close'));
+
+    // tslint:disable-next-line:prefer-array-literal
+    [...Array(10)].map(async (__, i) => {
+        getUniqueConnectionByAppName({ appName: 'xxx' })
+            .then(async (connectResult) => {
+                console.log('connected:', connectResult.id, i);
+                await getUniqueConnectionByAppName({ appName: 'xxx' });
+            });
+    });
+
+    console.log(mongoose.connections.length, 'mongoose.connections found');
+
+    // db.currentOp(true)
+    //     .inprog.forEach((op) => {
+    //         if (op.active = true && op.client != undefined) {
+    //             const miniOp = {
+    //                 client: op.client, description: op.desc
+    //             };
+    //             console.log(miniOp);
+    //         }
+    //     });
+}
+
+main()
+    .catch(console.error);

package/example/src/redisClientList.ts

@@ -55,14 +55,25 @@ async function main() {
     console.log('redisClient created.', redisClient.options?.name);
 
     const reply = await redisClient.CLIENT_LIST();
-    console.dir(reply, { depth: null });
+    // console.dir(reply, { depth: null });
     console.dir(
         reply.map(
             ({ id, name, age, idle, user, addr, flags }) => `${id}, ${name}, ${age}, ${idle}, ${user}, ${addr}, ${flags}`
         ),
         { depth: null }
     );
+    const connectRedisCount = reply.filter(({ name }) => name.slice(-13) === ':connectRedis')
+        .length;
+    const clientsByName: Record<string, any> = {};
+    reply.forEach(({ name }) => {
+        if (clientsByName[name] === undefined) {
+            clientsByName[name] = { count: 0 };
+        }
+        clientsByName[name].count += 1;
+    });
     console.log(reply.length, 'clients found');
+    console.log('connectRedisCount:', connectRedisCount);
+    console.log(clientsByName);
 }
 
 main()

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

@@ -120,6 +120,7 @@ export interface ISetting {
     userPoolIdOld?: string;
     userPoolIdNew?: string;
     waiter?: IWaiterSettings;
+    useMongoAsStockHolder?: boolean;
 }
 type IDocType = ISetting;
 type IModel = Model<IDocType>;

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

@@ -22,7 +22,8 @@ const schemaDefinition = {
     useInformResourceTypes: [String],
     userPoolIdOld: String,
     userPoolIdNew: String,
-    waiter: mongoose_1.SchemaTypes.Mixed
+    waiter: mongoose_1.SchemaTypes.Mixed,
+    useMongoAsStockHolder: Boolean
 };
 const schemaOptions = {
     autoIndex: settings_1.MONGO_AUTO_INDEX,
@@ -48,7 +49,12 @@ const schemaOptions = {
         versionKey: false
     }
 };
-const indexes = [];
+const indexes = [
+    [
+        { 'project.id': 1 },
+        { name: 'projectId' }
+    ]
+];
 exports.indexes = indexes;
 /**
  * 設定スキーマ

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

@@ -0,0 +1,28 @@
+import { IndexDefinition, IndexOptions, Model, Schema, SchemaDefinition } from 'mongoose';
+import * as factory from '../../../factory';
+interface ISubReservation {
+    identifier: string;
+    reservationNumber: string;
+}
+interface IAggregateReservation {
+    project: {
+        id: string;
+        typeOf: factory.organizationType.Project;
+    };
+    typeOf: 'AggregateReservation';
+    reservationCount: number;
+    reservationFor: {
+        id: string;
+        startDate: Date;
+    };
+    reservations: ISubReservation[];
+    expires: Date;
+}
+type IDocType = IAggregateReservation;
+type IModel = Model<IDocType>;
+type ISchemaDefinition = SchemaDefinition<IDocType>;
+type ISchema = Schema<IDocType, IModel, {}, {}, {}, {}, ISchemaDefinition, IDocType>;
+declare const modelName = "StockHolder";
+declare const indexes: [d: IndexDefinition, o: IndexOptions][];
+declare function createSchema(): ISchema;
+export { createSchema, IModel, ISubReservation, IAggregateReservation, indexes, modelName };