old-psihologija/services/officeRnD/fees.js

'use strict';

const moment = require('moment-timezone');

const { API } = require('../../helpers/api');
const {
    officeRnDAPIErrors,
    DEFAULT_DATE_FORMAT,
    UNPAID_FEE_STATUS,
    CUSTOM_FEES_PREFIXES,
    MAX_FEES_TO_DELETE,
    FEES_DELETE_DELAY,
} = require('../../constants/constants');

const deleteFeesFromORD = (dateRange, memberIds) => {
    return new Promise((resolve, reject) => {
        const startDate = moment.utc(dateRange.startDate, DEFAULT_DATE_FORMAT).startOf('day');
        const endDate = moment.utc(dateRange.endDate, DEFAULT_DATE_FORMAT).endOf('day');

        const asyncDataFetch = [API.get('fees'), API.get('plans')];

        const feesToSkip = [];

        Promise.all(asyncDataFetch)
            .then((responses) => {
                const feesResponse = responses[0];
                const plansResponse = responses[1];

                const fetchedFees = feesResponse.data ? feesResponse.data : [];
                const fetchedPlans = plansResponse.data ? plansResponse.data : [];

                const manualFeeNames = [];
                fetchedPlans.forEach((plan) => {
                    const { name } = plan;
                    if (name && name.length > 0){
                        manualFeeNames.push(name);
                    }
                });

                const memberIdsMap = {};
                memberIds.forEach((memberId) => {
                    memberIdsMap[memberId] = true;
                });

                const filterByMemberIds = memberIds.length > 0;

                const feeIdsToRemove = [];

                fetchedFees.forEach((fee) => {
                    const { member, date, invoice, name } = fee;
                    const { status } = invoice;
                    const feeId = fee['_id'];

                    const isDateInDateRange = startDate.isSameOrBefore(date) && endDate.isSameOrAfter(date);
                    let manuallyAddedFee = false;
                    if (manualFeeNames.indexOf(name) === -1){
                        if (name && name[0] && CUSTOM_FEES_PREFIXES.indexOf(name[0]) !== -1){
                            manuallyAddedFee = true;
                        }
                    }else{
                        manuallyAddedFee = true;
                    }

                    const memberFeesShouldBeDeleted = filterByMemberIds ? memberIdsMap[member] : true;

                    if (memberFeesShouldBeDeleted && isDateInDateRange && (status === UNPAID_FEE_STATUS) && !manuallyAddedFee) {
                        feeIdsToRemove.push(feeId);
                    }else{
                        feesToSkip.push(fee);
                    }
                });

                const asyncDeleteCalls = [];

                let i,j;
                for (i=0, j=feeIdsToRemove; i<j; i+= MAX_FEES_TO_DELETE){
                    const feesSubset = feeIdsToRemove.slice(i, i+MAX_FEES_TO_DELETE);
                    const deleteFeesPromise = API.delete('fees', { data: feesSubset }).then(() => resolve(true)).catch((error) => {
                        console.log('[Delete Fees From ORD] Error deleting fees from ORD : ', error);
                        reject(officeRnDAPIErrors.FAILED_TO_DELETE_FEES);
                    });

                    asyncDeleteCalls.push(deleteFeesPromise);
                    //sleep for FEES_DELETE_DELAY ms
                }

                Promise.all(asyncDeleteCalls)
                    .then(() => {
                        resolve(feesToSkip);
                    })
                    .catch((error) => {
                        reject(error);
                    })

            })
            .catch((error) => {
                console.log("[Delete Fees From ORD] Error fetching fees and plans from ORD : ", error);
                reject(`${officeRnDAPIErrors.FAILED_TO_FETCH_FEES} and ${officeRnDAPIErrors.FAILED_TO_FETCH_PLANS}`);
            });
    });
};

const addFeesToORD = (allFees, invoicedFees) => {
    return new Promise((resolve, reject) => {
        const isFeeNonInvoiced = (fee) => {
            const { name: feeName, member: feeMember, team: feeTeam, office: feeOffice } = fee;

            const invoicedFeeObject = invoicedFees.find((invoicedFee) => {
                const { name, member, team, office } = invoicedFee;

                return (name === feeName && member === feeMember && team === feeTeam && office === feeOffice );
            });

            return !invoicedFeeObject;
        };

        const nonInvoicedFees = allFees.filter(isFeeNonInvoiced);

        API.post('/fees', nonInvoicedFees)
            .then(() => {
                resolve(nonInvoicedFees.length);
            })
            .catch((error) => {
                console.log('[Add Fees To ORD] Failed to send fees to ORD', error);
                reject(officeRnDAPIErrors.FAILED_TO_ADD_FEES);
            });
    });
};

module.exports = {
    deleteFeesFromORD,
    addFeesToORD
};