old-crm-integration/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 } = 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 planIsRateMap = {};

                const manualFeeNames = [];
                fetchedPlans.forEach((plan) => {
                    const { name, _id, isRate } = plan;

                    planIsRateMap[_id] = !!isRate;

                    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, plan } = fee;
                    const { status } = invoice;
                    const feeId = fee['_id'];
                    const feePlanIsRate = plan ? planIsRateMap[plan] : null;

                    const isDateInDateRange = startDate.isSameOrBefore(date) && endDate.isSameOrAfter(date);
                    let manuallyAddedFee = false;

                    if (plan && !feePlanIsRate){
                        manuallyAddedFee = true;
                    }else{
                        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);
                    }
                });

                API.delete('fees/?silent', { data: feeIdsToRemove })
                    .then(() => {
                        resolve(feesToSkip);
                    })
                    .catch((error) => {
                        console.log('[Delete Fees From ORD] Error deleting fees from ORD : ', error);
                        reject(officeRnDAPIErrors.FAILED_TO_DELETE_FEES);
                    });
            })
            .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
};