@zeniai/client-epic-state 4.19.28 → 4.19.30

package/lib/esm/view/profitAndLoss/profitAndLossReducer.js

@@ -0,0 +1,167 @@
+import { createSlice } from '@reduxjs/toolkit';
+import { mapReportPayloadV2ToReportV2 } from '../../commonPayloadTypes/v2/viewAndReportPayloadv2';
+export const initialPandLState = {
+    bookCloseDate: undefined,
+    fetchState: {
+        month: {
+            fetchState: 'Not-Started',
+            error: undefined,
+        },
+        quarter: {
+            fetchState: 'Not-Started',
+            error: undefined,
+        },
+        year: {
+            fetchState: 'Not-Started',
+            error: undefined,
+        },
+    },
+    uiState: {
+        nodeCollapseState: {},
+        scrollPosition: {
+            scrollTop: 0,
+            scrollLeft: undefined,
+        },
+    },
+    firstMonthOfFY: 1,
+    reportId: 'profit_and_loss',
+    reportTitle: 'profit_and_loss',
+};
+export const initialState = {
+    pandL: initialPandLState,
+    pandLByForecastID: {},
+};
+const profitAndLoss = createSlice({
+    name: 'profitAndLoss',
+    initialState: initialState,
+    reducers: {
+        fetchProfitAndLoss: {
+            prepare(forecastId, cacheOverride = false) {
+                return { payload: { forecastId, cacheOverride } };
+            },
+            reducer(
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            _draft, 
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            _action) {
+                // nothing to do here
+            },
+        },
+        fetchProfitAndLossForTimeframe: {
+            prepare(timeframe, forecastId, fetchFullReport = true, cacheOverride = false) {
+                return {
+                    payload: { forecastId, timeframe, fetchFullReport, cacheOverride },
+                };
+            },
+            reducer(draft, action) {
+                const timeframe = action.payload.timeframe;
+                const pAndLState = getState(draft, action.payload.forecastId);
+                const fetchState = {
+                    ...pAndLState.fetchState,
+                };
+                fetchState[timeframe] = {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                };
+                updateState(draft, action.payload.forecastId, { fetchState });
+            },
+        },
+        updateProfitAndLossForTimeframe(draft, action) {
+            doUpdatedProfitAndLoss(draft, action.payload.forecastId, action.payload.timeframe, action.payload.report);
+        },
+        updateProfitAndLossForTimeframeFailure: {
+            prepare(error, forecastId, timeframe) {
+                return {
+                    payload: {
+                        error,
+                        forecastId,
+                        timeframe,
+                    },
+                };
+            },
+            reducer(draft, action) {
+                const pandL = getState(draft, action.payload.forecastId);
+                const fetchState = {
+                    ...pandL.fetchState,
+                };
+                fetchState[action.payload.timeframe] = {
+                    fetchState: 'Error',
+                    error: action.payload.error,
+                };
+                updateState(draft, action.payload.forecastId, { fetchState });
+            },
+        },
+        updateProfitAndLossUIState(draft, action) {
+            const { nodeCollapseState, forecastId, scrollPosition, resetLeftScroll } = action.payload;
+            const pandL = getState(draft, forecastId);
+            const uiState = {
+                ...pandL.uiState,
+            };
+            if (nodeCollapseState != null) {
+                uiState.nodeCollapseState = Object.assign({}, uiState.nodeCollapseState, {
+                    [nodeCollapseState.nodeId]: nodeCollapseState.isCollapsed,
+                });
+            }
+            if (resetLeftScroll === true && uiState.scrollPosition != null) {
+                uiState.scrollPosition.scrollLeft = undefined;
+            }
+            else if (scrollPosition != null) {
+                uiState.scrollPosition = scrollPosition;
+            }
+            updateState(draft, forecastId, { uiState });
+        },
+        resetProfitAndLossNodeCollapseState(draft) {
+            draft.pandL.uiState.nodeCollapseState = {};
+        },
+        clearProfitAndLoss(draft) {
+            Object.assign(draft, initialState);
+        },
+    },
+});
+export const { fetchProfitAndLoss, fetchProfitAndLossForTimeframe, updateProfitAndLossForTimeframe, updateProfitAndLossForTimeframeFailure, updateProfitAndLossUIState, resetProfitAndLossNodeCollapseState, clearProfitAndLoss, } = profitAndLoss.actions;
+export default profitAndLoss.reducer;
+const doUpdatedProfitAndLoss = (draft, forecastId, timeframe, pandLReport) => {
+    const report = mapReportPayloadV2ToReportV2(pandLReport.report);
+    const pandL = getState(draft, forecastId);
+    pandL.dataAvailable = report.dataAvailable;
+    pandL.firstMonthOfFY = report.firstMonthOfFY;
+    pandL.bookCloseDate = report.bookCloseDate;
+    pandL.fetchState[timeframe].fetchState = 'Completed';
+    updateState(draft, forecastId, pandL);
+};
+export function getState(state, forecastId) {
+    if (forecastId != null && forecastId.length > 0) {
+        return Object.assign({}, state.pandLByForecastID[forecastId] ?? {
+            ...initialPandLState,
+            uiState: {
+                ...initialPandLState.uiState,
+                scrollPosition: {
+                    ...initialPandLState.uiState.scrollPosition,
+                    scrollLeft: 0, // Default Scroll Left should be 0 for forecast table
+                },
+            },
+        });
+    }
+    else {
+        return state.pandL;
+    }
+}
+function updateState(state, forecastId, updates) {
+    if (forecastId != null && forecastId.length > 0) {
+        const currentValue = state.pandLByForecastID[forecastId] ?? {
+            ...initialPandLState,
+            uiState: {
+                ...initialPandLState.uiState,
+                scrollPosition: {
+                    ...initialPandLState.uiState.scrollPosition,
+                    scrollLeft: 0, // Default Scroll Left should be 0 for forecast table
+                },
+            },
+        };
+        const updatedValue = Object.assign({}, currentValue, updates);
+        state.pandLByForecastID[forecastId] = updatedValue;
+    }
+    else {
+        state.pandL = Object.assign({}, state.pandL, updates);
+    }
+}

