@chevre/domain 22.9.0-alpha.10 → 22.9.0-alpha.100

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

@@ -0,0 +1,124 @@
+// tslint:disable:no-console
+// import * as fs from 'fs';
+import * as moment from 'moment-timezone';
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../../lib/index';
+
+const PROJECT_ID = String(process.env.PROJECT_ID);
+const AGGREGATE_PERIOD_IN_DAYS = 365;
+
+function createAggregation(params: {
+    order: Pick<chevre.factory.order.IOrder, 'customer' | 'orderDate' | 'orderNumber' | 'project'>;
+    orderDateGte: Date;
+    orderDateLte: Date;
+}) {
+    return async (repos: {
+        order: chevre.repository.Order;
+    }) => {
+        const { order, orderDateGte, orderDateLte } = params;
+
+        return repos.order.aggregateOrderOfCustomer({
+            project: { id: { $eq: PROJECT_ID } },
+            orderDate: { $gte: orderDateGte, $lte: orderDateLte },
+            customer: { email: { $eq: String(order.customer.email) } }
+        });
+    };
+}
+
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const aggregateOrderRepo = await chevre.repository.AggregateOrder.createInstance(mongoose.connection);
+    const orderRepo = await chevre.repository.Order.createInstance(mongoose.connection);
+
+    const orderDateLte: Date = moment()
+        .toDate();
+    const orderDateGte: Date = moment(orderDateLte)
+        .add(-AGGREGATE_PERIOD_IN_DAYS, 'days')
+        .toDate();
+
+    const cursor = orderRepo.getCursor(
+        {
+            'project.id': { $eq: PROJECT_ID },
+            orderDate: {
+                $gte: orderDateGte,
+                $lte: orderDateLte
+            },
+            typeOf: { $eq: chevre.factory.order.OrderType.Order }
+        },
+        {
+            customer: 1,
+            orderDate: 1,
+            orderNumber: 1,
+            project: 1
+        }
+    );
+    console.log('docs found');
+
+    let maxSumGraceTime: number = 0;
+    const peopleWithAggregateOrder: {
+        identifier: string;
+        aggregateOrder: {
+            // emailCount: number;
+            orderCount: number;
+            sumGraceTime: number;
+        };
+        score?: number;
+    }[] = [];
+
+    let i = 0;
+    let updateCount = 0;
+    // tslint:disable-next-line:max-func-body-length
+    await cursor.eachAsync(async (doc) => {
+        i += 1;
+        const order: Pick<chevre.factory.order.IOrder, 'customer' | 'orderDate' | 'orderNumber' | 'project'> = doc.toObject();
+
+        const { email } = order.customer;
+        if (typeof email === 'string') {
+            console.log(
+                'aggregating...',
+                order.project.id, order.orderNumber, order.orderDate, i);
+            const aggregateResult = await createAggregation({ order, orderDateGte, orderDateLte })({ order: orderRepo });
+            await aggregateOrderRepo.save(
+                {
+                    project: order.project,
+                    identifier: email,
+                    typeOf: chevre.factory.personType.Person
+                },
+                { $set: { aggregateOrder: aggregateResult.aggregation } }
+            );
+            updateCount += 1;
+            console.log(
+                'aggregated.',
+                order.project.id, order.orderNumber, order.orderDate, i);
+
+            const sumGraceTime = (typeof aggregateResult.aggregation.sumGraceTime === 'number')
+                ? aggregateResult.aggregation.sumGraceTime
+                : 0;
+            maxSumGraceTime = Math.max(sumGraceTime, maxSumGraceTime);
+
+            peopleWithAggregateOrder.push({
+                identifier: email,
+                aggregateOrder: {
+                    ...aggregateResult.aggregation,
+                    sumGraceTime
+                }
+            });
+            console.log('maxSumGraceTime:', maxSumGraceTime);
+        }
+    });
+
+    console.log(i, 'docs checked');
+    console.log(updateCount, 'docs aggregated');
+
+    // tslint:disable-next-line:non-literal-fs-path no-null-keyword
+    // fs.writeFileSync(`${__dirname}/peopleWithAggregateOrder.json`, JSON.stringify(peopleWithAggregateOrder, null, '    '));
+}
+
+main()
+    .then(() => {
+        console.log('success!');
+    })
+    .catch(console.error);

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

