@zeniai/client-epic-state 4.20.7 → 4.20.9-beta0ND

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

@@ -0,0 +1,262 @@
+import { defaultCustomerCurrency } from '../../commonStateTypes/currencyHelper';
+import { getEmptyHorizontalSectionBalancesSlice } from './horizontalSectionEmptyBalancesSlice';
+import { HORIZONTAL_CLASS_TOTAL_BALANCE_ID, } from './profitAndLossClassesByClassHorizontalSelectorTypes';
+/**
+ * Populates `sectionHeaderBalancesSlice`, and per-account `accountReportData`, so the
+ * web layer only maps selector output to tree nodes.
+ */
+export function enrichProfitAndLossByClassHorizontalReport(report) {
+    if (report.fetchState !== 'Completed' || report.selectedPeriod == null) {
+        return;
+    }
+    for (const section of Object.values(report.sections)) {
+        if (section != null) {
+            enrichHorizontalSection(report, section);
+        }
+    }
+    for (const calc of Object.values(report.calculatedSections)) {
+        if (calc != null) {
+            enrichHorizontalCalculatedSection(report, calc);
+        }
+    }
+}
+function enrichHorizontalSection(report, section) {
+    const classAmounts = report.classColumns.map((col) => {
+        const total = section.classTotals.find((ct) => ct.classId === col.classId);
+        return total?.balance.amount ?? 0;
+    });
+    section.sectionHeaderBalancesSlice = buildHorizontalClassColumnBalancesSlice(report, classAmounts, section.sectionTotal.amount);
+    const parentIndices = computeHorizontalAccountParentIndices(section.accounts);
+    const childrenRowIndicesByParent = buildHorizontalAccountChildIndicesByParent(parentIndices);
+    const childrenRecord = {};
+    childrenRowIndicesByParent.forEach((childIndices, parentIndex) => {
+        childrenRecord[parentIndex] = childIndices;
+    });
+    section.treeLayout = {
+        rootAccountRowIndices: section.accounts
+            .map((_, i) => (parentIndices[i] === -1 ? i : -1))
+            .filter((i) => i >= 0),
+        childrenRowIndicesByParent: childrenRecord,
+    };
+    const siblingsPerRow = buildSiblingIndicesPerRow(section.accounts, parentIndices);
+    const hasChildFlags = computeHorizontalHasChildFlags(parentIndices);
+    for (let accountIndex = 0; accountIndex < section.accounts.length; accountIndex++) {
+        const row = section.accounts[accountIndex];
+        // Same column order as `report.classColumns` (see `pivotSectionToHorizontal`).
+        const classRowAmounts = row.classBalances.map((classBalance) => classBalance.balance.amount);
+        row.accountReportData = {
+            accountId: row.accountId,
+            accountName: row.accountName,
+            accountType: row.accountType,
+            depth: row.depth,
+            balancesInTimeframe: buildHorizontalClassColumnBalancesSlice(report, classRowAmounts, row.rowTotal.amount),
+            horizontalTreeView: buildHorizontalTreeViewFromPrecomputed(section.accounts, accountIndex, parentIndices, siblingsPerRow, hasChildFlags),
+        };
+    }
+}
+function enrichHorizontalCalculatedSection(report, calcSection) {
+    const classAmounts = report.classColumns.map((col) => {
+        const total = calcSection.classTotals.find((ct) => ct.classId === col.classId);
+        return total?.balance.amount ?? 0;
+    });
+    calcSection.sectionHeaderBalancesSlice =
+        buildHorizontalClassColumnBalancesSlice(report, classAmounts, calcSection.sectionTotal.amount);
+}
+function buildHorizontalClassColumnBalancesSlice(report, classAmounts, totalAmount) {
+    const fallback = defaultCustomerCurrency;
+    const firstHeader = report.headerBalances[0];
+    const currencyCode = firstHeader?.balance.currencyCode ?? fallback.currencyCode;
+    const currencySymbol = firstHeader?.balance.currencySymbol ?? fallback.currencySymbol;
+    const timeframe = firstHeader?.balanceTimeFrame ?? 'month';
+    if (report.selectedPeriod == null) {
+        return getEmptyHorizontalSectionBalancesSlice(report.firstMonthOfFY, timeframe);
+    }
+    const { startDate, endDate } = report.selectedPeriod;
+    const balances = report.classColumns.map((col, columnIndex) => {
+        const amount = classAmounts[columnIndex] ?? 0;
+        return {
+            balance: {
+                amount,
+                currencyCode,
+                currencySymbol,
+            },
+            balanceTimeFrame: timeframe,
+            startDate,
+            endDate,
+            type: amount === 0 ? 'default_with_null_balance' : 'default',
+            id: col.classId,
+            label: col.className,
+        };
+    });
+    balances.push({
+        balance: {
+            amount: totalAmount,
+            currencyCode,
+            currencySymbol,
+        },
+        balanceTimeFrame: timeframe,
+        startDate,
+        endDate,
+        type: totalAmount === 0 ? 'default_with_null_balance' : 'default',
+        id: HORIZONTAL_CLASS_TOTAL_BALANCE_ID,
+        label: 'Total',
+    });
+    return {
+        balances,
+        additionalBalances: [],
+        filter: {
+            firstMonthOfFY: report.firstMonthOfFY,
+            timeframe,
+            balancesRange: {
+                numberOfPeriods: balances.length,
+                orderBy: 'ascending_date',
+            },
+            additionalBalances: [],
+        },
+    };
+}
+/**
+ * Parent index per DFS row — O(n). Matches the scan in the former
+ * `findHorizontalAccountParentIndex` (depth &lt;= 2 rows have no parent).
+ */
+function computeHorizontalAccountParentIndices(rows) {
+    const accountRowCount = rows.length;
+    const parentIndex = new Array(accountRowCount).fill(-1);
+    const stack = [];
+    for (let rowIndex = 0; rowIndex < accountRowCount; rowIndex++) {
+        const accountRow = rows[rowIndex];
+        if (accountRow == null) {
+            continue;
+        }
+        const depth = accountRow.depth;
+        while (stack.length > 0) {
+            const topRow = rows[stack[stack.length - 1]];
+            if (topRow == null) {
+                stack.pop();
+                continue;
+            }
+            if (topRow.depth < depth) {
+                break;
+            }
+            stack.pop();
+        }
+        if (depth > 2 && stack.length > 0) {
+            const peek = stack[stack.length - 1];
+            const parentRow = rows[peek];
+            if (parentRow != null && parentRow.depth === depth - 1) {
+                parentIndex[rowIndex] = peek;
+            }
+        }
+        stack.push(rowIndex);
+    }
+    return parentIndex;
+}
+/** Sibling row indices (same parent + depth), in traversal order — O(n). */
+function buildSiblingIndicesPerRow(rows, parentIndices) {
+    const accountRowCount = rows.length;
+    const keyToIndices = new Map();
+    for (let rowIndex = 0; rowIndex < accountRowCount; rowIndex++) {
+        const parentRowIndex = parentIndices[rowIndex];
+        const accountRow = rows[rowIndex];
+        if (parentRowIndex == null || accountRow == null) {
+            continue;
+        }
+        const key = `${parentRowIndex}:${accountRow.depth}`;
+        let siblingGroup = keyToIndices.get(key);
+        if (siblingGroup == null) {
+            siblingGroup = [];
+            keyToIndices.set(key, siblingGroup);
+        }
+        siblingGroup.push(rowIndex);
+    }
+    const siblingsPerRow = new Array(accountRowCount);
+    for (let rowIndex = 0; rowIndex < accountRowCount; rowIndex++) {
+        const parentRowIndex = parentIndices[rowIndex];
+        const accountRow = rows[rowIndex];
+        if (parentRowIndex == null || accountRow == null) {
+            siblingsPerRow[rowIndex] = [rowIndex];
+            continue;
+        }
+        const key = `${parentRowIndex}:${accountRow.depth}`;
+        const group = keyToIndices.get(key);
+        siblingsPerRow[rowIndex] = group != null ? group : [rowIndex];
+    }
+    return siblingsPerRow;
+}
+function computeHorizontalHasChildFlags(parentIndices) {
+    const rowCount = parentIndices.length;
+    const flags = new Array(rowCount).fill(false);
+    for (let rowIndex = 0; rowIndex < rowCount; rowIndex++) {
+        const parentRowIndex = parentIndices[rowIndex];
+        if (parentRowIndex != null &&
+            parentRowIndex >= 0 &&
+            parentRowIndex < rowCount) {
+            flags[parentRowIndex] = true;
+        }
+    }
+    return flags;
+}
+function buildHorizontalSubAccountAncestorMetadataFromPrecomputed(dfsOrderedAccountRows, currentRowIndex, parentIndices, siblingsPerRow, hasChildFlags) {
+    const chain = [];
+    let walkRowIndex = currentRowIndex;
+    while (walkRowIndex >= 0) {
+        chain.unshift(walkRowIndex);
+        const parentRowIndex = parentIndices[walkRowIndex];
+        if (parentRowIndex == null) {
+            break;
+        }
+        walkRowIndex = parentRowIndex;
+    }
+    return chain.map((rowIndex) => {
+        const accountRow = dfsOrderedAccountRows[rowIndex];
+        const siblingIndices = siblingsPerRow[rowIndex];
+        const hasChild = hasChildFlags[rowIndex];
+        if (accountRow == null || siblingIndices == null) {
+            return {
+                depth: 0,
+                hasSibling: false,
+                hasChildren: hasChild === true,
+                isLastNode: true,
+                name: '',
+            };
+        }
+        return {
+            depth: accountRow.depth - 2,
+            hasSibling: siblingIndices.length > 1,
+            hasChildren: hasChild === true,
+            isLastNode: rowIndex === siblingIndices[siblingIndices.length - 1],
+            name: accountRow.accountName,
+        };
+    });
+}
+function buildHorizontalTreeViewFromPrecomputed(dfsOrderedAccountRows, currentRowIndex, parentIndices, siblingsPerRow, hasChildFlags) {
+    const siblingIndices = siblingsPerRow[currentRowIndex];
+    const accountRow = dfsOrderedAccountRows[currentRowIndex];
+    const hasChildrenFlag = hasChildFlags[currentRowIndex];
+    const treeDepth = accountRow != null ? Math.max(0, accountRow.depth - 2) : 0;
+    const hasChildren = hasChildrenFlag === true;
+    const siblings = siblingIndices ?? [currentRowIndex];
+    return {
+        subAccountAncestorMetadata: buildHorizontalSubAccountAncestorMetadataFromPrecomputed(dfsOrderedAccountRows, currentRowIndex, parentIndices, siblingsPerRow, hasChildFlags),
+        treeDepth,
+        hasChildren,
+        hasSiblings: siblings.length > 1,
+        isLeaf: !hasChildren,
+        isLastNode: currentRowIndex === siblings[siblings.length - 1],
+    };
+}
+function buildHorizontalAccountChildIndicesByParent(parentIndices) {
+    const childIndicesByParentRowIndex = new Map();
+    for (let rowIndex = 0; rowIndex < parentIndices.length; rowIndex++) {
+        const parentRowIndex = parentIndices[rowIndex];
+        if (parentRowIndex != null && parentRowIndex >= 0) {
+            let childRowIndices = childIndicesByParentRowIndex.get(parentRowIndex);
+            if (childRowIndices == null) {
+                childRowIndices = [];
+                childIndicesByParentRowIndex.set(parentRowIndex, childRowIndices);
+            }
+            childRowIndices.push(rowIndex);
+        }
+    }
+    return childIndicesByParentRowIndex;
+}

