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

Chevre Domain Library for Node.js

// tslint:disable:no-console
import { chevre } from '../../../lib/index';

import * as mongoose from 'mongoose';
import * as redis from 'redis';

export async function executeTaskIfExists() {
    const redisClient = redis.createClient<redis.RedisDefaultModules, Record<string, never>, Record<string, never>>({
        socket: {
            port: Number(<string>process.env.REDIS_PORT),
            host: <string>process.env.REDIS_HOST
        },
        password: <string>process.env.REDIS_KEY
    });
    await redisClient.connect();

    await mongoose.connect(<string>process.env.MONGOLAB_URI);

    let count = 0;

    const MAX_NUBMER_OF_PARALLEL_TASKS = 1;
    const INTERVAL_MILLISECONDS = 1000;

    setInterval(
        async () => {
            if (count > MAX_NUBMER_OF_PARALLEL_TASKS) {
                return;
            }

            count += 1;

            try {
                console.log('executing...', count);
                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,
                    credentials: {
                        sendGrid: await chevre.credentials.SendGrid.createInstance({ apiKey: 'xxx' })
                    },
                    settings: new chevre.settings.Settings({
                        deliverOrderLimit: 1,
                        abortedTasksWithoutReport: [],
                        coa: { timeout: 1000 },
                        gmo: { timeout: 1000, timeoutBackground: 1000, useFetch: true },
                        movieticketReserve: { timeout: 1000, timeoutCheck: 1000, minIntervalBetweenPayAndRefund: 0 },
                        numTryConfirmReserveTransaction: 10,
                        useExperimentalFeature: false
                    })
                });
                console.log('executed', count);
            } catch (error) {
                console.error(error);
            }

            count -= 1;
        },
        INTERVAL_MILLISECONDS
    );
}

executeTaskIfExists()
    .then(() => {
        console.log('success!');
    })
    .catch(console.error);