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

package/example/src/chevre/aggregateEventReservation.ts

@@ -0,0 +1,37 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+import * as redis from 'redis';
+
+import { chevre } from '../../../lib/index';
+
+// const project = { id: <string>process.env.PROJECT_ID };
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI);
+    const client = redis.createClient({
+        host: process.env.REDIS_HOST,
+        port: Number(process.env.REDIS_PORT),
+        password: process.env.REDIS_KEY
+    });
+
+    // const now = new Date();
+    await chevre.service.aggregation.event.aggregateScreeningEvent({
+        id: 'alb35u7m4'
+    })({
+        event: new chevre.repository.Event(mongoose.connection),
+        eventAvailability: new chevre.repository.itemAvailability.ScreeningEvent(client),
+        offer: new chevre.repository.Offer(mongoose.connection),
+        offerRateLimit: new chevre.repository.rateLimit.Offer(client),
+        place: new chevre.repository.Place(mongoose.connection),
+        product: new chevre.repository.Product(mongoose.connection),
+        project: new chevre.repository.Project(mongoose.connection),
+        reservation: new chevre.repository.Reservation(mongoose.connection),
+        task: new chevre.repository.Task(mongoose.connection)
+    });
+}
+
+main()
+    .then(() => {
+        console.log('success!');
+    })
+    .catch(console.error);

package/example/src/chevre/aggregation/aggregateSystem.ts

@@ -0,0 +1,112 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../../lib/index';
+
+// const project = { id: <string>process.env.PROJECT_ID };
+const EXCLUDED_PROJECT_ID = process.env.EXCLUDED_PROJECT_ID;
+const AGGREGATE_DAYS = Number(process.env.AGGREGATE_DAYS);
+const AGGREGATE_CLIENT_IDS = (typeof process.env.AGGREGATE_CLIENT_IDS === 'string') ? process.env.AGGREGATE_CLIENT_IDS.split(',') : [];
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const aggregationRepo = new chevre.repository.Aggregation(mongoose.connection);
+    const eventRepo = new chevre.repository.Event(mongoose.connection);
+    const transactionRepo = new chevre.repository.Transaction(mongoose.connection);
+    const assetTransactionRepo = new chevre.repository.AssetTransaction(mongoose.connection);
+    const actionRepo = new chevre.repository.Action(mongoose.connection);
+    const taskRepo = new chevre.repository.Task(mongoose.connection);
+
+    await aggregationRepo.aggregationModel.deleteMany({
+        typeOf: { $in: ['AggregateOrder', 'AggregateReservation'] }
+    })
+        .exec();
+
+    await chevre.service.aggregation.system.aggregatePayTransaction({
+        aggregationDays: AGGREGATE_DAYS,
+        excludedProjectId: EXCLUDED_PROJECT_ID
+    })({
+        agregation: aggregationRepo,
+        assetTransaction: assetTransactionRepo
+    });
+
+    await chevre.service.aggregation.system.aggregateEvent({
+        aggregationDays: AGGREGATE_DAYS,
+        excludedProjectId: EXCLUDED_PROJECT_ID
+    })({
+        agregation: aggregationRepo,
+        event: eventRepo
+    });
+
+    await chevre.service.aggregation.system.aggregateTask({
+        aggregationDays: AGGREGATE_DAYS,
+        excludedProjectId: EXCLUDED_PROJECT_ID
+    })({
+        agregation: aggregationRepo,
+        task: taskRepo
+    });
+
+    await chevre.service.aggregation.system.aggregateReserveTransaction({
+        aggregationDays: AGGREGATE_DAYS,
+        excludedProjectId: EXCLUDED_PROJECT_ID
+    })({
+        agregation: aggregationRepo,
+        assetTransaction: assetTransactionRepo
+    });
+
+    await chevre.service.aggregation.system.aggregatePlaceOrder({
+        aggregationDays: AGGREGATE_DAYS,
+        excludedProjectId: EXCLUDED_PROJECT_ID,
+        clientIds: AGGREGATE_CLIENT_IDS
+    })({
+        agregation: aggregationRepo,
+        transaction: transactionRepo
+    });
+
+    await chevre.service.aggregation.system.aggregateAuthorizeOrderAction({
+        aggregationDays: AGGREGATE_DAYS,
+        excludedProjectId: EXCLUDED_PROJECT_ID
+    })({
+        agregation: aggregationRepo,
+        action: actionRepo
+    });
+
+    await chevre.service.aggregation.system.aggregateAuthorizeEventServiceOfferAction({
+        aggregationDays: AGGREGATE_DAYS,
+        excludedProjectId: EXCLUDED_PROJECT_ID
+    })({
+        agregation: aggregationRepo,
+        action: actionRepo
+    });
+
+    await chevre.service.aggregation.system.aggregateAuthorizePaymentAction({
+        aggregationDays: AGGREGATE_DAYS,
+        excludedProjectId: EXCLUDED_PROJECT_ID
+    })({
+        agregation: aggregationRepo,
+        action: actionRepo
+    });
+
+    await chevre.service.aggregation.system.aggregateUseAction({
+        aggregationDays: AGGREGATE_DAYS,
+        excludedProjectId: EXCLUDED_PROJECT_ID
+    })({
+        agregation: aggregationRepo,
+        action: actionRepo
+    });
+
+    await chevre.service.aggregation.system.aggregateCheckMovieTicketAction({
+        aggregationDays: AGGREGATE_DAYS,
+        excludedProjectId: EXCLUDED_PROJECT_ID
+    })({
+        agregation: aggregationRepo,
+        action: actionRepo
+    });
+}
+
+main()
+    .then(() => {
+        console.log('success!');
+    })
+    .catch(console.error);