package/lib/esm/view/reportUIOptions/updateReportUIOptionCOABalancesRangeEpic.js

@@ -2,15 +2,19 @@ import { of } from 'rxjs';
 import { filter, switchMap } from 'rxjs/operators';
 import { updateCashInCashOutCOABalancesRange } from '../cashInCashOut/cashInCashOutReducer';
 import { updateCashPositionCOABalancesRange } from '../cashPosition/cashPositionReducer';
-import { initialFinanceStatementState, updateCOABalancesRange, } from '../financeStatement/financeStatementReducer';
+import { updateCOABalancesRange } from '../financeStatement/financeStatementReducer';
 import { updateNetBurnOrIncomeCOABalancesRange } from '../netBurnOrIncome/netBurnOrIncomeReducer';
 import { updateOpExCOABalancesRange } from '../opEx/opExReducer';
 import { updateRevenueCOABalancesRange } from '../revenue/revenueReducer';
 import { updateReportUIOptionCOABalancesRange } from './reportUIOptionsReducer';
 export const updateReportUIOptionCOABalancesRangeEpic = (actions$, state$) => actions$.pipe(filter(updateReportUIOptionCOABalancesRange.match), switchMap((action) => {
-    const thisPeriod = action.payload.selectedCOABalancesRange.thisPeriod;
-    const orderBy = action.payload.selectedCOABalancesRange.orderBy;
-    const highlightedNoOfPeriods = state$.value.reportUIOptionsState.isCompareModeOn === true ? 4 : 1;
+    const selectedRange = action.payload.selectedCOABalancesRange;
+    const thisPeriod = selectedRange.thisPeriod;
+    const orderBy = selectedRange.orderBy;
+    const numberOfPeriodsFromSelection = selectedRange.numberOfPeriods;
+    const highlightedNoOfPeriods = state$.value.reportUIOptionsState.isCompareModeOn === true
+        ? numberOfPeriodsFromSelection
+        : 1;
     const highlightedCOABalancesRange = action.payload.highlightedCOABalancesRange == null && thisPeriod != null
         ? {
             numberOfPeriods: highlightedNoOfPeriods,
@@ -62,9 +66,7 @@ export const updateReportUIOptionCOABalancesRangeEpic = (actions$, state$) => ac
         thisPeriod: action.payload.highlightedCOABalancesRange != null
             ? action.payload.highlightedCOABalancesRange.thisPeriod
             : thisPeriod,
-        numberOfPeriods: state$.value.reportUIOptionsState.isCompareModeOn === true
-            ? 4
-            : initialFinanceStatementState.maxNumOfPeriodsToHighlight,
+        numberOfPeriods: numberOfPeriodsFromSelection,
         orderBy,
     }));
 }));

