@zeniai/client-epic-state 5.1.18-betaDI1 → 5.1.18-betaDI10

package/lib/esm/commonStateTypes/classesView/getNestedClassIDHierarchyForReport.js

@@ -0,0 +1,106 @@
+import { toClassMetadata, } from '../../entity/class/classPayload';
+/**
+ * This function builds the hierarchy which is used to display all classes
+ * in the selection view
+ * @param classesMetadata
+ * @returns
+ */
+export function geNestedClassIDHierarchyForReport(classesMetadata) {
+    const parentClasses = [];
+    classesMetadata.forEach((classMeta) => {
+        if (classMeta.isSubclass === false ||
+            // look for its parent in the entire metadata. If not found, then push this also as a rootNode
+            classesMetadata.find((eachClass) => eachClass.classId === classMeta.parentClassId) == null) {
+            parentClasses.push(classMeta);
+        }
+    });
+    const nestedParents = parentClasses.map((parentClass) => {
+        const classId = parentClass.classId;
+        return {
+            classId: [classId],
+            className: parentClass.className,
+            isDeleted: parentClass.isDeleted,
+            qboId: parentClass.qboId,
+            fullyQualifiedAccountingClassName: parentClass.fullyQualifiedAccountingClassName,
+            accountingClassNumber: parentClass.accountingClassNumber,
+            children: getNestedChildren([classId], classesMetadata),
+            hasSiblings: parentClasses.length > 1,
+        };
+    });
+    return nestedParents;
+}
+const getNestedChildren = (parentClass, allClasses) => {
+    const parentId = parentClass[0];
+    const children = allClasses.filter((eachClass) => eachClass.parentClassId === parentId);
+    const nestedChildren = children.map((child) => {
+        const childId = [child.classId, ...parentClass];
+        return {
+            classId: childId,
+            className: child.className,
+            isDeleted: child.isDeleted,
+            qboId: child.qboId,
+            fullyQualifiedAccountingClassName: child.fullyQualifiedAccountingClassName,
+            accountingClassNumber: child.accountingClassNumber,
+            children: getNestedChildren(childId, allClasses),
+            hasSiblings: children.length > 1,
+        };
+    });
+    return nestedChildren;
+};
+/**
+ * Modified this function to remove recursion. The classes metadata will ALWAYS be sorted such that all
+ * parent classes of any will appear before any child class.
+ * @param classId
+ * @param classesMetadata
+ * @returns
+ */
+export function getNestedClassIDForClass(classId, classesMetadata) {
+    let nestedClassId = undefined;
+    let toFindClassId = classId;
+    let toFindParentClassId = undefined;
+    for (let index = classesMetadata.length - 1; index >= 0; index--) {
+        if (classesMetadata[index].classId === toFindClassId) {
+            nestedClassId =
+                nestedClassId == null
+                    ? [toFindClassId]
+                    : [...nestedClassId, toFindClassId];
+            toFindParentClassId = classesMetadata[index].parentClassId;
+            if (toFindParentClassId == null) {
+                break;
+            }
+            else {
+                toFindClassId = toFindParentClassId;
+                toFindParentClassId = undefined;
+            }
+        }
+    }
+    if (nestedClassId == null) {
+        throw Error(`Cannot find classId ${classId} in class metadata`);
+    }
+    return nestedClassId;
+}
+export const getParentClassId = (classId) => {
+    return classId.length > 1 ? classId.slice(1) : undefined;
+};
+export const getAllClassMetadataRecordsByID = (classesMetadataPayload) => {
+    const classMetadataRecords = {};
+    const classMetadataRecordsPartial = {};
+    const classesMetadata = classesMetadataPayload != null
+        ? classesMetadataPayload.map((classPayload) => {
+            const classMeta = toClassMetadata(classPayload);
+            classMetadataRecordsPartial[classMeta.classId] = Object.assign({}, {
+                payload: classPayload,
+                meta: classMeta,
+            });
+            return classMeta;
+        })
+        : [];
+    classesMetadata.forEach((classMeta) => {
+        classMetadataRecords[classMeta.classId] = Object.assign({}, {
+            nestedClassId: getNestedClassIDForClass(classMeta.classId, classesMetadata),
+            classMetadata: classMetadataRecordsPartial[classMeta.classId].meta,
+            classMetadataPayload: classMetadataRecordsPartial[classMeta.classId].payload,
+        });
+    });
+    return classMetadataRecords;
+};

package/lib/esm/commonStateTypes/classesView/nestedClassID.js