@@ -0,0 +1,172 @@
+// tslint:disable:no-console
+import * as fs from 'fs';
+import * as moment from 'moment-timezone';
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../../lib/index';
+
+const PROJECT_ID = String(process.env.PROJECT_ID);
+// const SCREEN_CODE = '10';
+// const MOVIE_THEATER_CODE = '118';
+const SCREEN_CODE = '130';
+// const SCREEN_CODE = '211';
+const MOVIE_THEATER_CODE = '020';
+const AGGREGATE_PERIOD_IN_MONTHS = 12;
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const aggregateOrderRepo = await chevre.repository.AggregateOrder.createInstance(mongoose.connection);
+    const seatRepo = await chevre.repository.place.Seat.createInstance(mongoose.connection);
+    const orderRepo = await chevre.repository.Order.createInstance(mongoose.connection);
+
+    const royalCustomers = await aggregateOrderRepo.searchRoyalCustomers({
+        limit: 300,
+        project: { id: PROJECT_ID },
+        aggregateOrder: { orderCount: { $gte: 12 } }
+    });
+    // tslint:disable-next-line:no-null-keyword
+    console.dir(royalCustomers, { depth: null });
+    console.log(royalCustomers.length, 'royalCustomers found');
+
+    const customerEmails = royalCustomers.map(({ identifier }) => identifier);
+
+    const seats = <Pick<chevre.factory.place.seat.IPlace, 'branchCode'>[]>await seatRepo.searchSeats({
+        // limit: 50,
+        $projection: {
+            additionalProperty: 0,
+            'containedInPlace.typeOf': 0,
+            'containedInPlace.name': 0,
+            'containedInPlace.containedInPlace': 0,
+            name: 0, typeOf: 0
+        },
+        project: { id: { $eq: PROJECT_ID } },
+        containedInPlace: {
+            containedInPlace: {
+                branchCode: { $eq: SCREEN_CODE },
+                containedInPlace: { branchCode: { $eq: MOVIE_THEATER_CODE } }
+            }
+        }
+    });
+    // tslint:disable-next-line:no-null-keyword
+    // console.dir(seats, { depth: null });
+    console.log(seats.length, 'seats found');
+
+    const orderDateGte: Date = moment()
+        .add(-AGGREGATE_PERIOD_IN_MONTHS, 'months')
+        .toDate();
+    const orderDateLte: Date = moment()
+        .toDate();
+
+    let maxSumGraceTime: number = 0;
+    let maxRepeatRate: number = 0;
+    const seatsWithAggregateOrder: {
+        branchCode: string;
+        aggregateOrder: {
+            emailCount: number;
+            orderCount: number;
+            repeatRate: number;
+            avgGraceTime?: number;
+            sumGraceTime: number;
+            avgGraceTimeInHours?: number;
+            sumGraceTimeInHours: number;
+        };
+        score?: number;
+    }[] = [];
+    let i = 1;
+    for (const { branchCode } of seats) {
+        i += 1;
+        const startTime = process.hrtime();
+        const aggregateResult = await orderRepo.aggregateOrderOfSeat({
+            project: { id: { $eq: PROJECT_ID } },
+            orderDate: { $gte: orderDateGte, $lte: orderDateLte },
+            acceptedOffers: {
+                itemOffered: {
+                    reservationFor: {
+                        location: { branchCode: SCREEN_CODE },
+                        superEvent: { location: { branchCode: MOVIE_THEATER_CODE } }
+                    },
+                    reservedTicket: { ticketedSeat: { seatNumber: branchCode } }
+                }
+            },
+            customer: { email: { $in: customerEmails } }
+        });
+        console.log('aggregateOrder:result', aggregateResult, orderDateGte, orderDateLte, i);
+        const diff = process.hrtime(startTime);
+        console.log(`aggregateOrderOfSeat took ${diff[0]} seconds and ${diff[1]} nanoseconds.`);
+
+        const emailCount = (typeof aggregateResult.aggregation.emailCount === 'number')
+            ? aggregateResult.aggregation.emailCount
+            : 0;
+        const repeatRate = (aggregateResult.aggregation.orderCount > 0)
+            // tslint:disable-next-line:no-magic-numbers
+            ? (aggregateResult.aggregation.orderCount - emailCount) * 100 / aggregateResult.aggregation.orderCount
+            : 0;
+        const sumGraceTime = (typeof aggregateResult.aggregation.sumGraceTime === 'number')
+            ? aggregateResult.aggregation.sumGraceTime
+            : 0;
+        const avgGraceTimeInHours = (typeof aggregateResult.aggregation.sumGraceTime === 'number')
+            ? Math.floor(
+                moment.duration(Math.floor(aggregateResult.aggregation.sumGraceTime / aggregateResult.aggregation.orderCount), 'milliseconds')
+                    .asHours()
+            )
+            : 0;
+        const sumGraceTimeInHours = (typeof aggregateResult.aggregation.sumGraceTime === 'number')
+            ? Math.floor(moment.duration(aggregateResult.aggregation.sumGraceTime, 'milliseconds')
+                .asHours())
+            : 0;
+        maxSumGraceTime = Math.max(sumGraceTime, maxSumGraceTime);
+        maxRepeatRate = Math.max(repeatRate, maxRepeatRate);
+
+        seatsWithAggregateOrder.push({
+            branchCode,
+            aggregateOrder: {
+                ...aggregateResult.aggregation,
+                emailCount,
+                repeatRate,
+                avgGraceTimeInHours,
+                sumGraceTimeInHours,
+                sumGraceTime
+            }
+        });
+    }
+
+    const seatsJson = seatsWithAggregateOrder.map((seat, key) => {
+        // tslint:disable-next-line:no-magic-numbers
+        const score = Math.floor(seat.aggregateOrder.sumGraceTime * 100 / maxSumGraceTime);
+        console.log('aggregateOrder:result', seat.branchCode, key);
+
+        return {
+            branchCode: seat.branchCode,
+            score
+        };
+    });
+
+    const scoresByEmailJson = seatsWithAggregateOrder.map((seat, key) => {
+        // tslint:disable-next-line:no-magic-numbers
+        const score = Math.floor(seat.aggregateOrder.repeatRate * 100 / maxRepeatRate);
+        console.log('aggregateOrder:result', seat.branchCode, seat.aggregateOrder.emailCount, key);
+
+        return {
+            branchCode: seat.branchCode,
+            score
+            // repeatRate: seat.aggregateOrder.repeatRate,
+            // emailCount: seat.aggregateOrder.emailCount,
+            // orderCount: seat.aggregateOrder.orderCount
+        };
+    });
+
+    console.log('maxSumGraceTime:', maxSumGraceTime);
+    console.log('maxRepeatRate:', maxRepeatRate);
+
+    // tslint:disable-next-line:non-literal-fs-path no-null-keyword
+    fs.writeFileSync(`${__dirname}/seatScoresByGraceTime.json`, JSON.stringify(seatsJson, null, '    '));
+    // tslint:disable-next-line:non-literal-fs-path no-null-keyword
+    fs.writeFileSync(`${__dirname}/seatScoresByEmail.json`, JSON.stringify(scoresByEmailJson, null, '    '));
+}
+
+main()
+    .then(() => {
+        console.log('success!');
+    })
+    .catch(console.error);