package/example/src/chevre/findScreeningRoomsByBranchCode.ts

@@ -0,0 +1,27 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI);
+
+    const placeRepo = new chevre.repository.Place(mongoose.connection);
+
+    const event = await placeRepo.findScreeningRoomsByBranchCode({
+        branchCode: {
+            $eq: '20'
+        },
+        containedInPlace: {
+            id: {
+                $eq: '5bfb841d5a78d7948369979a'
+            }
+        }
+    });
+    console.log('room found', event);
+
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/importEventsFromCOA.ts

@@ -14,6 +14,7 @@ async function main() {
     const categoryCodeRepo = new chevre.repository.CategoryCode(mongoose.connection);
     const eventRepo = new chevre.repository.Event(mongoose.connection);
     const placeRepo = new chevre.repository.Place(mongoose.connection);
+    const sellerRepo = new chevre.repository.Seller(mongoose.connection);
 
     await chevre.service.event.importFromCOA({
         project: {
@@ -28,7 +29,13 @@ async function main() {
             .toDate(),
         saveMovieTheater: false,
         saveScreeningEventSeries: false
-    })({ action: actionRepo, categoryCode: categoryCodeRepo, event: eventRepo, place: placeRepo });
+    })({
+        action: actionRepo,
+        categoryCode: categoryCodeRepo,
+        event: eventRepo,
+        place: placeRepo,
+        seller: sellerRepo
+    });
     console.log('imported');
 }
 

package/example/src/chevre/migrateEventOffersItemOfferedAvailableChannel.ts