@@ -0,0 +1,4 @@
+export function getNestedClassIDStr(nestedClassId) {
+    const [classId, parentClassId, greatParentClassId, greatGreatParentClassId, greatGreatGreatParentClassId,] = nestedClassId;
+    return `${classId}-${parentClassId ?? ''}-${greatParentClassId ?? ''}-${greatGreatParentClassId ?? ''}-${greatGreatGreatParentClassId ?? ''}`;
+}

package/lib/esm/commonStateTypes/coaBalance/additionalBalances/getAdditionalBalances.js

@@ -0,0 +1,128 @@
+import cloneDeep from 'lodash/cloneDeep';
+import { getComparisionBalance } from './getComparisionBalance';
+import { getSamePeriodLastYearBalance } from './getSamePeriodLastYearBalance';
+import { getFreeRangeCashAndEquivalentsClosingBalance, getFreeRangeCashAndEquivalentsOpeningBalance, getSummationBalance, getSummationFreeRangeTotalBalance, } from './getSummationBalance';
+import { sliceCOABalances } from './sliceCOABalances';
+/**
+ * Instantiate a new Additional balances option.
+ * @param isBalanceSheetBalances is balance sheet balances
+ * @param isCashFlowCashAndEquivalents is cash flow CashAndEquivalent balances. one of `opening_balance, closing_balance, closing_minus_opening_balance`
+ * @param cashAndEquivalents set only when `isCashFlowCashAndEquivalents === closing_minus_opening_balance`
+ * @returns
+ */
+export function newAdditionalBalancesOptions(isBalanceSheetBalances, isCashFlowCashAndEquivalents = undefined, cashAndEquivalents = undefined) {
+    return {
+        isBalanceSheetBalances,
+        isCashFlowCashAndEquivalents,
+        cashAndEquivalents,
+    };
+}
+/**
+ * Get additional balance of given balance type
+ * @param balanceType balance type
+ * @param resultSlice result slice where the last element represents `thisMonth`
+ * @param resultBalancesOrder order of balances in the result slice.
+ * @param allBalancesOrderedAsc  all balances ordered
+ * @param allMonthlyBalancesOrderedAsc all balances ordered in monthly timeframe
+ * @param options other options to generate additional balances.
+ */
+export function getAdditionalBalance(firstMonthOfFY, balanceType, resultSlice, resultFilter, allBalancesOrderedAsc, allMonthlyBalancesOrderedAsc, options) {
+    const resultBalancesOrder = resultFilter.balancesRange.orderBy;
+    switch (balanceType) {
+        case 'same_period_last_year':
+            return getSamePeriodLastYearBalance(resultFilter.timeframe, resultSlice, resultBalancesOrder, allBalancesOrderedAsc);
+        case 'this_period_vs_last_period':
+        case 'this_period_vs_last_period_percent':
+        case 'this_period_vs_same_period_last_year':
+        case 'this_period_vs_same_period_last_year_percent':
+            return getComparisionBalance(balanceType, resultFilter.timeframe, resultSlice, resultBalancesOrder, allBalancesOrderedAsc);
+        case 'year_to_date_total':
+        case 'year_to_date_last_year_total':
+        case 'rolling_12_months':
+        case 'rolling_12_months_average':
+            return getSummationBalance(balanceType, firstMonthOfFY, resultFilter.timeframe, resultSlice, resultBalancesOrder, allMonthlyBalancesOrderedAsc, options?.isBalanceSheetBalances ?? false, options?.isCashFlowCashAndEquivalents, {
+                allOpeningMonthlyBalanceOrderedAsc: options?.cashAndEquivalents?.openingBalanceGrouped?.months ?? [],
+                allClosingMonthlyBalanceOrderedAsc: options?.cashAndEquivalents?.closingBalanceGrouped?.months ?? [],
+            });
+        case 'free_range_total':
+            if (options == null ||
+                (options.isBalanceSheetBalances === false &&
+                    options.isBalanceSheetBalances == null)) {
+                return getSummationFreeRangeTotalBalance(resultSlice);
+            }
+            else if (options.isBalanceSheetBalances === true) {
+                // Note: for balanceSheet balances, the sum is nothing but the latest balance.
+                let latestBalance = undefined;
+                if (resultSlice.length > 0) {
+                    latestBalance =
+                        resultBalancesOrder === 'ascending_date'
+                            ? resultSlice[resultSlice.length - 1]
+                            : resultSlice[0];
+                }
+                return Object.assign({}, latestBalance, { type: 'free_range_total' });
+            }
+            else if (options.isCashFlowCashAndEquivalents != null) {
+                return cashAndEquivalentsFreeRangeBalances(resultSlice, resultFilter, options.isCashFlowCashAndEquivalents, options.cashAndEquivalents);
+            }
+            else {
+                console.error('Invalid request for free range total');
+                return undefined;
+            }
+        case 'period_total':
+        case 'default':
+        case 'default_with_percent':
+        case 'default_with_null_balance':
+            return undefined;
+    }
+}
+function cashAndEquivalentsFreeRangeBalances(resultSlice, resultFilter, isCashFlowCashAndEquivalents, 
+// This `cashAndEquivalents` is set only when isCashFlowCashAndEquivalents === 'closing_minus_opening_balance'
+cashAndEquivalents) {
+    const resultBalancesOrder = resultFilter.balancesRange.orderBy;
+    switch (isCashFlowCashAndEquivalents) {
+        case 'closing_balance':
+            return getFreeRangeCashAndEquivalentsClosingBalance(resultSlice, resultBalancesOrder);
+        case 'opening_balance':
+            return getFreeRangeCashAndEquivalentsOpeningBalance(resultSlice, resultBalancesOrder);
+        case 'closing_minus_opening_balance': {
+            if (cashAndEquivalents == null) {
+                console.error("Can't calculate closing_minus_opening_balance without opening & closing balances");
+                return undefined;
+            }
+            const openingBalance = getFreeRangeCashAndEquivalentsOpeningBalance(getCOABalancesInTimeframe(cashAndEquivalents.openingBalanceGrouped, resultFilter), resultBalancesOrder);
+            const closingBalance = getFreeRangeCashAndEquivalentsClosingBalance(getCOABalancesInTimeframe(cashAndEquivalents.closingBalanceGrouped, resultFilter), resultBalancesOrder);
+            let result = undefined;
+            if (openingBalance != null && closingBalance != null) {
+                result = cloneDeep(closingBalance);
+                result.balance.amount =
+                    closingBalance.balance.amount - openingBalance.balance.amount;
+            }
+            return result;
+        }
+    }
+}
+function getCOABalancesInTimeframe(coaBalanceGrouped, filter) {
+    if (coaBalanceGrouped == null) {
+        return [];
+    }
+    let allBalancesInTimeframe = [];
+    switch (filter.timeframe) {
+        case 'week':
+            allBalancesInTimeframe = coaBalanceGrouped.weeks ?? [];
+            break;
+        case 'month':
+            allBalancesInTimeframe = coaBalanceGrouped.months ?? [];
+            break;
+        case 'quarter':
+            allBalancesInTimeframe = coaBalanceGrouped.quarters ?? [];
+            break;
+        case 'year':
+            allBalancesInTimeframe = coaBalanceGrouped.years ?? [];
+            break;
+        case 'free_range':
+            console.error('Querying by free_range is not supported!');
+            break;
+    }
+    const resultBalances = sliceCOABalances(allBalancesInTimeframe, filter.balancesRange);
+    return resultBalances;
+}

