@chevre/domain 22.9.0-alpha.6 → 22.9.0-alpha.61

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/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.DeleteTransaction,
+                    $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);

package/example/src/chevre/migratePaymentServiceChannelIds.ts

@@ -0,0 +1,107 @@
+// 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
+        }
+    );
+    console.log('docs found');
+
+    let i = 0;
+    let updateCount = 0;
+    await cursor.eachAsync(async (doc) => {
+        i += 1;
+        const paymentService: Pick<
+            chevre.factory.service.paymentService.IService,
+            'availableChannel' | 'id' | 'productID' | 'project' | 'typeOf'
+        > = doc.toObject();
+
+        console.log(
+            'alreadyMigrated?', paymentService.project.id, paymentService.productID, i);
+        if (typeof paymentService.id !== 'string') {
+            throw new Error('id must be string');
+        }
+
+        let alreadyMigrated = false;
+        try {
+            const channelId = paymentService.availableChannel?.id;
+            if (typeof channelId === 'string' && channelId !== '') {
+                if (paymentService.typeOf === chevre.factory.service.paymentService.PaymentServiceType.CreditCard) {
+                    const existingChannel = await paymentServiceRepo.findAvailableChannelCreditCard({
+                        project: { id: paymentService.project.id },
+                        id: paymentService.id
+                    });
+                    if (typeof existingChannel.id === 'string'
+                        && existingChannel.id === channelId) {
+                        alreadyMigrated = true;
+                    }
+                } else if (paymentService.typeOf === chevre.factory.service.paymentService.PaymentServiceType.MovieTicket) {
+                    const existingChannel = await paymentServiceRepo.findAvailableChannelMovieTicket({
+                        project: { id: paymentService.project.id },
+                        id: paymentService.id
+                    });
+                    if (typeof existingChannel.id === 'string'
+                        && existingChannel.id === channelId) {
+                        alreadyMigrated = true;
+                    }
+                } else {
+                    throw new Error('invalid paymentServiceType');
+                }
+            }
+        } catch (error) {
+            // no op
+        }
+
+        if (alreadyMigrated) {
+            console.log(
+                'already migrated.', paymentService.project.id, paymentService.productID, i);
+        } else {
+            if (paymentService.typeOf === chevre.factory.service.paymentService.PaymentServiceType.CreditCard
+                || paymentService.typeOf === chevre.factory.service.paymentService.PaymentServiceType.MovieTicket) {
+                // await paymentServiceRepo.migrateChannelId({
+                //     project: { id: paymentService.project.id },
+                //     id: paymentService.id,
+                //     typeOf: paymentService.typeOf
+                // });
+                updateCount += 1;
+                console.log(
+                    'updated.',
+                    paymentService.project.id, paymentService.productID, i);
+            } else {
+                throw new Error('invalid paymentServiceType');
+            }
+        }
+    });
+
+    console.log(i, 'docs checked');
+    console.log(updateCount, 'docs updated');
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/recreateRefundTasks.ts

