@zeniai/client-epic-state 4.20.3-betaRD2 → 4.20.3-betaRD21

package/lib/esm/view/expenseAutomationView/reducers/jeSchedulesViewReducer.js

@@ -44,7 +44,8 @@ export const initialState = {
     uiState: {
         searchString: '',
         scrollPosition: { scrollTop: 0, scrollLeft: undefined },
-        sortKey: 'startMonth',
+        selectedMainTab: 'pending_review',
+        sortKey: 'transactionDate',
         sortOrder: 'descending',
         totalCount: 0,
         limit: 10,
@@ -380,6 +381,9 @@ const expenseAutomationJESchedulesView = createSlice({
             if (action.payload.scrollPosition != null) {
                 draft.uiState.scrollPosition = action.payload.scrollPosition;
             }
+            if (action.payload.selectedMainTab != null) {
+                draft.uiState.selectedMainTab = action.payload.selectedMainTab;
+            }
         },
         clearExpenseAutomationJESchedulesView(draft) {
             Object.assign(draft, initialState);

package/lib/esm/view/expenseAutomationView/reducers/reconciliationViewReducer.js

@@ -37,7 +37,15 @@ export const initialReconciliationTabsState = {
     },
 };
 export const initialActionFetchState = {
+    excludeAccountFetch: {
+        fetchState: 'Not-Started',
+        error: undefined,
+    },
     excludeFetchById: {},
+    includeAccountFetch: {
+        fetchState: 'Not-Started',
+        error: undefined,
+    },
     reconcileFetch: {
         fetchState: 'Not-Started',
         error: undefined,
@@ -51,6 +59,7 @@ export const initialActionFetchState = {
 export const initialState = {
     accountReconciliationRecordsBySelectedPeriod: {},
     accountConnectionStatusByAccountID: {},
+    excludedAccountExclusionInfo: {},
     fetchState: 'Not-Started',
     error: undefined,
     selectedTab: 'review',
@@ -60,10 +69,12 @@ export const initialState = {
     selectedAccountId: undefined,
     statementUploadChosen: false,
     reconListUIState: {
+        nodeCollapseState: {},
         scrollPosition: {
             scrollTop: 0,
         },
     },
+    excludedAccountIDs: [],
 };
 // Create slice with reducers
 const expenseAutomationReconciliationView = createSlice({
@@ -132,7 +143,7 @@ const expenseAutomationReconciliationView = createSlice({
         fetchReconciliationSuccess: {
             reducer(draft, action) {
                 if (action.payload.accountId == null) {
-                    updateAllReconciliation(draft, action.payload.reconciliation.accounts, action.payload.selectedPeriod, action.payload.reconciliation.reconciliation, action.payload.refreshViewInBackground);
+                    updateAllReconciliation(draft, action.payload.reconciliation.accounts, action.payload.selectedPeriod, action.payload.reconciliation.reconciliation, action.payload.refreshViewInBackground, action.payload.reconciliation.excluded_accounts ?? []);
                 }
                 else if (action.payload.reconciliation.reconciliation.length > 0 &&
                     action.payload.reconciliation.accounts.length > 0) {
@@ -344,6 +355,10 @@ const expenseAutomationReconciliationView = createSlice({
         updateReconListScrollPosition: (draft, action) => {
             draft.reconListUIState.scrollPosition = action.payload.scrollPosition;
         },
+        updateNodeCollapseState: (draft, action) => {
+            draft.reconListUIState.nodeCollapseState[action.payload.nodeId] =
+                action.payload.collapsed;
+        },
         setConnectionInProgressForAccount: (draft, action) => {
             if (draft.accountConnectionStatusByAccountID[action.payload.accountId] ==
                 null) {
@@ -421,6 +436,85 @@ const expenseAutomationReconciliationView = createSlice({
                 ...localData,
             };
         },
+        excludeAccountFromReconciliation: {
+            reducer(draft) {
+                draft.actionFetchState.excludeAccountFetch = {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                };
+            },
+            prepare(payload) {
+                return { payload };
+            },
+        },
+        excludeAccountFromReconciliationSuccess: (draft, action) => {
+            draft.actionFetchState.excludeAccountFetch = {
+                fetchState: 'Completed',
+                error: undefined,
+            };
+            const { account, selectedPeriod } = action.payload;
+            if (account != null) {
+                if (!draft.excludedAccountIDs.includes(account.account_id)) {
+                    draft.excludedAccountIDs.push(account.account_id);
+                }
+                updateExcludedAccountExclusionInfo(draft, account);
+                const monthYearPeriodId = toMonthYearPeriodId(selectedPeriod);
+                if (draft.accountReconciliationRecordsBySelectedPeriod[monthYearPeriodId]
+                    ?.accountIDs != null) {
+                    draft.accountReconciliationRecordsBySelectedPeriod[monthYearPeriodId].accountIDs = draft.accountReconciliationRecordsBySelectedPeriod[monthYearPeriodId].accountIDs.filter((id) => id !== account.account_id);
+                }
+            }
+        },
+        excludeAccountFromReconciliationFailure: (draft, action) => {
+            draft.actionFetchState.excludeAccountFetch = {
+                fetchState: 'Error',
+                error: action.payload.error,
+            };
+        },
+        includeAccountInReconciliation: {
+            reducer(draft) {
+                draft.actionFetchState.includeAccountFetch = {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                };
+            },
+            prepare(payload) {
+                return { payload };
+            },
+        },
+        includeAccountInReconciliationSuccess: (draft, action) => {
+            draft.actionFetchState.includeAccountFetch = {
+                fetchState: 'Completed',
+                error: undefined,
+            };
+            const { reconciliation, selectedPeriod } = action.payload;
+            if (reconciliation == null) {
+                return;
+            }
+            const accountId = reconciliation.account_id;
+            draft.excludedAccountIDs = draft.excludedAccountIDs.filter((id) => id !== accountId);
+            delete draft.excludedAccountExclusionInfo[accountId];
+            const monthYearPeriodId = toMonthYearPeriodId(selectedPeriod);
+            const accountReconciliationRecords = draft.accountReconciliationRecordsBySelectedPeriod[monthYearPeriodId];
+            if (accountReconciliationRecords != null) {
+                if (!accountReconciliationRecords.accountIDs.includes(accountId)) {
+                    accountReconciliationRecords.accountIDs.push(accountId);
+                }
+                // put this in a function
+                updateReconciliationByAccountIDOnIncludeAccount(draft, accountId, reconciliation, monthYearPeriodId);
+            }
+            draft.accountConnectionStatusByAccountID[accountId] = {
+                status: toBankStatusCodeType(reconciliation.bank_status.code),
+                connectionInProgress: false,
+                paymentAccountId: undefined,
+            };
+        },
+        includeAccountInReconciliationFailure: (draft, action) => {
+            draft.actionFetchState.includeAccountFetch = {
+                fetchState: 'Error',
+                error: action.payload.error,
+            };
+        },
         updateStatementUploadChosen: (draft, action) => {
             draft.statementUploadChosen = action.payload.statementUploadChosen;
         },
@@ -430,10 +524,38 @@ const expenseAutomationReconciliationView = createSlice({
     },
 });
 // Export actions
-export const { fetchReconciliation, fetchReconciliationFailure, fetchReconciliationSuccess, saveReconciliationDetail, saveReconciliationDetailFailure, updateSelectedAccountId, setConnectionInProgressForAccount, setStatementParseInProgress, updateReconcileTabLocalData, updateReconcileTabListSortState, updateReconcileTabListScrollState, saveReconciliationDetailSuccess, updateSelectedTab, updateBalancesLocalData, initialiseLocalDataForSelectedAccountId, clearExpenseAutomationReconciliationView, updateSelectedDrawerAccountId, updateReviewTabSortState, initializeReconciliationReviewTabLocalData, updateReviewTabLocalData, saveReconciliationReview, updateSaveReconciliationReviewFetchStatus, updateReconListScrollPosition, updateAccountReconciliationLocalData, deleteAccountStatement, deleteAccountStatementSuccess, deleteAccountStatementFailure, uploadAccountStatement, uploadAccountStatementSuccess, uploadAccountStatementFailure, updateStatementUploadChosen, } = expenseAutomationReconciliationView.actions;
+export const { fetchReconciliation, fetchReconciliationFailure, fetchReconciliationSuccess, saveReconciliationDetail, saveReconciliationDetailFailure, updateSelectedAccountId, setConnectionInProgressForAccount, setStatementParseInProgress, updateReconcileTabLocalData, updateReconcileTabListSortState, updateReconcileTabListScrollState, saveReconciliationDetailSuccess, updateSelectedTab, updateBalancesLocalData, initialiseLocalDataForSelectedAccountId, clearExpenseAutomationReconciliationView, updateSelectedDrawerAccountId, updateReviewTabSortState, initializeReconciliationReviewTabLocalData, updateReviewTabLocalData, saveReconciliationReview, updateSaveReconciliationReviewFetchStatus, updateReconListScrollPosition, updateAccountReconciliationLocalData, deleteAccountStatement, deleteAccountStatementSuccess, deleteAccountStatementFailure, excludeAccountFromReconciliation, excludeAccountFromReconciliationSuccess, excludeAccountFromReconciliationFailure, includeAccountInReconciliation, includeAccountInReconciliationSuccess, includeAccountInReconciliationFailure, uploadAccountStatement, uploadAccountStatementSuccess, uploadAccountStatementFailure, updateStatementUploadChosen, updateNodeCollapseState, } = expenseAutomationReconciliationView.actions;
 // Export reducer
 export default expenseAutomationReconciliationView.reducer;
-function updateAllReconciliation(draft, accounts, selectedPeriod, reconciliationData, refreshViewInBackground) {
+function updateAllReconciliation(draft, accounts, selectedPeriod, reconciliationData, refreshViewInBackground, excludedAccounts) {
+    draft.excludedAccountIDs = excludedAccounts.map((ea) => ea.account_id);
+    draft.excludedAccountExclusionInfo = {};
+    excludedAccounts.forEach((ea) => {
+        const { exclusion_info } = ea;
+        draft.excludedAccountExclusionInfo[ea.account_id] = {
+            bankBalance: exclusion_info.bank_balance != null
+                ? {
+                    amount: exclusion_info.bank_balance,
+                    currencyCode: ea.currency_code ?? 'USD',
+                    currencySymbol: ea.currency_symbol ?? '$',
+                }
+                : undefined,
+            clearedBalance: exclusion_info.cleared_balance != null
+                ? {
+                    amount: exclusion_info.cleared_balance,
+                    currencyCode: ea.currency_code ?? 'USD',
+                    currencySymbol: ea.currency_symbol ?? '$',
+                }
+                : undefined,
+            variance: exclusion_info.variance != null
+                ? {
+                    amount: exclusion_info.variance,
+                    currencyCode: ea.currency_code ?? 'USD',
+                    currencySymbol: ea.currency_symbol ?? '$',
+                }
+                : undefined,
+        };
+    });
     draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)] = {
         accountIDs: [],
         reconciliationByAccountID: {},
@@ -516,3 +638,41 @@ function updateReconciliationByAccountID(draft, accounts, selectedPeriod, accoun
         };
     }
 }
+const updateExcludedAccountExclusionInfo = (draft, account) => {
+    draft.excludedAccountExclusionInfo[account.account_id] = {
+        bankBalance: account.bank_balance != null
+            ? {
+                amount: account.bank_balance,
+                currencyCode: account.currency_code ?? 'USD',
+                currencySymbol: account.currency_symbol ?? '$',
+            }
+            : undefined,
+        clearedBalance: account.cleared_balance != null
+            ? {
+                amount: account.cleared_balance,
+                currencyCode: account.currency_code ?? 'USD',
+                currencySymbol: account.currency_symbol ?? '$',
+            }
+            : undefined,
+        variance: account.variance != null
+            ? {
+                amount: account.variance,
+                currencyCode: account.currency_code ?? 'USD',
+                currencySymbol: account.currency_symbol ?? '$',
+            }
+            : undefined,
+    };
+};
+const updateReconciliationByAccountIDOnIncludeAccount = (draft, accountId, reconciliation, monthYearPeriodId) => {
+    draft.accountReconciliationRecordsBySelectedPeriod[monthYearPeriodId].reconciliationByAccountID[accountId] = {
+        accountId,
+        reconciliationId: reconciliation.reconciliation_id ?? undefined,
+        transactionFetchState: { fetchState: 'Not-Started', error: undefined },
+        refreshStatus: { fetchState: 'Not-Started', error: undefined },
+        statementDeleteStatus: { fetchState: 'Not-Started', error: undefined },
+        statementUploadStatus: { fetchState: 'Not-Started', error: undefined },
+        statementUpdateStatus: { fetchState: 'Not-Started', error: undefined },
+        statementParseInProgress: reconciliation.bank_status.code === 'parsing',
+        localData: {},
+    };
+};

package/lib/esm/view/expenseAutomationView/selectorTypes/reconciliationViewSelectorTypes.js

@@ -1,4 +1,3 @@
 import { stringToUnion } from '../../../commonStateTypes/stringToUnion';
 export const ALL_ACCOUNT_RECON_SECTION_IDS = ['assets', 'liabilities'];
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-const toAccountReconSectionID = (v) => stringToUnion(v, ALL_ACCOUNT_RECON_SECTION_IDS);
+export const toAccountReconSectionID = (v) => stringToUnion(v, ALL_ACCOUNT_RECON_SECTION_IDS);

package/lib/esm/view/expenseAutomationView/selectors/reconciliationViewSelector.js

@@ -9,6 +9,7 @@ import { getAccountsByType } from '../../../entity/account/accountSelector';
 import { getAccountReconByAccountIdAndSelectedPeriod } from '../../../entity/accountRecon/accountReconSelector';
 import { getCurrentTenant } from '../../../entity/tenant/tenantSelector';
 import { getVendorByVendorId } from '../../../entity/vendor/vendorSelector';
+import { date } from '../../../zeniDayJS';
 import { getAccountList, getNestedAccountListHierarchy, } from '../../accountList/accountListSelector';
 import { getClassList, getNestedClassListHierarchy, } from '../../classList/classListSelector';
 import { initialActionFetchState, initialReconciliationTabsState, initialState, } from '../reducers/reconciliationViewReducer';
@@ -90,6 +91,30 @@ export const getExpenseAutomationReconciliationView = createSelector((state) =>
                     totalVariancePercentage: undefined,
                 },
             },
+            excludedAccountReconciliationByAccountID: {},
+            excludedAccountReconciliationBySectionID: {
+                assets: {
+                    sectionId: 'assets',
+                    accountIDs: [],
+                    totalBankBalance: undefined,
+                    totalClearedBalance: undefined,
+                    totalReconciledBalance: undefined,
+                    totalVariance: undefined,
+                    totalVariancePercentage: undefined,
+                },
+                liabilities: {
+                    sectionId: 'liabilities',
+                    accountIDs: [],
+                    totalBankBalance: undefined,
+                    totalClearedBalance: undefined,
+                    totalReconciledBalance: undefined,
+                    totalVariance: undefined,
+                    totalVariancePercentage: undefined,
+                },
+            },
+            excludeAccountFetchState: reconciliationViewState.actionFetchState.excludeAccountFetch,
+            includeAccountFetchState: reconciliationViewState.actionFetchState.includeAccountFetch,
+            excludedAccountIDs: reconciliationViewState.excludedAccountIDs,
         };
     }
     const allAccountIDs = accountReconForMonthYearPeriod.accountIDs;
@@ -249,6 +274,88 @@ export const getExpenseAutomationReconciliationView = createSelector((state) =>
             totalVariancePercentage: liabilityTotals.variancePercentage,
         },
     };
+    const bankAccountIdSet = new Set(uniqueBankAccounts.map((a) => a.accountId));
+    const creditCardIdSet = new Set(uniqueCreditCards.map((a) => a.accountId));
+    const excludedAssetAccountIDs = [];
+    const excludedLiabilityAccountIDs = [];
+    reconciliationViewState.excludedAccountIDs.forEach((accountID) => {
+        const isAsset = bankAccountIdSet.has(accountID);
+        const isLiability = creditCardIdSet.has(accountID);
+        if (!isAsset && !isLiability) {
+            return;
+        }
+        if (isAsset) {
+            excludedAssetAccountIDs.push(accountID);
+        }
+        else {
+            excludedLiabilityAccountIDs.push(accountID);
+        }
+    });
+    const excludedAccountReconciliationBySectionID = {
+        assets: {
+            sectionId: 'assets',
+            accountIDs: excludedAssetAccountIDs,
+        },
+        liabilities: {
+            sectionId: 'liabilities',
+            accountIDs: excludedLiabilityAccountIDs,
+        },
+    };
+    const excludedAccountReconciliationByAccountID = {};
+    const accountsInState = Object.values(accountState.accountsByKey);
+    const accountsInStateMap = new Map(accountsInState.map((a) => [a.accountId, a]));
+    reconciliationViewState.excludedAccountIDs.forEach((excludedAccountID) => {
+        const account = accountsInStateMap.get(excludedAccountID);
+        const exclusionInfo = reconciliationViewState.excludedAccountExclusionInfo[excludedAccountID];
+        if (account != null) {
+            excludedAccountReconciliationByAccountID[excludedAccountID] = {
+                refreshStatus: { fetchState: 'Not-Started' },
+                statementUpdateStatus: { fetchState: 'Not-Started' },
+                statementUploadStatus: { fetchState: 'Not-Started' },
+                statementDeleteStatus: { fetchState: 'Not-Started' },
+                localData: {},
+                connectionInProgress: false,
+                statementParseInProgress: false,
+                accountConnectionStatus: 'not_connected',
+                transactionFetchState: { fetchState: 'Not-Started' },
+                accountReconEntity: {
+                    account: {
+                        accountId: account.accountId,
+                        accountName: account.accountName,
+                        accountType: account.accountType,
+                        accountSubType: account.accountSubType,
+                        accountDescription: account.accountDescription,
+                        qboId: account.qboId,
+                        coaId: account.coaId,
+                        labels: account.labels,
+                    },
+                    currency: {
+                        currencyCode: exclusionInfo?.bankBalance?.currencyCode ??
+                            exclusionInfo?.clearedBalance?.currencyCode ??
+                            'USD',
+                        currencySymbol: exclusionInfo?.bankBalance?.currencySymbol ??
+                            exclusionInfo?.clearedBalance?.currencySymbol ??
+                            '$',
+                    },
+                    startDate: date(new Date().toDateString()),
+                    endDate: date(new Date().toDateString()),
+                    statementStatus: { code: 'not_found', label: 'Not Found' },
+                    transactionsToReconcile: [],
+                    transactionsToReview: [],
+                    balance: exclusionInfo?.bankBalance,
+                    clearedBalance: exclusionInfo?.clearedBalance,
+                    variance: exclusionInfo?.variance,
+                    variancePercentage: exclusionInfo?.variance != null &&
+                        exclusionInfo?.bankBalance != null &&
+                        exclusionInfo?.bankBalance.amount !== 0
+                        ? Math.abs((exclusionInfo.variance.amount /
+                            exclusionInfo.bankBalance.amount) *
+                            100)
+                        : undefined,
+                },
+            };
+        }
+    });
     const accountListNestedAccountHierarchy = getNestedAccountListHierarchy(accountListState, 'accountList');
     const classListNestedAccountHierarchy = getNestedClassListHierarchy(classListState);
     const accountsList = getAccountList(accountState, accountListState, 'accountList');
@@ -309,6 +416,11 @@ export const getExpenseAutomationReconciliationView = createSelector((state) =>
         allClassList: allClasses,
         reviewTabSelectedVendorByTransactionId,
         reconListUIState: reconciliationViewState.reconListUIState,
+        excludedAccountReconciliationBySectionID,
+        excludedAccountReconciliationByAccountID,
+        excludeAccountFetchState: reconciliationViewState.actionFetchState.excludeAccountFetch,
+        includeAccountFetchState: reconciliationViewState.actionFetchState.includeAccountFetch,
+        excludedAccountIDs: reconciliationViewState.excludedAccountIDs,
     };
 });
 export const isAccountReconReport = (reportId) => {

package/lib/esm/view/expenseAutomationView/selectors/transactionCategorizationSelector.js

@@ -1,7 +1,7 @@
 import omit from 'lodash/omit';
 import { reduceAllFetchState, reduceAnyFetchState, } from '../../../commonStateTypes/reduceFetchState';
 import { toMonthYearPeriodId } from '../../../commonStateTypes/timePeriod';
-import { getCurrentTenant } from '../../../entity/tenant/tenantSelector';
+import { getIsAccountingClassesEnabled, getCurrentTenant, } from '../../../entity/tenant/tenantSelector';
 import { getTransactionWithCOT } from '../../../entity/transaction/transactionHelper';
 import { getSupportedTransactionsByIds } from '../../../entity/transaction/transactionSelector';
 import { getAccountList, getNestedAccountListHierarchy, getUncategorizedAccounts, } from '../../accountList/accountListSelector';
@@ -44,12 +44,16 @@ export function getExpenseAutomationTransactionView(state) {
     const monthEndFetchState = monthYearPeriodId != null
         ? (monthEndCloseChecksViewState.monthEndCloseChecksViewByTenantId[currentTenant.tenantId]?.[monthYearPeriodId] ?? { fetchState: 'Not-Started', error: undefined })
         : { fetchState: 'Not-Started', error: undefined };
+    const isAccountingClassesEnabled = getIsAccountingClassesEnabled(state);
+    const allFetchStateList = [
+        accountList,
+        expenseAutomationTransactionsViewState.transactionCategorizationView[selectedTransactionCategorizationTab],
+    ];
+    if (isAccountingClassesEnabled) {
+        allFetchStateList.push(classList);
+    }
     const fetchStatus = reduceAnyFetchState([
-        reduceAllFetchState([
-            accountList,
-            classList,
-            expenseAutomationTransactionsViewState.transactionCategorizationView[selectedTransactionCategorizationTab],
-        ]),
+        reduceAllFetchState(allFetchStateList),
         monthEndFetchState,
     ]);
     const totalCountByReview = expenseAutomationTransactionsViewState.transactionCategorizationView.review

package/lib/esm/view/expenseAutomationView/types/jeSchedulesViewState.js

@@ -16,3 +16,9 @@ const JE_SCHEDULE_SORT_KEYS = [
     'memo',
 ];
 export const toJEScheduleSortKey = (v) => stringToUnion(v, JE_SCHEDULE_SORT_KEYS);
+const JE_SCHEDULE_MAIN_TABS = [
+    'pending_review',
+    'ongoing',
+    'completed',
+];
+export const toJEScheduleMainTab = (v) => stringToUnion(v, JE_SCHEDULE_MAIN_TABS);

package/lib/esm/view/financeStatement/financeStatementSelector.js

@@ -9,10 +9,8 @@ import { extractThisPeriod } from '../../commonStateTypes/viewAndReport/thisPeri
 import { getBalanceSheet } from '../balanceSheet/balanceSheetSelector';
 import { getCashFlow } from '../cashFlow/cashFlowSelector';
 import { getProfitAndLossReport, } from '../profitAndLoss/profitAndLossSelector';
-import { newBalancesFilterProjectView } from '../../commonStateTypes/coaBalance/coaBalancesFilterProjectView';
 import { getProfitAndLossClassesHorizontalView } from '../profitAndLossClassesView/profitAndLossClassesByClassHorizontalSelector';
 import { getProfitAndLossClassesView } from '../profitAndLossClassesView/profitAndLossClassesViewSelector';
-import { getProfitAndLossProjectView } from '../profitAndLossProjectView/profitAndLossProjectViewSelector';
 function getDateRangeForFinanceReports(profitAndLossState, balanceSheetState, cashFlowState) {
     const datesSorted = [
         profitAndLossState.dataAvailable?.startDate,
@@ -37,7 +35,7 @@ function getFirstMonthOfFY(profitAndLossState, balanceSheetState, cashFlowState)
         cashFlowState.firstMonthOfFY ??
         1);
 }
-export const getFinanceStatement = createSelector((state) => state.accountState, (state) => state.accountGroupState, (state) => state.classState, (state) => state.sectionClassesViewStateV2, (state) => state.profitAndLossState, (state) => state.profitAndLossClassesViewState, (state) => state.projectState, (state) => state.sectionProjectViewState, (state) => state.profitAndLossProjectViewState, (state) => state.balanceSheetState, (state) => state.cashFlowState, (state) => state.financeStatementState, (state) => state.sectionAccountsViewState, (state) => state.forecastState, (accountState, accountGroupState, classState, sectionsState, profitAndLossState, profitAndLossClassesViewState, projectState, sectionProjectViewState, profitAndLossProjectViewState, balanceSheetState, cashFlowState, financeStatementState, sectionAccountsViewState, forecastState) => {
+export const getFinanceStatement = createSelector((state) => state.accountState, (state) => state.accountGroupState, (state) => state.classState, (state) => state.sectionClassesViewStateV2, (state) => state.profitAndLossState, (state) => state.profitAndLossClassesViewState, (state) => state.balanceSheetState, (state) => state.cashFlowState, (state) => state.financeStatementState, (state) => state.sectionAccountsViewState, (state) => state.forecastState, (accountState, accountGroupState, classState, sectionsState, profitAndLossState, profitAndLossClassesViewState, balanceSheetState, cashFlowState, financeStatementState, sectionAccountsViewState, forecastState) => {
     // to get min and max dates across three reports
     let allTimeframeTicks = [];
     let balancesInTimeframe = [];
@@ -71,8 +69,6 @@ export const getFinanceStatement = createSelector((state) => state.accountState,
     const profitAndLossReport = getProfitAndLossReport(filter, undefined, accountState, accountGroupState, sectionAccountsViewState, profitAndLossState, forecastState);
     const classFilter = newBalancesFilterClassesView(filter.firstMonthOfFY, filter.timeframe, filter.balancesRange.numberOfPeriods, filter.balancesRange.thisPeriod, filter.balancesRange.orderBy, filter.additionalBalances, profitAndLossClassesViewState.uiState.classesToFilterOut);
     const profitAndLossByClassReport = getProfitAndLossClassesView(classFilter, accountState, classState, sectionsState, profitAndLossClassesViewState);
-    const projectFilter = newBalancesFilterProjectView(filter.firstMonthOfFY, filter.timeframe, filter.balancesRange.numberOfPeriods, filter.balancesRange.thisPeriod, filter.balancesRange.orderBy, filter.additionalBalances, profitAndLossProjectViewState.uiState.projectsToFilterOut);
-    const profitAndLossByProjectReport = getProfitAndLossProjectView(projectFilter, accountState, projectState, sectionProjectViewState, profitAndLossProjectViewState);
     const profitAndLossByClassHorizontalReport = getProfitAndLossClassesHorizontalView(classFilter, accountState, classState, sectionsState, profitAndLossClassesViewState, profitAndLossClassesViewState.uiState.classViewLayout === 'horizontal'
         ? thisPeriod
         : undefined);
@@ -93,12 +89,6 @@ export const getFinanceStatement = createSelector((state) => state.accountState,
                 error: profitAndLossReport.error,
             };
             break;
-        case 'profit_and_loss_by_projects':
-            selectedReportAndTimeframeFetchState = {
-                fetchState: profitAndLossByProjectReport.fetchState,
-                error: profitAndLossByProjectReport.error,
-            };
-            break;
         case 'balance_sheet':
             selectedReportAndTimeframeFetchState = {
                 fetchState: balanceSheetReport.fetchState,
@@ -129,7 +119,6 @@ export const getFinanceStatement = createSelector((state) => state.accountState,
         dataAvailable,
         profitAndLossReport,
         profitAndLossByClassReport,
-        profitAndLossByProjectReport,
         profitAndLossByClassHorizontalReport,
         balanceSheetReport,
         cashFlowReport,

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

@@ -122,10 +122,12 @@ function buildClassColumns(classHierarchy, classesToFilterOut) {
         qboId: c.qboId,
     }))
         .sort((a, b) => {
-        if (a.classId === NOT_SPECIFIED_CLASS_ID) {
+        const aIsNotSpecified = a.classId === NOT_SPECIFIED_CLASS_ID;
+        const bIsNotSpecified = b.classId === NOT_SPECIFIED_CLASS_ID;
+        if (aIsNotSpecified && !bIsNotSpecified) {
             return 1;
         }
-        if (b.classId === NOT_SPECIFIED_CLASS_ID) {
+        if (!aIsNotSpecified && bIsNotSpecified) {
             return -1;
         }
         return a.className.localeCompare(b.className, [], {

package/lib/esm/view/reportsResync/reportsClassViewRefetchingEpic.js

@@ -3,7 +3,6 @@ import { filter, switchMap } from 'rxjs/operators';
 import { fetchNetBurnOrIncomeClassesView } from '../netBurnOrIncomeClassesView/netBurnOrIncomeClassesViewReducer';
 import { fetchOpExClassesView } from '../opExClassesView/opExClassesViewReducer';
 import { fetchProfitAndLossClassesView } from '../profitAndLossClassesView/profitAndLossClassesViewReducer';
-import { fetchProfitAndLossProjectView } from '../profitAndLossProjectView/profitAndLossProjectViewReducer';
 import { fetchRevenueClassesView } from '../revenueClassesView/revenueClassesViewReducer';
 import { initiateReportsClassViewRefetching } from './reportsResyncReducer';
 export const initiateReportsClassViewRefetchingEpic = (actions$, 
@@ -24,9 +23,6 @@ _) => actions$.pipe(filter(initiateReportsClassViewRefetching.match), switchMap(
         case 'net_burn_or_income_by_classes':
             actions.push(fetchNetBurnOrIncomeClassesView(true));
             break;
-        case 'profit_and_loss_by_projects':
-            actions.push(fetchProfitAndLossProjectView(true));
-            break;
         default:
             break;
     }