@chevre/domain/example/src/chevre/recreateRefundTasks.ts

Chevre Domain Library for Node.js

// 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);