@chevre/domain/example/src/chevre/aggregation/aggregateOrderOfCustomer.ts

Chevre Domain Library for Node.js

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