@@ -21,7 +21,8 @@ async function main() {
             typeOf: { $eq: chevre.factory.eventType.ScreeningEvent },
             startDate: {
                 $gte: moment()
-                    .add(-1, 'month')
+                    // tslint:disable-next-line:no-magic-numbers
+                    .add(-6, 'months')
                     .toDate()
             }
             // _id: { $eq: 'al6aff83w' }

package/example/src/chevre/migrateProjectSubscription.ts

@@ -0,0 +1,51 @@
+// tslint:disable:no-console
+// import * as moment from 'moment';
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const projectRepo = new chevre.repository.Project(mongoose.connection);
+
+    const cursor = projectRepo.getCursor(
+        {
+        },
+        {
+            // _id: 1,
+        }
+    );
+    console.log('projects found');
+
+    let i = 0;
+    let updateCount = 0;
+    // tslint:disable-next-line:max-func-body-length
+    await cursor.eachAsync(async (doc) => {
+        i += 1;
+        const project: chevre.factory.project.IProject = doc.toObject();
+
+        const useEventServiceAsProduct = project.subscription?.useEventServiceAsProduct;
+        const alreadyMigrated = useEventServiceAsProduct === true;
+
+        if (alreadyMigrated) {
+            console.log('already migrated.', project.id, i);
+        } else {
+            console.log(
+                'updating product...', project.id, i);
+            await projectRepo.findByIdAndIUpdate({
+                id: project.id,
+                subscription: { useEventServiceAsProduct: true }
+            });
+            updateCount += 1;
+            console.log('updated...', project.id, i);
+        }
+    });
+    console.log(i, 'projects checked');
+    console.log(updateCount, 'projects updated');
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/processReserve.ts

@@ -63,6 +63,8 @@ async function main() {
             ],
             reservationFor: { id: 'ckuz8uj0c' }
         },