package/lib/esm/commonStateTypes/coaBalance/additionalBalances/getComparisionBalance.js

@@ -0,0 +1,148 @@
+import { getSamePeriodLastYearBalance } from './getSamePeriodLastYearBalance';
+export function getComparisionBalance(comparisionType, timeframe, resultSlice, resultBalancesOrder, allBalancesOrderedAsc) {
+    if (allBalancesOrderedAsc.length === 0 || resultSlice.length === 0) {
+        return undefined;
+    }
+    switch (comparisionType) {
+        case 'this_period_vs_last_period':
+        case 'this_period_vs_last_period_percent':
+            if (resultSlice.length >= 2) {
+                const currentPeriod = resultBalancesOrder === 'ascending_date'
+                    ? resultSlice[resultSlice.length - 1]
+                    : resultSlice[0];
+                const lastPeriod = resultBalancesOrder === 'ascending_date'
+                    ? resultSlice[resultSlice.length - 2]
+                    : resultSlice[1];
+                return getBalancesDiff(currentPeriod, lastPeriod, comparisionType);
+            }
+            break;
+        case 'this_period_vs_same_period_last_year':
+        case 'this_period_vs_same_period_last_year_percent':
+            {
+                const currentPeriod = resultBalancesOrder === 'ascending_date'
+                    ? resultSlice[resultSlice.length - 1]
+                    : resultSlice[0];
+                const samePeriodLY = getSamePeriodLastYearBalance(timeframe, resultSlice, resultBalancesOrder, allBalancesOrderedAsc);
+                if (samePeriodLY != null) {
+                    return getBalancesDiff(currentPeriod, samePeriodLY, comparisionType);
+                }
+            }
+            break;
+    }
+    return undefined;
+}
+function getBalancesDiff(thisPeriodBalance, lastPeriodBalance, type) {
+    const balancesDiff = thisPeriodBalance.balance.amount - lastPeriodBalance.balance.amount;
+    let balancesDiffInPercent = undefined;
+    if (lastPeriodBalance.balance.amount !== 0 &&
+        !isNaN(lastPeriodBalance.balance.amount)) {
+        balancesDiffInPercent =
+            balancesDiff / Math.abs(lastPeriodBalance.balance.amount);
+    }
+    const comparisonTotalAmount = getComparisonTotalAmount(thisPeriodBalance, lastPeriodBalance);
+    const comparisonForecastTotalAmount = getComparisonTotalForecastAmount(thisPeriodBalance, lastPeriodBalance);
+    const resultBalance = Object.assign({}, thisPeriodBalance, {
+        type: type,
+        balanceTimeFrame: 'free_range',
+        balance: Object.assign({}, thisPeriodBalance.balance, {
+            amount: balancesDiff,
+        }),
+        percentValue: balancesDiffInPercent,
+        label: '',
+        totalBalance: comparisonTotalAmount.totalBalanceDiff,
+        totalForecast: comparisonForecastTotalAmount.totalBalanceDiff,
+        forecastPercentValue: comparisonForecastTotalAmount.totalPercentDiff,
+        totalPercentValue: comparisonTotalAmount.totalPercentDiff,
+    });
+    return resultBalance;
+}
+function getComparisonTotalAmount(thisPeriodBalanceWithTotal, lastPeriodBalanceWithTotal) {
+    let thisBalanceAmount = undefined;
+    let lastBalanceAmount = undefined;
+    if (thisPeriodBalanceWithTotal?.totalBalance != null &&
+        lastPeriodBalanceWithTotal?.totalBalance != null) {
+        thisBalanceAmount = thisPeriodBalanceWithTotal.totalBalance;
+        lastBalanceAmount = lastPeriodBalanceWithTotal.totalBalance;
+    }
+    else if (thisPeriodBalanceWithTotal?.totalBalance != null &&
+        lastPeriodBalanceWithTotal?.totalBalance == null) {
+        thisBalanceAmount = thisPeriodBalanceWithTotal.totalBalance;
+        lastBalanceAmount = {
+            ...thisBalanceAmount,
+            amount: 0,
+        };
+    }
+    else if (thisPeriodBalanceWithTotal?.totalBalance == null &&
+        lastPeriodBalanceWithTotal?.totalBalance != null) {
+        lastBalanceAmount = lastPeriodBalanceWithTotal.totalBalance;
+        thisBalanceAmount = {
+            ...lastBalanceAmount,
+            amount: 0,
+        };
+    }
+    if (thisBalanceAmount != null && lastBalanceAmount != null) {
+        const { amountDiff, amountDiffInPercent } = getAmountDiffAndPercentDiff(thisBalanceAmount, lastBalanceAmount);
+        return {
+            totalBalanceDiff: amountDiff,
+            totalPercentDiff: amountDiffInPercent,
+        };
+    }
+    else {
+        return {
+            totalBalanceDiff: undefined,
+            totalPercentDiff: undefined,
+        };
+    }
+}
+function getComparisonTotalForecastAmount(thisPeriodBalanceWithTotal, lastPeriodBalanceWithTotal) {
+    let thisBalanceAmount = undefined;
+    let lastBalanceAmount = undefined;
+    if (thisPeriodBalanceWithTotal?.totalForecast != null &&
+        lastPeriodBalanceWithTotal?.totalForecast != null) {
+        thisBalanceAmount = thisPeriodBalanceWithTotal.totalForecast;
+        lastBalanceAmount = lastPeriodBalanceWithTotal.totalForecast;
+    }
+    else if (thisPeriodBalanceWithTotal?.totalForecast != null &&
+        lastPeriodBalanceWithTotal?.totalForecast == null) {
+        thisBalanceAmount = thisPeriodBalanceWithTotal.totalForecast;
+        lastBalanceAmount = {
+            ...thisBalanceAmount,
+            amount: 0,
+        };
+    }
+    else if (thisPeriodBalanceWithTotal?.totalForecast == null &&
+        lastPeriodBalanceWithTotal?.totalForecast != null) {
+        lastBalanceAmount = lastPeriodBalanceWithTotal.totalForecast;
+        thisBalanceAmount = {
+            ...lastBalanceAmount,
+            amount: 0,
+        };
+    }
+    if (thisBalanceAmount != null && lastBalanceAmount != null) {
+        const { amountDiff, amountDiffInPercent } = getAmountDiffAndPercentDiff(thisBalanceAmount, lastBalanceAmount);
+        return {
+            totalBalanceDiff: amountDiff,
+            totalPercentDiff: amountDiffInPercent,
+        };
+    }
+    else {
+        return {
+            totalBalanceDiff: undefined,
+            totalPercentDiff: undefined,
+        };
+    }
+}
+function getAmountDiffAndPercentDiff(thisPeriodAmount, lastPeriodAmount) {
+    const amountDiff = thisPeriodAmount.amount - lastPeriodAmount.amount;
+    let amountDiffInPercent = undefined;
+    if (lastPeriodAmount.amount !== 0 && !isNaN(lastPeriodAmount.amount)) {
+        amountDiffInPercent = amountDiff / Math.abs(lastPeriodAmount.amount);
+    }
+    return {
+        amountDiff: {
+            ...thisPeriodAmount,
+            amount: amountDiff,
+        },
+        amountDiffInPercent,
+    };
+}