package/example/src/chevre/checkPaymentServiceUniqueness.ts

@@ -0,0 +1,79 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+// const project = { id: String(process.env.PROJECT_ID) };
+// const excludedProject = { id: String(process.env.EXCLUDED_PROJECT_ID) };
+
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const paymentServiceRepo = await chevre.repository.PaymentService.createInstance(mongoose.connection);
+
+    const cursor = paymentServiceRepo.getCursor(
+        {
+            typeOf: {
+                $in: [
+                    chevre.factory.service.paymentService.PaymentServiceType.CreditCard,
+                    chevre.factory.service.paymentService.PaymentServiceType.MovieTicket
+                ]
+            }
+            // _id: { $eq: '5f9a4fed4f3709000abe6415' }
+        },
+        {
+            _id: 1,
+            availableChannel: 1,
+            productID: 1,
+            project: 1,
+            typeOf: 1,
+            serviceType: 1
+        }
+    );
+    console.log('docs found');
+
+    let i = 0;
+    // let updateCount = 0;
+    const unexpectedIds: string[] = [];
+    await cursor.eachAsync(async (doc) => {
+        i += 1;
+        const paymentService: Pick<
+            chevre.factory.service.paymentService.IService,
+            'availableChannel' | 'id' | 'productID' | 'project' | 'typeOf' | 'serviceType'
+        > = doc.toObject();
+
+        console.log(
+            'alreadyMigrated?', paymentService.project.id, paymentService.productID, i);
+        if (typeof paymentService.id !== 'string') {
+            throw new Error('id must be string');
+        }
+
+        let isUnique = false;
+        const existingServices = await paymentServiceRepo.projectFields(
+            {
+                project: { id: { $eq: paymentService.project.id } },
+                serviceType: { codeValue: { $eq: paymentService.serviceType.codeValue } }
+            },
+            ['id']
+        );
+        if (existingServices.length === 1 && existingServices.at(0)?.id === paymentService.id) {
+            isUnique = true;
+        }
+
+        if (isUnique) {
+            console.log(
+                'unique.', paymentService.project.id, paymentService.productID, i);
+        } else {
+            unexpectedIds.push(paymentService.productID);
+        }
+    });
+
+    console.log(unexpectedIds);
+    console.log(i, 'docs checked');
+    console.log(unexpectedIds.length, 'docs unexpected');
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/countPotentiallyExportTasks.ts