package/lib/esm/view/profitAndLoss/profitAndLossSelector.js

@@ -0,0 +1,108 @@
+import { newBalancesFilter, } from '../../commonStateTypes/coaBalance/coaBalancesFilter';
+import { getNumberOfPeriods } from '../../commonStateTypes/dataAvailable';
+import { reduceAllFetchState, reduceAnyCompletedFetchState, } from '../../commonStateTypes/reduceFetchState';
+import { getForecast } from '../../entity/forecast/forecastSelector';
+import { getCalculatedSectionAccountsViewReport, getSectionAccountsViewReport, } from '../../entity/sectionAccountsView/sectionAccountsViewSelector';
+import { profitAndLossIdsInOrder } from '../profitAndLossClassesView/profitAndLossClassesViewSelector';
+import { ALL_PANDL_REPORT_VIEW_CALCULATED_SECTION_IDS, ALL_PANDL_REPORT_VIEW_SECTION_IDS, } from '../profitAndLossClassesView/profitAndLossClassesViewSelectorTypes';
+import { reportIdUniqueKey } from './profitAndLossForTimeframeEpic';
+import { getState } from './profitAndLossReducer';
+/**
+ * Get P&L with forecast data overlaid on actuals.
+ * @param filter : ;
+ * @param forecastId
+ * @param accountState
+ * @param accountGroupState
+ * @param forecastState
+ * @param state
+ * @notes IMPORTANT:
+ * 1. Here the forecast data for the given forecast ID is super imposed on actual data.
+ * 2. This method can super impose forecast data on whole data available date range,
+ * rather than restricting to ONLY forecast date range.
+function getProfitAndLossWithForecastOnDataAvailableDateRange(
+ * This is different from zeni REST API endpoint where it only super imposes forecast data ONLY for the forecast time period.
+ */
+export const getProfitAndLossReport = (filter, forecastId, accountState, accountGroupState, sectionsState, profitAndLossState, forecastState) => {
+    if (filter.timeframe === 'week' || filter.timeframe === 'free_range') {
+        throw Error('free_range or week period is invalid');
+    }
+    const pandLState = getState(profitAndLossState, forecastId);
+    const { reducedAllFetchState, reducedAnyFetchState, fetchStateByTimeframe } = getPandLReportFetchState(forecastId, profitAndLossState);
+    const reportId = reportIdUniqueKey(forecastId);
+    const sections = {};
+    const calculatedSections = {};
+    const selectedTimeframeFetchState = fetchStateByTimeframe[filter.timeframe];
+    if (selectedTimeframeFetchState.fetchState === 'Completed') {
+        ALL_PANDL_REPORT_VIEW_SECTION_IDS.forEach((sectionId) => {
+            sections[`${sectionId}`] = getSectionAccountsViewReport(accountState, accountGroupState, sectionsState, {
+                reportId,
+                sectionId,
+            }, filter);
+        });
+        ALL_PANDL_REPORT_VIEW_CALCULATED_SECTION_IDS.forEach((sectionId) => {
+            calculatedSections[`${sectionId}`] =
+                getCalculatedSectionAccountsViewReport(sectionsState, {
+                    reportId,
+                    sectionId,
+                }, filter);
+        });
+    }
+    const forecast = pandLState.forecastId != null
+        ? getForecast(forecastState, pandLState.forecastId)
+        : undefined;
+    return {
+        sections,
+        calculatedSections,
+        reportId: pandLState.reportId,
+        reportTitle: pandLState.reportTitle,
+        firstMonthOfFY: pandLState.firstMonthOfFY,
+        dataAvailable: pandLState.dataAvailable,
+        bookCloseDate: pandLState.bookCloseDate,
+        version: pandLState.version,
+        status: pandLState.status,
+        reducedAllFetchState,
+        reducedAnyFetchState,
+        fetchStateByTimeframe,
+        fetchState: selectedTimeframeFetchState.fetchState,
+        error: selectedTimeframeFetchState.error,
+        filter: filter,
+        uiState: pandLState.uiState,
+        idsInOrder: profitAndLossIdsInOrder,
+        forecast,
+    };
+};
+/**
+ * Get FULL profit and loss report for given data available range,
+ * In case if data available range is null, then it returns empty
+ * @param timeframe
+ * @param forecastId
+ * @param accountState
+ * @param accountGroupState
+ * @param forecastState
+ * @param state
+ */
+export function getProfitAndLossForFullDataAvailableRange(timeframe, forecastId, accountState, accountGroupState, sectionsState, forecastState, state) {
+    const pandLState = getState(state, forecastId);
+    const numberOfPeriods = getNumberOfPeriods(pandLState.firstMonthOfFY, timeframe, pandLState.dataAvailable) ?? 0;
+    return getProfitAndLossReport(newBalancesFilter(pandLState.firstMonthOfFY, timeframe, numberOfPeriods), forecastId, accountState, accountGroupState, sectionsState, state, forecastState);
+}
+export const getPandLReportFetchState = (forecastId, profitAndLossState) => {
+    const pandLState = getState(profitAndLossState, forecastId);
+    return {
+        reducedAnyFetchState: reduceAnyCompletedFetchState([
+            pandLState.fetchState.month,
+            pandLState.fetchState.quarter,
+            pandLState.fetchState.year,
+        ]),
+        reducedAllFetchState: reduceAllFetchState([
+            pandLState.fetchState.month,
+            pandLState.fetchState.quarter,
+            pandLState.fetchState.year,
+        ]),
+        fetchStateByTimeframe: {
+            month: pandLState.fetchState.month,
+            quarter: pandLState.fetchState.quarter,
+            year: pandLState.fetchState.year,
+        },
+    };
+};