@@ -0,0 +1,187 @@
+// 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) };
+// const excludedProject = { id: String(process.env.EXCLUDED_PROJECT_ID) };
+
+type IAcceptPayAction = chevre.factory.action.accept.pay.IAction;
+
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    // 注文取引が中止、期限切れであれば、返金タスクを作成
+    const actionRepo = await chevre.repository.Action.createInstance(mongoose.connection);
+    const transactionRepo = await chevre.repository.Transaction.createInstance(mongoose.connection);
+    const taskRepo = await chevre.repository.Task.createInstance(mongoose.connection);
+
+    const runsAt = new Date();
+    const cursor = transactionRepo.getCursor(
+        {
+            status: {
+                $in: [
+                    chevre.factory.transactionStatusType.Canceled,
+                    chevre.factory.transactionStatusType.Expired
+                ]
+            },
+            typeOf: { $eq: chevre.factory.transactionType.PlaceOrder },
+            startDate: {
+                $gte: moment('2025-02-22T15:00:00Z')
+                    .toDate(),
+                $lte: moment('2025-02-22T17:00:00Z')
+                    .toDate()
+            }
+            // _id: { $eq: 'cinerino' }
+        },
+        {
+            _id: 1,
+            status: 1,
+            object: 1,
+            typeOf: 1,
+            project: 1,
+            startDate: 1,
+            seller: 1,
+            agent: 1
+        }
+    );
+    console.log('docs found');
+
+    let i = 0;
+    let updateCount = 0;
+    // tslint:disable-next-line:max-func-body-length
+    await cursor.eachAsync(async (doc) => {
+
+        i += 1;
+        const transaction: Pick<chevre.factory.transaction.placeOrder.ITransaction,
+            'id' | 'typeOf' | 'object' | 'status' | 'project' | 'startDate' | 'seller' | 'agent'
+        > = doc.toObject();
+
+        // console.log(
+        //     'alreadyRefunded?', transaction.project.id, transaction.status, transaction.typeOf, transaction.startDate, i);
+
+        const acceptPayActions = (<Pick<IAcceptPayAction, 'object'>[]>await actionRepo.search(
+            {
+                project: { id: { $eq: transaction.project.id } },
+                typeOf: { $eq: chevre.factory.actionType.AcceptAction },
+                actionStatus: { $in: [chevre.factory.actionStatusType.CompletedActionStatus] },
+                purpose: { id: { $in: [transaction.id] } },
+                object: {
+                    typeOf: { $eq: chevre.factory.assetTransactionType.Pay }
+                }
+            },
+            ['object']
+        ));
+
+        for (const acceptPayAction of acceptPayActions) {
+            const paymentMethodId = acceptPayAction.object.transactionNumber;
+            const paymentMethodType = acceptPayAction.object.object.paymentMethod.identifier;
+
+            let alreadyRefunded = false;
+            const refundAction = (await actionRepo.search(
+                {
+                    limit: 1,
+                    page: 1,
+                    typeOf: chevre.factory.actionType.RefundAction,
+                    object: {
+                        paymentMethod: {
+                            paymentMethodId: { $eq: paymentMethodId }
+                        }
+                    }
+                },
+                ['id']
+            )).shift();
+            if (refundAction !== undefined) {
+                alreadyRefunded = true;
+            }
+
+            if (alreadyRefunded) {
+                // console.log(
+                //     'already migrated.',
+                //     transaction.project.id, transaction.status, transaction.typeOf, paymentMethodId, i);
+            } else {
+                if (typeof paymentMethodType === 'string' && paymentMethodType.length > 0
+                    // && paymentMethodId === '792043512179199'
+                ) {
+                    // create task
+                    const purpose: chevre.factory.action.trade.refund.IPurposeAsPlaceOrder = {
+                        typeOf: transaction.typeOf, id: transaction.id
+                    };
+                    const data: Omit<chevre.factory.task.refund.IData, 'purpose'> & {
+                        purpose: chevre.factory.action.trade.refund.IPurposeAsPlaceOrder;
+                    } = {
+                        project: transaction.project,
+                        typeOf: chevre.factory.actionType.RefundAction,
+                        agent: {
+                            typeOf: transaction.seller.typeOf,
+                            name: (typeof transaction.seller.name === 'string')
+                                ? transaction.seller.name
+                                : String(transaction.seller.name?.ja),
+                            id: transaction.seller.id
+                        },
+                        recipient: {
+                            typeOf: transaction.agent.typeOf,
+                            id: transaction.agent.id
+                            // name: transaction.agent.name
+                        },
+                        object: [{
+                            typeOf: chevre.factory.service.paymentService.PaymentServiceType.CreditCard,
+                            id: acceptPayAction.object.object.id,
+                            paymentMethod: {
+                                additionalProperty: [],
+                                name: paymentMethodType,
+                                typeOf: paymentMethodType,
+                                paymentMethodId: paymentMethodId
+                            },
+                            refundFee: 0
+                        }],
+                        purpose,
+                        instrument: []
+
+                    };
+                    const refundTask: Omit<chevre.factory.task.refund.IAttributes, 'data'> & {
+                        data: Omit<chevre.factory.task.refund.IData, 'purpose'> & {
+                            purpose: chevre.factory.action.trade.refund.IPurposeAsPlaceOrder;
+                        };
+                    } = {
+                        name: chevre.factory.taskName.Refund,
+                        data,
+                        status: chevre.factory.taskStatus.Ready,
+                        runsAt,
+                        project: transaction.project,
+                        remainingNumberOfTries: 10,
+                        numberOfTried: 0,
+                        executionResults: []
+                    };
+                    console.log(
+                        'creating task...',
+                        transaction.project.id, transaction.status,
+                        transaction.typeOf, transaction.startDate,
+                        acceptPayAction.object.transactionNumber,
+                        i,
+                        refundTask
+                    );
+                    await taskRepo.saveMany([refundTask], { emitImmediately: false });
+                    updateCount += 1;
+                    console.log(
+                        'created.',
+                        transaction.project.id, transaction.status,
+                        transaction.typeOf, transaction.startDate,
+                        acceptPayAction.object.transactionNumber,
+                        acceptPayAction.object.transactionNumber,
+                        i
+                    );
+                }
+            }
+        }
+    });
+
+    console.log(i, 'docs checked');
+    console.log(updateCount, 'docs updated');
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/saveWebSite.ts