package/lib/esm/view/taskManager/taskDetailView/taskDetailSelector.js

@@ -109,7 +109,7 @@ export const allTaskPriority = [
     },
     {
         code: 'medium',
-        name: 'Normal',
+        name: 'Medium',
     },
     {
         code: 'low',

package/lib/esm/view/taskManager/taskListView/epics/bulkUpdateTaskListEpic.js

@@ -70,6 +70,7 @@ const toTaskPayload = (state, task) => {
         name: task.name,
         assignees: task.assignees,
         description: task.description,
+        group_assignees: task.groupAssignees,
         due_date: task.dueDate != null ? task.dueDate.format(DEFAULT_DATE_FORMAT) : null,
         priority: task.priority.code,
         status: task.status.code,

package/lib/esm/view/taskManager/taskListView/taskListSelector.js

@@ -11,6 +11,7 @@ import { getTaskGroupTemplateByIds } from '../../../entity/taskGroupTemplate/tas
 import { getUserName, getUsersByUserIds, } from '../../../entity/user/userSelector';
 import { getUserAndUserRole, } from '../../companyView/types/userAndRole';
 import { applyAdvancedFiltersOnList } from '../../spendManagement/spendManagementFilterHelpers';
+import { getUserGroupList } from '../../userGroupListView/userGroupListViewSelector';
 import { getUserList, } from '../../userListView/userListViewSelector';
 import { allTaskPriority, allTaskStatus, } from '../taskDetailView/taskDetailSelector';
 import { DUE_DATE_GROUP_KEYS, } from './taskList';
@@ -308,7 +309,7 @@ const getTaskGroupsWithTaskList = ({ taskListState, taskState, userState, userRo
         tagState,
     });
 };
-export const getAllTasks = createSelector((state) => state.taskListState, (state) => state.taskState, (state) => state.userState, (state) => state.userRoleState, (state) => state.userListViewState, (state) => state.addressState, (state) => state.taskGroupState, (state) => state.taskGroupViewState, (state) => state.tagViewState, (state) => state.tagState, (state) => state.taskGroupTemplateState, (state) => state.taskGroupTemplateViewState, (_state, isTaskTemplatesEnabled) => isTaskTemplatesEnabled, (taskListState, taskState, userState, userRoleState, userListViewState, addressState, taskGroupState, taskGroupViewState, tagViewState, tagState, taskGroupTemplateState, taskGroupTemplateViewState, isTaskTemplatesEnabled) => {
+export const getAllTasks = createSelector((state) => state.taskListState, (state) => state.taskState, (state) => state.userState, (state) => state.userRoleState, (state) => state.userListViewState, (state) => state.addressState, (state) => state.taskGroupState, (state) => state.taskGroupViewState, (state) => state.tagViewState, (state) => state.tagState, (state) => state.taskGroupTemplateState, (state) => state.taskGroupTemplateViewState, (state) => state.userGroupsState, (state) => state.userGroupListViewState, (_state, isTaskTemplatesEnabled) => isTaskTemplatesEnabled, (taskListState, taskState, userState, userRoleState, userListViewState, addressState, taskGroupState, taskGroupViewState, tagViewState, tagState, taskGroupTemplateState, taskGroupTemplateViewState, userGroupsState, userGroupListViewState, isTaskTemplatesEnabled) => {
     const { localData } = taskListState;
     const taskGroupsWithTasksList = getTaskGroupsWithTaskList({
         taskListState,
@@ -336,6 +337,7 @@ export const getAllTasks = createSelector((state) => state.taskListState, (state
         taskGroupTemplates,
         fetchState: fetchState,
         userList: getUserList(userState, userRoleState, userListViewState, 'taskManagerCandidate'),
+        userGroupList: getUserGroupList(userGroupsState, userGroupListViewState, 'taskManagerCandidate'),
         error: error,
         version: 0,
         taskGroupsWithTasksList,

package/lib/esm/view/userGroupListView/userGroupListViewReducer.js

@@ -0,0 +1,65 @@
+import { createSlice } from '@reduxjs/toolkit';
+const initialUserGroupList = {
+    ids: [],
+    fetchState: 'Not-Started',
+    error: undefined,
+    hasValidState() {
+        return this.fetchState == 'Completed';
+    },
+};
+export const initialState = {
+    userGroupListByType: {
+        taskManagerCandidate: initialUserGroupList,
+    },
+};
+const userGroupListView = createSlice({
+    name: 'userGroupListView',
+    initialState,
+    reducers: {
+        fetchUserGroupListByType: {
+            reducer(draft, action) {
+                const { userGroupType } = action.payload;
+                draft.userGroupListByType[userGroupType].fetchState = 'In-Progress';
+                draft.userGroupListByType[userGroupType].error = undefined;
+            },
+            prepare(userGroupType, cacheOverride = false) {
+                return {
+                    payload: {
+                        userGroupType,
+                        cacheOverride,
+                    },
+                };
+            },
+        },
+        updateUserGroupIds(draft, action) {
+            const { userGroupType, userGroupsPayload } = action.payload;
+            draft.userGroupListByType[userGroupType].fetchState = 'Completed';
+            draft.userGroupListByType[userGroupType].error = undefined;
+            draft.userGroupListByType[userGroupType].ids = userGroupsPayload.map((userGroup) => userGroup.id);
+        },
+        addUserGroupId(draft, action) {
+            const { userGroupType, id } = action.payload;
+            const index = draft.userGroupListByType[userGroupType].ids.indexOf(id);
+            if (index < 0) {
+                draft.userGroupListByType[userGroupType].ids.push(id);
+            }
+        },
+        removeUserGroupId(draft, action) {
+            const { userGroupType, id } = action.payload;
+            const index = draft.userGroupListByType[userGroupType].ids.indexOf(id);
+            if (index > -1) {
+                draft.userGroupListByType[userGroupType].ids.splice(index, 1);
+            }
+        },
+        updateUserGroupListFetchFailure(draft, action) {
+            const { userGroupType, status } = action.payload;
+            draft.userGroupListByType[userGroupType].fetchState = 'Error';
+            draft.userGroupListByType[userGroupType].error = status;
+        },
+        clearUserGroupListView(draft) {
+            Object.assign(draft, initialState);
+        },
+    },
+});
+export const { fetchUserGroupListByType, updateUserGroupIds, addUserGroupId, removeUserGroupId, updateUserGroupListFetchFailure, clearUserGroupListView, } = userGroupListView.actions;
+export default userGroupListView.reducer;

package/lib/esm/view/userGroupListView/userGroupListViewSelector.js

@@ -0,0 +1,16 @@
+import { getUserGroupByUserGroupId } from '../../entity/userGroups/userGroupsSelector';
+export const getUserGroupList = (userGroupsState, userGroupListViewState, userGroupType) => {
+    const listState = userGroupListViewState.userGroupListByType[userGroupType];
+    return {
+        userGroups: getUserGroupListByIds(userGroupsState, userGroupListViewState, userGroupType),
+        fetchState: listState?.fetchState,
+        error: listState?.error,
+        version: 0,
+    };
+};
+function getUserGroupListByIds(userGroupsState, userGroupListViewState, type) {
+    const userGroupIds = userGroupListViewState.userGroupListByType[type].ids;
+    return userGroupIds
+        .map((id) => getUserGroupByUserGroupId(userGroupsState, id))
+        .filter((value) => value != null);
+}

package/lib/esm/view/userGroupListView/userGroupListViewState.js

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

package/lib/esm/view/userListView/fetchUserListByTypeEpic.js

@@ -3,9 +3,11 @@ import { catchError, filter, mergeMap } from 'rxjs/operators';
 import { updateAddresses } from '../../entity/address/addressReducer';
 import { getCurrentTenant, isZeniDomainTenant, } from '../../entity/tenant/tenantSelector';
 import { updateAllUsers } from '../../entity/user/userReducer';
+import { updateAllUserGroups } from '../../entity/userGroups/userGroupsReducer';
 import { updateUserRoles } from '../../entity/userRole/userRoleReducer';
 import { createZeniAPIStatus, isSuccessResponse } from '../../responsePayload';
 import { updateChargeCardCount, updateDebitCardCount, } from '../spendManagement/chargeCards/issueChargeCard/issueChargeCardReducer';
+import { updateUserGroupIds } from '../userGroupListView/userGroupListViewReducer';
 import { fetchUserListByType, updateUserIds, updateUserListFetchFailure, } from './userListViewReducer';
 export const fetchUserListByTypeEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(fetchUserListByType.match), mergeMap((action) => {
     const { userType, cacheOverride } = action.payload;
@@ -29,6 +31,15 @@ export const fetchUserListByTypeEpic = (actions$, state$, zeniAPI) => actions$.p
                         usersPayload: response.data?.users ?? [],
                     }),
                 ];
+                if (response.data?.user_groups != null) {
+                    userListAction.push(updateAllUserGroups({ userGroups: response.data.user_groups }));
+                    if (userType === 'taskManagerCandidate') {
+                        userListAction.push(updateUserGroupIds({
+                            userGroupType: userType,
+                            userGroupsPayload: response.data.user_groups,
+                        }));
+                    }
+                }
                 if (userType === 'cardHolderCandidate') {
                     userListAction.push(updateChargeCardCount(response.data?.cards_count_by_user_id ?? []));
                     userListAction.push(updateDebitCardCount(response.data?.debit_cards_count_by_deposit_account_id ?? {}));

package/lib/esm/zeniAPI.js

@@ -79,8 +79,6 @@ export class ZeniAPIClient {
         return from(promise);
     }
     postFormData(restEndPoint, formData, signal) {
-        // Use apiHeaders for auth headers, then remove Content-Type
-        // so the browser sets multipart/form-data with the correct boundary
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
         const { 'Content-Type': _contentType, ...headers } = this.apiHeaders();
         const promise = fetch(restEndPoint, {