package/lib/esm/view/profitAndLoss/profitAndLossState.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/view/profitAndLossClassesView/profitAndLossClassesViewEpic.js

@@ -0,0 +1,30 @@
+import { from } from 'rxjs';
+import { filter, switchMap } from 'rxjs/operators';
+import { fetchProfitAndLossClassesView, fetchProfitAndLossForTimeframeClassesView, } from './profitAndLossClassesViewReducer';
+export const fetchProfitAndLossClassesViewEpic = (actions$, state) => actions$.pipe(filter(fetchProfitAndLossClassesView.match), switchMap((action) => {
+    const { cacheOverride } = action.payload;
+    if (cacheOverride === true) {
+        return from([
+            fetchProfitAndLossForTimeframeClassesView('month'),
+            fetchProfitAndLossForTimeframeClassesView('quarter'),
+            fetchProfitAndLossForTimeframeClassesView('year'),
+        ]);
+    }
+    else {
+        const fetchActions = [];
+        const classFetchState = state.value.profitAndLossClassesViewState.fetchState;
+        if (classFetchState['month'].fetchState !== 'In-Progress' &&
+            classFetchState['month'].fetchState !== 'Completed') {
+            fetchActions.push(fetchProfitAndLossForTimeframeClassesView('month'));
+        }
+        if (classFetchState['quarter'].fetchState !== 'In-Progress' &&
+            classFetchState['quarter'].fetchState !== 'Completed') {
+            fetchActions.push(fetchProfitAndLossForTimeframeClassesView('quarter'));
+        }
+        if (classFetchState['year'].fetchState !== 'In-Progress' &&
+            classFetchState['year'].fetchState !== 'Completed') {
+            fetchActions.push(fetchProfitAndLossForTimeframeClassesView('year'));
+        }
+        return from(fetchActions);
+    }
+}));