@@ -0,0 +1,42 @@
+// tslint:disable:no-console
+import * as moment from 'moment';
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+// const project = { id: String(process.env.PROJECT_ID) };
+
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const transactionRepo = await chevre.repository.Transaction.createInstance(mongoose.connection);
+    const taskRepo = await chevre.repository.Task.createInstance(mongoose.connection);
+
+    let result = await transactionRepo.countPotentiallyExportTasks({
+        endDate: {
+            $lt: moment()
+                // tslint:disable-next-line:no-magic-numbers
+                .add(-60, 'seconds')
+                .toDate()
+        },
+        limit: 10
+    });
+    console.log('result', result);
+
+    result = await taskRepo.countPotentiallyRunning({
+        runsAt: {
+            $lt: moment()
+                // tslint:disable-next-line:no-magic-numbers
+                .add(-60, 'seconds')
+                .toDate()
+        },
+        name: { $eq: chevre.factory.taskName.DeleteTransaction },
+        limit: 10
+    });
+    console.log('result', result);
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/countTransactions.ts

@@ -0,0 +1,30 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+// const project = { id: String(process.env.PROJECT_ID) };
+
+mongoose.Model.on('index', (...args) => {
+    console.error('******** index event emitted. ********\n', args);
+});
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const transactionRepo = await chevre.repository.Transaction.createInstance(mongoose.connection);
+
+    const { count } = await transactionRepo.count<chevre.factory.transactionType.PlaceOrder>({
+        limit: 5000,
+        // page: 1,
+        // project: { id: { $eq: project.id } },
+        typeOf: chevre.factory.transactionType.PlaceOrder,
+        statuses: [chevre.factory.transactionStatusType.InProgress],
+        startThrough: new Date()
+    });
+    console.log('count:', count);
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/createTaskIfNotExistByAlternateName.ts

