@chevre/domain 22.9.0-alpha.8 → 22.9.0-alpha.80

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/aggregateOrderOfSeat.ts

@@ -0,0 +1,159 @@
+// 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 seatRepo = await chevre.repository.place.Seat.createInstance(mongoose.connection);
+    const orderRepo = await chevre.repository.Order.createInstance(mongoose.connection);
+
+    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 } }
+                }
+            }
+        });
+        console.log('aggregateOrder:result', aggregateResult, orderDateGte, orderDateLte, i);
+        const diff = process.hrtime(startTime);
+        console.log(`importing chevre 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/countPotentiallyExpired.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.countPotentiallyExpired({
+        expires: {
+            $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/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!');
     })

package/example/src/chevre/findExecutableTask.ts

@@ -0,0 +1,50 @@
+// 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);
+
+    setInterval(
+        async () => {
+            const startTime = process.hrtime();
+            const task = await taskRepo.findExecutableOne({
+                name: {
+                    $eq: chevre.factory.taskName.VoidReserveTransaction
+                    // $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
+                    // ]
+                },
+                runsAt: {
+                    $lt: moment()
+                        // tslint:disable-next-line:no-magic-numbers
+                        .add(-60, 'seconds')
+                        .toDate()
+                }
+            });
+            const diff = process.hrtime(startTime);
+            console.log(`took ${diff[0]} seconds and ${diff[1]} nanoseconds.`);
+
+            // tslint:disable-next-line:no-null-keyword
+            console.dir(task?.id, { depth: null });
+        },
+        // tslint:disable-next-line:no-magic-numbers
+        1000
+    );
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/makeExpiredManyTasks.ts

@@ -0,0 +1,27 @@
+// tslint:disable:no-implicit-dependencies no-console
+import { chevre } from '../../../lib/index';
+
+import * as  moment from 'moment';
+import * as  mongoose from 'mongoose';
+
+// const project = { id: String(process.env.PROJECT_ID) };
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const taskRepo = await chevre.repository.Task.createInstance(mongoose.connection);
+
+    const expiresLt = moment()
+        .add(-1, 'hour')
+        .toDate();
+    const result = await taskRepo.makeExpiredMany({
+        expiresLt
+    });
+    console.log('result:', result);
+}
+
+main()
+    .then(() => {
+        console.log('success!');
+    })
+    .catch(console.error);

package/example/src/chevre/makeTransactionExpired.ts

@@ -0,0 +1,28 @@
+// 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, { autoIndex: false });
+
+    const transactionRepo = await chevre.repository.Transaction.createInstance(mongoose.connection);
+
+    const result = await transactionRepo.makeOneExpiredIfExists({
+        expires: {
+            $lt: moment()
+                // tslint:disable-next-line:no-magic-numbers
+                .add(-60, 'seconds')
+                .toDate()
+        }
+    });
+
+    console.log('result:', result);
+}
+
+main()
+    .then()
+    .catch(console.error);