package/lib/esm/view/profitAndLossClassesView/profitAndLossClassesViewPayload.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/view/profitAndLossClassesView/profitAndLossClassesViewReducer.js

@@ -0,0 +1,118 @@
+import { createSlice } from '@reduxjs/toolkit';
+import { mapReportPayloadV2ToReportV2 } from '../../commonPayloadTypes/v2/viewAndReportPayloadv2';
+import { geNestedClassIDHierarchyForReport } from '../../commonStateTypes/classesView/getNestedClassIDHierarchyForReport';
+import { toClassMetadata } from '../../entity/class/classPayload';
+export const initialState = {
+    classHierarchy: [],
+    bookCloseDate: undefined,
+    fetchState: {
+        month: {
+            fetchState: 'Not-Started',
+            error: undefined,
+        },
+        quarter: {
+            fetchState: 'Not-Started',
+            error: undefined,
+        },
+        year: {
+            fetchState: 'Not-Started',
+            error: undefined,
+        },
+    },
+    uiState: {
+        nodeCollapseState: {},
+        scrollPosition: undefined,
+        accountViewMode: 'account_group',
+        classesToFilterOut: [],
+    },
+    firstMonthOfFY: 1,
+    reportId: 'profit_and_loss_by_classes',
+    reportTitle: 'profit_and_loss_by_classes',
+};
+const profitAndLossClassesView = createSlice({
+    name: 'profitAndLossClassesView',
+    initialState,
+    reducers: {
+        fetchProfitAndLossClassesView: {
+            prepare(cacheOverride = false) {
+                return { payload: { cacheOverride } };
+            },
+            reducer(
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            _draft, 
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            _action) {
+                // nothing to do here
+            },
+        },
+        fetchProfitAndLossForTimeframeClassesView: {
+            prepare(timeframe, fetchFullReport = true, cacheOverride = false) {
+                return { payload: { timeframe, fetchFullReport, cacheOverride } };
+            },
+            reducer(draft, action) {
+                const timeframe = action.payload.timeframe;
+                draft.fetchState[timeframe].fetchState = 'In-Progress';
+                draft.fetchState[timeframe].error = undefined;
+            },
+        },
+        updateProfitAndLossForTimeframeClassesView(draft, action) {
+            doUpdatedProfitAndLossClassesView(draft, action.payload.timeframe, action.payload.report);
+        },
+        updateProfitAndLossForTimeframeClassesViewFailure: {
+            prepare(error, timeframe) {
+                return {
+                    payload: {
+                        error,
+                        timeframe,
+                    },
+                };
+            },
+            reducer(draft, action) {
+                draft.fetchState[action.payload.timeframe] = {
+                    fetchState: 'Error',
+                    error: action.payload.error,
+                };
+            },
+        },
+        updateClassesToFilterOut(draft, action) {
+            draft.uiState.classesToFilterOut = action.payload.classesToFilterOut;
+        },
+        updateProfitAndLossClassesViewUIState(draft, action) {
+            const { nodeCollapseState, scrollPosition, resetLeftScroll } = action.payload;
+            if (nodeCollapseState != null) {
+                draft.uiState.nodeCollapseState = Object.assign({}, draft.uiState.nodeCollapseState, {
+                    [nodeCollapseState.nodeId]: nodeCollapseState.isCollapsed,
+                });
+            }
+            if (resetLeftScroll === true && draft.uiState.scrollPosition != null) {
+                draft.uiState.scrollPosition.scrollLeft = undefined;
+            }
+            else if (scrollPosition != null) {
+                draft.uiState.scrollPosition = scrollPosition;
+            }
+        },
+        updateAccountViewMode(draft, action) {
+            draft.uiState.accountViewMode = action.payload.viewMode;
+        },
+        resetProfitAndLossClassesNodeCollapseState(draft) {
+            draft.uiState.nodeCollapseState = {};
+        },
+        clearProfitAndLossClassesView(draft) {
+            Object.assign(draft, initialState);
+        },
+    },
+});
+export const { fetchProfitAndLossClassesView, fetchProfitAndLossForTimeframeClassesView, updateProfitAndLossForTimeframeClassesView, updateProfitAndLossForTimeframeClassesViewFailure, updateClassesToFilterOut, updateProfitAndLossClassesViewUIState, updateAccountViewMode, resetProfitAndLossClassesNodeCollapseState, clearProfitAndLossClassesView, } = profitAndLossClassesView.actions;
+export default profitAndLossClassesView.reducer;
+const doUpdatedProfitAndLossClassesView = (draft, timeframe, pandLReport) => {
+    const report = mapReportPayloadV2ToReportV2(pandLReport.report);
+    draft.dataAvailable = report.dataAvailable;
+    draft.firstMonthOfFY = report.firstMonthOfFY;
+    draft.bookCloseDate = report.bookCloseDate;
+    draft.status = report.status;
+    draft.fetchState[timeframe].fetchState = 'Completed';
+    const classMetadata = pandLReport.report.classes.map((eachClass) => toClassMetadata(eachClass));
+    if (draft.classHierarchy.length <= 0) {
+        draft.classHierarchy = geNestedClassIDHierarchyForReport(classMetadata);
+    }
+};