+        validateEvent: false,
+        validateEventOfferPeriod: false,
         validateAppliesToMovieTicket: true
     })({
         eventAvailability: itemAvailabilityRepo,

package/example/src/chevre/searchEventIds.ts

@@ -0,0 +1,24 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+const PROJECT_ID = process.env.PROJECT_ID;
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI);
+
+    const eventRepo = new chevre.repository.Event(mongoose.connection);
+
+    const ids = await eventRepo.searchIds({
+        typeOf: chevre.factory.eventType.ScreeningEvent,
+        project: { id: { $eq: PROJECT_ID } },
+        id: { $in: ['al6afe7ad', 'al6afe7ae'] }
+    });
+    console.log(ids);
+    console.log(ids.length);
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/searchEventTicketOffers.ts

@@ -21,9 +21,10 @@ async function main() {
     const offerRateLimitRepo = new chevre.repository.rateLimit.Offer(client);
     const productRepo = new chevre.repository.Product(mongoose.connection);
 
-    const offers = await chevre.service.offer.event.searchEventTicketOffers({
+    const { ticketOffers } = await chevre.service.offer.event.searchEventTicketOffers({
         event: { id: 'al9ew43f5' },
-        onlyValid: true
+        onlyValid: true,
+        sort: true
         // ...(typeof sellerId === 'string') ? { seller: { id: sellerId } } : undefined,
         // ...(typeof availableAtId === 'string') ? { store: { id: availableAtId } } : undefined
     })({
@@ -33,8 +34,7 @@ async function main() {
         priceSpecification: priceSpecificationRepo,
         product: productRepo
     });
-    // console.log(offers);
-    console.log(offers.length);
+    console.log(ticketOffers.length);
 }
 
 main()

package/example/src/chevre/searchEvents.ts

@@ -1,5 +1,4 @@
 // tslint:disable:no-console
-import * as moment from 'moment';
 import * as mongoose from 'mongoose';
 
 import { chevre } from '../../../lib/index';
@@ -11,47 +10,27 @@ async function main() {
 
     const eventRepo = new chevre.repository.Event(mongoose.connection);
 
-    const events = await eventRepo.search({
-        limit: 100,
-        page: 1,
-        sort: { startDate: 1 },
-        typeOf: chevre.factory.eventType.ScreeningEvent,
-        project: { id: { $eq: PROJECT_ID } },
-        offers: {
-            seller: {
-                makesOffer: {
-                    $elemMatch: {
-                        'availableAtOrFrom.id': { $eq: '5h3gs22mu9j3ok7o63uog9o9i3' },
-                        availabilityEnds: {
-                            $gte: moment('2022-11-18T02:20:00.000Z')
-                                .toDate(),
-                            $lte: moment('2022-11-18T02:20:00.000Z')
-                                .toDate()
-                        },
-                        availabilityStarts: {
-                            $gte: moment('2022-11-15T15:00:00.000Z')
-                                .toDate(),
-                            $lte: moment('2022-11-15T15:00:00.000Z')
-                                .toDate()
-                        },
-                        validFrom: {
-                            $gte: moment('2022-11-15T15:00:00.000Z')
-                                .toDate(),
-                            $lte: moment('2022-11-15T15:00:00.000Z')
-                                .toDate()
-                        },
-                        validThrough: {
-                            $gte: moment('2022-11-18T02:20:00.000Z')
-                                .toDate(),
-                            $lte: moment('2022-11-18T02:20:00.000Z')
-                                .toDate()
-                        }
-                    }
-                }
-            }
+    const event = await eventRepo.findById(
+        { id: 'al6aff83y' },
+        {
+            name: 1
+        }
+    );
+    console.log('event found', event);
+
+    const events = await eventRepo.search(
+        {
+            limit: 100,
+            page: 1,
+            sort: { startDate: 1 },
+            typeOf: chevre.factory.eventType.ScreeningEvent,
+            project: { id: { $eq: PROJECT_ID } },
+            id: { $in: ['al6aff83y'] }
         },
-        id: { $in: ['al6aff83y'] }
-    });
+        {
+            name: 1
+        }
+    );
     console.log(events);
     console.log(events.length);
 }

package/example/src/chevre/searchOffersByCatalog.ts

@@ -0,0 +1,27 @@
+// tslint:disable:no-console
+// import * as redis from 'redis';
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI);
+
+    const offerRepo = new chevre.repository.Offer(mongoose.connection);
+
+    const offers = await offerRepo.findOffersByOfferCatalogId({
+        ids: ['al96nqj7z', 'xxx', '1001'],
+        // ids: ['xx', 'xxx'],
+        offerCatalog: {
+            id: '0001'
+            // id: 'xxx'
+        },
+        sort: true
+    });
+    console.log(offers.map((o) => o.id));
+    console.log(offers.length);
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/updateTransaction.ts

@@ -0,0 +1,38 @@
+// tslint:disable:no-console
+import * as moment from 'moment';
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI);
+
+    const transactionRepo = new chevre.repository.Transaction(mongoose.connection);
+    const transactionId = '63ce4d501c45c2000bdb2f9d';
+    let update = {
+        $set: { 'object.modifiedTime': new Date() }
+    };
+
+    let now = moment();
+    await transactionRepo.findByIdAndUpdate({
+        id: transactionId,
+        update
+    });
+    console.log(moment()
+        .diff(now));
+
+    update = {
+        $set: { 'object.modifiedTime': new Date() }
+    };
+    now = moment();
+    // await transactionRepo.updateById({
+    //     id: transactionId,
+    //     update
+    // });
+    console.log(moment()
+        .diff(now));
+}
+
+main()
+    .then()
+    .catch(console.error);

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

@@ -0,0 +1,2 @@
+import * as factory from '../factory';
+export declare type IMinimizedIndividualEvent<T extends factory.eventType.ScreeningEvent | factory.eventType.Event> = T extends factory.eventType.ScreeningEvent ? Pick<factory.event.IEvent<T>, 'project' | 'id' | 'typeOf' | 'additionalProperty' | 'name' | 'doorTime' | 'endDate' | 'eventStatus' | 'location' | 'startDate' | 'superEvent' | 'offers' | 'coaInfo' | 'identifier'> : T extends factory.eventType.Event ? Pick<factory.event.IEvent<T>, 'project' | 'id' | 'typeOf' | 'additionalProperty' | 'name' | 'doorTime' | 'endDate' | 'eventStatus' | 'location' | 'startDate' | 'offers'> : never;

package/lib/chevre/factory/event.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -7,6 +7,23 @@ export interface IUseActionCountByOffer {
     _id: string[];
     useActionCount?: number;
 }
+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 { modelName };
 /**
  * アクションリポジトリ
@@ -107,4 +124,54 @@ export declare class MongoRepository {
     deleteEndDatePassedCertainPeriod(params: {
         $lt: Date;
     }): Promise<void>;
+    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>;
+    aggregateUseAction(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>;
+    private agggregateByStatus;
 }