@@ -0,0 +1,59 @@
+// 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 webSiteRepo = await chevre.repository.WebSite.createInstance(mongoose.connection);
+
+    const creatingWebSites: Pick<
+        chevre.factory.creativeWork.certification.webSite.ICertification,
+        'about' | 'certificationStatus' | 'project' | 'auditDate'
+    >[] = [
+            // {
+            //     project: { id: project.id, typeOf: chevre.factory.organizationType.Project },
+            //     about: {
+            //         identifier: 'xxx',
+            //         typeOf: chevre.factory.creativeWorkType.WebSite
+            //     },
+            //     certificationStatus: chevre.factory.CertificationStatusEnumeration.CertificationInactive
+            // },
+            // {
+            //     project: { id: project.id, typeOf: chevre.factory.organizationType.Project },
+            //     about: {
+            //         identifier: 'xxx',
+            //         typeOf: chevre.factory.creativeWorkType.WebSite
+            //     },
+            //     certificationStatus: chevre.factory.CertificationStatusEnumeration.CertificationInactive
+            // }
+        ];
+    for (const creatingWebSite of creatingWebSites) {
+        console.log('updating...', creatingWebSite);
+        try {
+            const { id } = await webSiteRepo.save({
+                attributes: creatingWebSite
+            });
+            await webSiteRepo.save({
+                id,
+                attributes: {
+                    ...creatingWebSite,
+                    auditDate: new Date(),
+                    certificationStatus: chevre.factory.CertificationStatusEnumeration.CertificationActive
+                }
+            });
+            console.log('updated.');
+        } catch (error) {
+            console.error(error);
+        }
+    }
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/searchPaymentServices.ts

@@ -0,0 +1,32 @@
+// tslint:disable:no-implicit-dependencies 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 paymentServiceRepo = await chevre.repository.PaymentService.createInstance(mongoose.connection);
+
+    const limit = 10;
+    const page = 1;
+    const docs = await paymentServiceRepo.projectFields(
+        {
+            limit,
+            page,
+            project: { id: { $eq: project.id } },
+            availableChannel: { serviceUrl: { $eq: 'xxx' } }
+        },
+        ['availableChannel', 'productID']
+    );
+    // tslint:disable-next-line:no-null-keyword
+    console.dir(docs, { depth: null });
+    console.log(docs.length, 'docs found');
+}
+
+main()
+    .then(() => {
+        console.log('success!');
+    })
+    .catch(console.error);