package/lib/esm/view/profitAndLossClassesView/profitAndLossClassesViewSelector.js

@@ -0,0 +1,94 @@
+import { getDifferenceOfBalancesGroupedByPeriod } from '../../commonStateTypes/coaBalance/classBalances/getDifferenceOfBalancesGroupedByPeriod';
+import { getSumOfBalancesByGroupedByPeriod } from '../../commonStateTypes/coaBalance/classBalances/getSumOfBalancesGroupedByPeriod';
+import { getCOABalances } from '../../commonStateTypes/coaBalance/coaBalance';
+import { getSectionClassesViewReport } from '../../entity/sectionClassesViewV2/sectionClassesViewSelector';
+import { ALL_PANDL_REPORT_VIEW_SECTION_IDS, } from './profitAndLossClassesViewSelectorTypes';
+export const profitAndLossIdsInOrder = [
+    'income',
+    'cogs',
+    'grossProfit',
+    'expenses',
+    'earningsBeforeInterestAndTax',
+    'otherIncome',
+    'otherExpenses',
+    'netOtherIncome',
+    'netIncome',
+];
+export const getProfitAndLossClassesView = (filter, accountState, classState, sectionsState, profitAndLossClassesViewState) => {
+    const fetchState = reduceFetchState([
+        profitAndLossClassesViewState.fetchState.month,
+        profitAndLossClassesViewState.fetchState.quarter,
+        profitAndLossClassesViewState.fetchState.year,
+    ]);
+    const reportId = 'profit_and_loss_by_classes';
+    const sections = {};
+    const calculatedSections = {};
+    if (fetchState.fetchState === 'Completed') {
+        ALL_PANDL_REPORT_VIEW_SECTION_IDS.forEach((sectionId) => {
+            sections[`${sectionId}`] = getSectionClassesViewReport(accountState, classState, sectionsState, {
+                reportId,
+                sectionId,
+            }, filter);
+        });
+        const grossProfitBalancesByPeriod = getDifferenceOfBalancesGroupedByPeriod(sections['income'].sectionBalancesTotalByPeriod, sections['cogs'].sectionBalancesTotalByPeriod);
+        calculatedSections['grossProfit'] = getCOABalances(grossProfitBalancesByPeriod, filter);
+        const ebitBalancesByPeriod = getDifferenceOfBalancesGroupedByPeriod(grossProfitBalancesByPeriod, sections['expenses'].sectionBalancesTotalByPeriod);
+        calculatedSections['earningsBeforeInterestAndTax'] = getCOABalances(ebitBalancesByPeriod, filter);
+        const netOtherIncomeBalances = getDifferenceOfBalancesGroupedByPeriod(sections['otherIncome'].sectionBalancesTotalByPeriod, sections['otherExpenses'].sectionBalancesTotalByPeriod);
+        calculatedSections['netOtherIncome'] = getCOABalances(netOtherIncomeBalances, filter);
+        const netIncomeBalances = netOtherIncomeBalances != null
+            ? getSumOfBalancesByGroupedByPeriod([
+                ebitBalancesByPeriod,
+                netOtherIncomeBalances,
+            ])
+            : ebitBalancesByPeriod;
+        calculatedSections['netIncome'] = getCOABalances(netIncomeBalances, filter);
+    }
+    const classHierarchy = profitAndLossClassesViewState.classHierarchy;
+    return {
+        sections,
+        calculatedSections,
+        reportId: profitAndLossClassesViewState.reportId,
+        reportTitle: profitAndLossClassesViewState.reportTitle,
+        firstMonthOfFY: profitAndLossClassesViewState.firstMonthOfFY,
+        dataAvailable: profitAndLossClassesViewState.dataAvailable,
+        bookCloseDate: profitAndLossClassesViewState.bookCloseDate,
+        version: profitAndLossClassesViewState.version,
+        status: profitAndLossClassesViewState.status,
+        fetchState: fetchState.fetchState,
+        error: fetchState.error,
+        filter: filter,
+        uiState: profitAndLossClassesViewState.uiState,
+        classHierarchy,
+        classesToFilterOut: profitAndLossClassesViewState.uiState.classesToFilterOut,
+        idsInOrder: profitAndLossIdsInOrder,
+    };
+};
+function reduceFetchState(fetchStateList) {
+    const isAnyProgress = fetchStateList.reduce((prevValue, currentValue) => {
+        return prevValue === true || currentValue.fetchState === 'In-Progress';
+    }, false);
+    const isAllCompleted = fetchStateList.reduce((prevValue, currentValue) => {
+        return prevValue === true && currentValue.fetchState === 'Completed';
+    }, true);
+    const isAnyError = fetchStateList.reduce((prevValue, currentValue) => {
+        return prevValue === true || currentValue.fetchState === 'Error';
+    }, false);
+    const error = fetchStateList.reduce((prevValue, currentValue) => {
+        return prevValue ?? currentValue.error;
+    }, undefined);
+    let fetchState = 'Not-Started';
+    if (isAnyProgress) {
+        fetchState = 'In-Progress';
+    }
+    else if (isAllCompleted) {
+        fetchState = 'Completed';
+    }
+    else if (isAnyError) {
+        fetchState = 'Error';
+    }
+    return {
+        fetchState,
+        error,
+    };
+}