@@ -0,0 +1,57 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+const project = { id: String(process.env.PROJECT_ID) };
+
+chevre.eventEmitter.task.onTaskStatusChanged((event) => {
+    console.log('onTaskStatusChanged', event);
+});
+
+async function main() {
+    const now = new Date();
+    await mongoose.connect(<string>process.env.MONGOLAB_URI);
+
+    const taskIdentifier: string = `${project.id}:${chevre.factory.taskName.TriggerWebhook}:sample:2025032801`;
+    const taskRepo = await chevre.repository.Task.createInstance(mongoose.connection);
+    const creatingTask = {
+        alternateName: taskIdentifier,
+        identifier: taskIdentifier,
+        name: chevre.factory.taskName.TriggerWebhook,
+        status: chevre.factory.taskStatus.Ready,
+        runsAt: now,
+        remainingNumberOfTries: 1,
+        numberOfTried: 0,
+        executionResults: [],
+        data: {
+            object: {
+                sample: 'sample'
+            },
+            recipient: {
+                id: '',
+                name: 'telemetry',
+                typeOf: 'WebApplication'
+            },
+            target: {
+                httpMethod: 'POST',
+                encodingType: 'application/json',
+                typeOf: 'EntryPoint',
+                urlTemplate: 'https://smart-theater-telemetry-api.an.r.appspot.com/webhooks/lineNotify'
+            },
+            identifier: 'sampleNotificationIdentifier'
+            // about: {
+            //     id: '67e62b0b28817948355a671c',
+            //     typeOf: 'PlaceOrder'
+            // }
+        },
+        project: { id: project.id, typeOf: <chevre.factory.organizationType.Project>chevre.factory.organizationType.Project }
+    };
+    taskRepo.createIfNotExistByAlternateName(creatingTask, { emitImmediately: true });
+    taskRepo.createIfNotExistByAlternateName(creatingTask, { emitImmediately: true });
+    console.log('success!');
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/deleteRunsAtPassedCertainPeriod.ts

@@ -4,7 +4,7 @@ import * as mongoose from 'mongoose';
 
 import { chevre } from '../../../lib/index';
 
-const TASK_STORAGE_PERIOD_IN_DAYS = 365;
+const TASK_STORAGE_PERIOD_IN_MINUTES = 43200; // 30*24*60
 
 async function main() {
     const now = new Date();
@@ -12,15 +12,29 @@ async function main() {
 
     const taskRepo = await chevre.repository.Task.createInstance(mongoose.connection);
 
-    const result = await taskRepo.deleteRunsAtPassedCertainPeriod({
-        runsAt: {
-            $lt: moment(now)
-                .add(-TASK_STORAGE_PERIOD_IN_DAYS, 'days')
-                .toDate()
-        }
-    });
+    let taskInMinutes = 57600; // 40*24*60
+    // let taskInMinutes = 172800; // 120*24*60
+    // tslint:disable-next-line:no-magic-numbers
+    while (taskInMinutes > TASK_STORAGE_PERIOD_IN_MINUTES) {
+        taskInMinutes -= 1;
+        console.log(
+            'cleaning...',
+            taskInMinutes,
+            moment.duration(taskInMinutes, 'minutes')
+                .asDays(),
+            'days'
+        );
+        const result = await taskRepo.deleteRunsAtPassedCertainPeriod({
+            runsAt: {
+                $lt: moment(now)
+                    .add(-taskInMinutes, 'minutes')
+                    .toDate()
+            }
+        });
+        console.log('deleted', result);
+    }
 
-    console.log('deleted', result);
+    console.log('success!');
 }
 
 main()

package/example/src/chevre/executeOneTask.ts

@@ -0,0 +1,41 @@
+// tslint:disable:no-console
+import * as moment from 'moment';
+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);
+
+    const taskRepo = await chevre.repository.Task.createInstance(mongoose.connection);
+    const task = await taskRepo.executeOneIfExists({
+        name: {
+            $nin: [
+                chevre.factory.taskName.DeleteTransaction,
+                chevre.factory.taskName.ImportEventCapacitiesFromCOA,
+                chevre.factory.taskName.ImportEventsFromCOA,
+                chevre.factory.taskName.AcceptCOAOffer,
+                chevre.factory.taskName.CheckMovieTicket,
+                chevre.factory.taskName.AuthorizePayment,
+                chevre.factory.taskName.PublishPaymentUrl
+            ]
+        },
+        executor: { name: 'sample' },
+        runsAt: {
+            $lt: moment()
+                // tslint:disable-next-line:no-magic-numbers
+                .add(-2, 'years')
+                // .add(-60, 'seconds')
+                .toDate()
+        }
+    });
+
+    // tslint:disable-next-line:no-null-keyword
+    console.dir(task, { depth: null });
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/{aggregateAllEvents2.ts → executeTaskIfExists.ts}

@@ -1,13 +1,10 @@
 // tslint:disable:no-console
-/**
- * イベント集計タスク実行
- */
 import { chevre } from '../../../lib/index';
 
 import * as mongoose from 'mongoose';
 import * as redis from 'redis';
 
-export async function aggregateScreeningEvent() {
+export async function executeTaskIfExists() {
     const redisClient = redis.createClient<redis.RedisDefaultModules, Record<string, never>, Record<string, never>>({
         socket: {
             port: Number(<string>process.env.REDIS_PORT),
@@ -21,8 +18,8 @@ export async function aggregateScreeningEvent() {
 
     let count = 0;
 
-    const MAX_NUBMER_OF_PARALLEL_TASKS = 10;
-    const INTERVAL_MILLISECONDS = 100;
+    const MAX_NUBMER_OF_PARALLEL_TASKS = 1;
+    const INTERVAL_MILLISECONDS = 1000;
 
     setInterval(
         async () => {
@@ -34,9 +31,21 @@ export async function aggregateScreeningEvent() {
 
             try {
                 console.log('executing...', count);
-                await (await chevre.service.task.createService()).executeByName({
-                    name: chevre.factory.taskName.AggregateScreeningEvent,
-                    executor: { name: 'sample' }
+                await (await chevre.service.task.createService()).executeOneIfExists({
+                    // name: chevre.factory.taskName.AggregateScreeningEvent,
+                    executor: { name: 'sample' },
+                    runsAt: { $lt: new Date() },
+                    name: {
+                        $nin: [
+                            chevre.factory.taskName.DeleteTransaction,
+                            chevre.factory.taskName.ImportEventCapacitiesFromCOA,
+                            chevre.factory.taskName.ImportEventsFromCOA,
+                            chevre.factory.taskName.AcceptCOAOffer,
+                            chevre.factory.taskName.CheckMovieTicket,
+                            chevre.factory.taskName.AuthorizePayment,
+                            chevre.factory.taskName.PublishPaymentUrl
+                        ]
+                    }
                 })({
                     connection: mongoose.connection,
                     redisClient,
@@ -64,7 +73,7 @@ export async function aggregateScreeningEvent() {
     );
 }
 
-aggregateScreeningEvent()
+executeTaskIfExists()
     .then(() => {
         console.log('success!');
     })