package/lib/esm/commonStateTypes/coaBalance/additionalBalances/getSamePeriodLastYearBalance.js

@@ -0,0 +1,62 @@
+import findLastIndex from 'lodash/findLastIndex';
+import { getStartOfAndEndOfTimeframeForFY } from '../../fiscalYearHelpers/getStartOfAndEndOfTimeframeFY';
+export function getSamePeriodLastYearBalance(timeframe, resultSlice, resultBalanceOrder, allBalancesOrderedAsc) {
+    if (allBalancesOrderedAsc.length === 0 || resultSlice.length === 0) {
+        return undefined;
+    }
+    const thisPeriod = resultBalanceOrder === 'ascending_date'
+        ? resultSlice[resultSlice.length - 1]
+        : resultSlice[0];
+    let startDateLY = undefined;
+    let endDateLY = undefined;
+    switch (timeframe) {
+        case 'month':
+        case 'quarter':
+        case 'year':
+            {
+                startDateLY = thisPeriod.startDate
+                    .subtract(1, 'year')
+                    .startOf(timeframe);
+                endDateLY = startDateLY.endOf(timeframe);
+            }
+            break;
+        default:
+            console.error(`timeframe ${timeframe} is not supported for getSamePeriodLastYearBalance`);
+            break;
+    }
+    if (startDateLY != null && endDateLY != null) {
+        const lastYearBalanceIndex = findLastIndex(allBalancesOrderedAsc, (value) => value.startDate.isSame(startDateLY, 'day') && // eslint-disable-line @typescript-eslint/no-non-null-assertion
+            value.endDate.isSame(endDateLY, 'day') // eslint-disable-line @typescript-eslint/no-non-null-assertion
+        );
+        return lastYearBalanceIndex != -1
+            ? allBalancesOrderedAsc[lastYearBalanceIndex]
+            : undefined;
+    }
+    else {
+        return undefined;
+    }
+}
+export function getThisPeriodForLastYear(firstMonthOfFY, thisPeriod, timeframe) {
+    let startDateLY = undefined;
+    let endDateLY = undefined;
+    switch (timeframe) {
+        case 'month':
+        case 'quarter':
+        case 'year':
+            {
+                const { startOfTimeframeFY } = getStartOfAndEndOfTimeframeForFY(thisPeriod.startDate.subtract(1, 'year'), firstMonthOfFY, timeframe);
+                startDateLY = startOfTimeframeFY;
+                endDateLY = thisPeriod.endDate.subtract(1, 'year').endOf('month');
+            }
+            break;
+        case 'week':
+        case 'free_range':
+            {
+                console.warn('Be carefull!! getThisPeriodLastYear for week or free_range is not intended');
+                startDateLY = thisPeriod.startDate.subtract(1, 'year');
+                endDateLY = thisPeriod.endDate.subtract(1, 'year');
+            }
+            break;
+    }
+    return { startDate: startDateLY, endDate: endDateLY };
+}