package/lib/esm/view/profitAndLossClassesView/profitAndLossClassesViewSelectorTypes.js

@@ -0,0 +1,21 @@
+import { stringToUnion } from '../../commonStateTypes/stringToUnion';
+export const ALL_PANDL_REPORT_VIEW_SECTION_IDS = [
+    'cogs',
+    'expenses',
+    'income',
+    'otherExpenses',
+    'otherIncome',
+    'netOperatingIncome',
+];
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const toPandLReportViewSectionID = (v) => stringToUnion(v, ALL_PANDL_REPORT_VIEW_SECTION_IDS);
+export const isPandLReportViewSectionID = (id) => ALL_PANDL_REPORT_VIEW_SECTION_IDS.find((sectionId) => id === sectionId) != null;
+export const ALL_PANDL_REPORT_VIEW_CALCULATED_SECTION_IDS = [
+    'grossProfit',
+    'earningsBeforeInterestAndTax',
+    'netOtherIncome',
+    'netIncome',
+];
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const toPandLReportViewCalculatedSectionID = (v) => stringToUnion(v, ALL_PANDL_REPORT_VIEW_CALCULATED_SECTION_IDS);
+export const isPandLReportViewCalculatedSectionID = (id) => ALL_PANDL_REPORT_VIEW_CALCULATED_SECTION_IDS.find((calcId) => id === calcId) != null;

package/lib/esm/view/profitAndLossClassesView/profitAndLossClassesViewState.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/view/profitAndLossClassesView/profitAndLossForTimeframeClassesViewEpic.js

@@ -0,0 +1,42 @@
+import { from, of } from 'rxjs';
+import { catchError, filter, mergeMap } from 'rxjs/operators';
+import { updateSectionClassesView } from '../../entity/sectionClassesViewV2/sectionClassesViewReducer';
+import { createZeniAPIStatus, isSuccessResponse } from '../../responsePayload';
+import { fetchProfitAndLossForTimeframeClassesView, updateProfitAndLossForTimeframeClassesView, updateProfitAndLossForTimeframeClassesViewFailure, } from './profitAndLossClassesViewReducer';
+export const fetchProfitAndLossForTimeframeClassesViewEpic = (actions$, _, zeniAPI) => actions$.pipe(filter(fetchProfitAndLossForTimeframeClassesView.match), mergeMap((action) => {
+    const getTimeSeriesGroup = (timeframe) => {
+        switch (timeframe) {
+            case 'month':
+                return 'months';
+            case 'quarter':
+                return 'quarters';
+            case 'year':
+                return 'years';
+        }
+    };
+    const queryValue = {
+        is_full_response: action.payload.fetchFullReport,
+        time_series_groups: [getTimeSeriesGroup(action.payload.timeframe)],
+        is_group_by_class: true,
+    };
+    return zeniAPI
+        .getJSON(`${zeniAPI.apiEndPoints.accountMicroServiceBaseUrl}/2.0/reports/profit_and_loss?query=${encodeURIComponent(JSON.stringify(queryValue))}`)
+        .pipe(mergeMap((response) => {
+        if (response.data != null && isSuccessResponse(response)) {
+            const actions = [];
+            actions.push(updateSectionClassesView(action.payload.timeframe, 'cogs', 'profit_and_loss_by_classes', response.data.report.cogs, response.data.report.classes, response.data.report.accounts, response.data.report.currency));
+            actions.push(updateSectionClassesView(action.payload.timeframe, 'expenses', 'profit_and_loss_by_classes', response.data.report.expenses, response.data.report.classes, response.data.report.accounts, response.data.report.currency));
+            actions.push(updateSectionClassesView(action.payload.timeframe, 'income', 'profit_and_loss_by_classes', response.data.report.income, response.data.report.classes, response.data.report.accounts, response.data.report.currency));
+            actions.push(updateSectionClassesView(action.payload.timeframe, 'otherExpenses', 'profit_and_loss_by_classes', response.data.report.other_expenses, response.data.report.classes, response.data.report.accounts, response.data.report.currency));
+            actions.push(updateSectionClassesView(action.payload.timeframe, 'otherIncome', 'profit_and_loss_by_classes', response.data.report.other_income, response.data.report.classes, response.data.report.accounts, response.data.report.currency));
+            actions.push(updateProfitAndLossForTimeframeClassesView({
+                timeframe: action.payload.timeframe,
+                report: response.data,
+            }));
+            return from(actions);
+        }
+        else {
+            return of(updateProfitAndLossForTimeframeClassesViewFailure(response.status, action.payload.timeframe));
+        }
+    }), catchError((error) => of(updateProfitAndLossForTimeframeClassesViewFailure(createZeniAPIStatus('Unexpected Error', 'P&L REST API call errored out' + JSON.stringify(error)), action.payload.timeframe))));
+}));