@zeniai/client-epic-state 4.10.2 → 4.10.3

package/lib/view/notificationView/epics/updateNotificationViewNotificationStatusEpic.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateNotificationViewNotificationStatusEpic = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const responsePayload_1 = require("../../../responsePayload");
+const notificationViewReducer_1 = require("../notificationViewReducer");
+const snackbarReducer_1 = require("../../../entity/snackbar/snackbarReducer");
+const notificationReducer_1 = require("../../../entity/notification/notificationReducer");
+const updateNotificationViewNotificationStatusEpic = (actions$, state$, zeniAPI) => actions$.pipe((0, operators_1.filter)(notificationViewReducer_1.updateNotificationViewNotificationStatus.match), (0, operators_1.switchMap)((action) => {
+    const { notificationGroup, status, notificationIds, showSnackBarOnSuccess, } = action.payload;
+    const { notificationViewState, notificationState } = state$.value;
+    const { stateByTab } = notificationViewState;
+    const notificationTab = (0, notificationViewReducer_1.toNotificationTab)(notificationGroup);
+    const notificationTabState = stateByTab[notificationTab];
+    const { selectedNotificationIds } = notificationTabState;
+    const payload = {
+        notifications: [],
+    };
+    let reduceUnreadCountBy = 0;
+    if (notificationIds.length > 0) {
+        notificationIds.forEach((notificationId) => {
+            payload.notifications.push({
+                user_notification_id: notificationId,
+                status,
+            });
+        });
+        reduceUnreadCountBy = notificationIds.length;
+    }
+    else {
+        selectedNotificationIds.forEach((notificationId) => {
+            payload.notifications.push({
+                user_notification_id: notificationId,
+                status,
+            });
+        });
+        if (notificationTab !== 'comments') {
+            selectedNotificationIds.forEach((selectedNotificationId) => {
+                if (notificationState.notificationById[selectedNotificationId] != null) {
+                    if (notificationState.notificationById[selectedNotificationId]
+                        .status !== status) {
+                        reduceUnreadCountBy = reduceUnreadCountBy + 1;
+                    }
+                }
+            });
+        }
+    }
+    return zeniAPI
+        .putAndGetJSON(`${zeniAPI.apiEndPoints.notificationMicroServiceBaseUrl}/1.0/user-notification`, { notifications: payload.notifications })
+        .pipe((0, operators_1.switchMap)((response) => {
+        if ((0, responsePayload_1.isSuccessStatus)(response)) {
+            const updateNotificationIds = payload.notifications.map((notification) => notification.user_notification_id);
+            const actions = [];
+            if (showSnackBarOnSuccess === true) {
+                actions.push((0, snackbarReducer_1.openSnackbar)({
+                    messageSection: 'notification_mark_as_read',
+                    messageText: 'success',
+                    type: 'success',
+                }));
+            }
+            actions.push((0, notificationReducer_1.updateNotificationsStatuses)(updateNotificationIds, status), (0, notificationViewReducer_1.updateNotificationViewNotificationStatusSuccess)(notificationGroup, reduceUnreadCountBy));
+            return (0, rxjs_1.from)(actions);
+        }
+        else {
+            return (0, rxjs_1.of)((0, notificationViewReducer_1.updateNotificationViewNotificationStatusFailure)({
+                status: response.status,
+                notificationGroup,
+            }), (0, snackbarReducer_1.openSnackbar)({
+                messageSection: 'notification_mark_as_read',
+                messageText: 'failed',
+                type: 'error',
+                variables: [
+                    {
+                        variableName: '_api-error_',
+                        variableValue: response.status.message,
+                    },
+                ],
+            }));
+        }
+    }), (0, operators_1.catchError)((error) => (0, rxjs_1.of)((0, notificationViewReducer_1.updateNotificationViewNotificationStatusFailure)({
+        status: (0, responsePayload_1.createZeniAPIStatus)('Unexpected Error', 'Update Notification Status API call errored out' +
+            JSON.stringify(error)),
+        notificationGroup,
+    }))));
+}));
+exports.updateNotificationViewNotificationStatusEpic = updateNotificationViewNotificationStatusEpic;

package/lib/view/notificationView/notificationView.helpers.d.ts

@@ -0,0 +1,2 @@
+import { NotificationSubTabType, NotificationTabType } from './notificationViewState';
+export declare const getSubTabsForATab: (notificationTab: NotificationTabType) => NotificationSubTabType[];

package/lib/view/notificationView/notificationView.helpers.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSubTabsForATab = void 0;
+const getSubTabsForATab = (notificationTab) => {
+    const subTabs = ['all', 'read', 'unread'];
+    if (notificationTab === 'comments') {
+        return [...subTabs, 'mentions'];
+    }
+    return subTabs;
+};
+exports.getSubTabsForATab = getSubTabsForATab;

package/lib/view/notificationView/notificationViewPayload.d.ts

@@ -0,0 +1,48 @@
+import { ZeniAPIResponse } from '../../responsePayload';
+import { NotificationPayload } from '../../entity/notification/notificationPayload';
+export interface NotificationViewQueryPayload {
+    notification_group: string;
+    mode: string;
+    is_paginated: boolean;
+    status: string[];
+    page_token: string | null;
+    limit: number;
+}
+export interface NotificationViewPayload {
+    notifications: NotificationPayload[];
+    query: NotificationViewQueryPayload;
+    total_count: number;
+    next_page_token: string | null;
+}
+export declare type NotificationViewResponse = ZeniAPIResponse<NotificationViewPayload>;
+export interface UpdateNotificationStatusQueryPayload {
+    notification_group: string;
+    is_paginated: boolean;
+}
+export interface UpdateAllNotificationStatusQueryPayload {
+    mark_all_as_read: boolean;
+}
+export interface FetchNotificationCountQueryPayload {
+    fetch_unread_notification_count: boolean;
+    notification_group: string;
+    mode: string;
+}
+export interface FetchNotificationCountPayload {
+    notification_group: string;
+    mode: string;
+    query: FetchNotificationCountQueryPayload;
+    count: {
+        unread: number;
+    };
+}
+export declare type UpdateNotificationStatusResponse = ZeniAPIResponse;
+export declare type UpdateAllNotificationsStatusResponse = ZeniAPIResponse;
+export declare type FetchNotificationCountResponse = ZeniAPIResponse<FetchNotificationCountPayload>;
+export interface PushNotificationPayload {
+    notification_group: string;
+    mode: string;
+    data: {
+        unread: number;
+    };
+    timestamp: string;
+}

package/lib/view/notificationView/notificationViewPayload.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/view/notificationView/notificationViewReducer.d.ts

@@ -0,0 +1,64 @@
+import { ZeniAPIStatus } from '../../responsePayload';
+import { NotificationPayload } from '../../entity/notification/notificationPayload';
+import { NotificationTabState, NotificationTabType, NotificationViewState, NotificationViewUIState } from './notificationViewState';
+import { NotificationGroup } from '../../entity/notification/types/notificationTypes';
+import { PageToken } from '../../commonStateTypes/viewAndReport/viewAndReport';
+export declare const initialState: NotificationViewState;
+export declare const fetchNotificationView: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[notificationGroup: "task_manager", mode?: "dashboard" | "email" | undefined, status?: ("unread" | "read")[] | undefined], {
+    notificationGroup: "task_manager";
+    mode: "dashboard" | "email";
+    status: ("unread" | "read")[];
+}, string, never, never>, fetchNotificationViewSuccess: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[notifications: NotificationPayload[], totalCount: number, notificationGroup: "task_manager", pageToken: PageToken], {
+    notifications: NotificationPayload[];
+    totalCount: number;
+    notificationGroup: "task_manager";
+    pageToken: PageToken;
+}, string, never, never>, fetchNotificationViewFailure: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    status: ZeniAPIStatus;
+    notificationGroup: NotificationGroup;
+}, string>, fetchNotificationUnreadCount: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[notificationGroup: "task_manager", mode?: "dashboard" | "email" | undefined], {
+    notificationGroup: "task_manager";
+    mode: "dashboard" | "email";
+}, string, never, never>, fetchNotificationUnreadCountSuccess: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[unreadCount: number, notificationGroup: "task_manager"], {
+    unreadCount: number;
+    notificationGroup: "task_manager";
+}, string, never, never>, fetchNotificationUnreadCountFailure: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    status: ZeniAPIStatus;
+    notificationGroup: NotificationGroup;
+}, string>, updateNotificationViewNotificationStatus: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[notificationGroup: "task_manager", status: "unread" | "read", notificationIds?: string[] | undefined, showSnackBarOnSuccess?: any], {
+    notificationGroup: "task_manager";
+    status: "unread" | "read";
+    notificationIds: string[];
+    showSnackBarOnSuccess: any;
+}, string, never, never>, updateNotificationViewNotificationStatusSuccess: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[notificationGroup: "task_manager", reduceUnreadCountBy: number], {
+    notificationGroup: "task_manager";
+    reduceUnreadCountBy: number;
+}, string, never, never>, updateNotificationViewNotificationStatusFailure: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    status: ZeniAPIStatus;
+    notificationGroup: NotificationGroup;
+}, string>, updateNotificationViewAllNotificationsStatus: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[notificationGroup: "task_manager", status: "unread" | "read"], {
+    notificationGroup: "task_manager";
+    status: "unread" | "read";
+}, string, never, never>, updateNotificationViewAllNotificationsStatusSuccess: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[notificationGroup: "task_manager"], {
+    notificationGroup: "task_manager";
+}, string, never, never>, updateNotificationViewAllNotificationsStatusFailure: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    status: ZeniAPIStatus;
+    notificationGroup: NotificationGroup;
+}, string>, updateNotificationViewTabState: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[notificationTabState: Partial<NotificationTabState>, tab: "tasks" | "comments"], {
+    notificationTabState: Partial<NotificationTabState>;
+    tab: "tasks" | "comments";
+}, string, never, never>, updateNotificationViewCurrentTabAndSubTab: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[newTab: "tasks" | "comments", newSubTab?: "all" | "unread" | "read" | "mentions" | undefined], {
+    newTab: "tasks" | "comments";
+    newSubTab: "all" | "unread" | "read" | "mentions" | undefined;
+}, string, never, never>, updateNotificationViewSubTab: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[newSubTab: "all" | "unread" | "read" | "mentions"], {
+    newSubTab: "all" | "unread" | "read" | "mentions";
+}, string, never, never>, updateNotificationViewUIState: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[uiState: Partial<NotificationViewUIState>, tab: "tasks" | "comments"], {
+    uiState: Partial<NotificationViewUIState>;
+    tab: "tasks" | "comments";
+}, string, never, never>, clearNotificationView: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
+declare const _default: import("@reduxjs/toolkit").Reducer<NotificationViewState, import("@reduxjs/toolkit").AnyAction>;
+export default _default;
+/**
+ * Helpers
+ */
+export declare const toNotificationTab: (notificationGroup: NotificationGroup) => NotificationTabType;

package/lib/view/notificationView/notificationViewReducer.js

@@ -0,0 +1,372 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toNotificationTab = exports.clearNotificationView = exports.updateNotificationViewUIState = exports.updateNotificationViewSubTab = exports.updateNotificationViewCurrentTabAndSubTab = exports.updateNotificationViewTabState = exports.updateNotificationViewAllNotificationsStatusFailure = exports.updateNotificationViewAllNotificationsStatusSuccess = exports.updateNotificationViewAllNotificationsStatus = exports.updateNotificationViewNotificationStatusFailure = exports.updateNotificationViewNotificationStatusSuccess = exports.updateNotificationViewNotificationStatus = exports.fetchNotificationUnreadCountFailure = exports.fetchNotificationUnreadCountSuccess = exports.fetchNotificationUnreadCount = exports.fetchNotificationViewFailure = exports.fetchNotificationViewSuccess = exports.fetchNotificationView = exports.initialState = void 0;
+const toolkit_1 = require("@reduxjs/toolkit");
+const notificationView_helpers_1 = require("./notificationView.helpers");
+exports.initialState = {
+    currentTab: 'tasks',
+    currentSubTab: 'all',
+    stateByTab: {
+        tasks: {
+            fetchCountState: {
+                fetchState: 'Not-Started',
+                error: undefined,
+            },
+            allNotificationsIds: [],
+            selectedNotificationIds: [],
+            uiState: {
+                pageToken: null,
+                scrollYOffset: { all: 0, mentions: 0, read: 0, unread: 0 },
+                limit: 10,
+                totalCount: 0,
+                unreadCount: 0,
+                hasMore: true,
+            },
+            markAsReadState: {
+                fetchState: 'Not-Started',
+                error: undefined,
+            },
+            markAsAllReadState: {
+                fetchState: 'Not-Started',
+                error: undefined,
+            },
+            hasValidState() {
+                return this.fetchState == 'Completed';
+            },
+            fetchState: 'Not-Started',
+            error: undefined,
+        },
+        comments: {
+            fetchCountState: {
+                fetchState: 'Not-Started',
+                error: undefined,
+            },
+            allNotificationsIds: [],
+            selectedNotificationIds: [],
+            uiState: {
+                pageToken: null,
+                scrollYOffset: { all: 0, mentions: 0, read: 0, unread: 0 },
+                limit: 10,
+                totalCount: 0,
+                unreadCount: 0,
+                hasMore: true,
+            },
+            markAsReadState: {
+                fetchState: 'Not-Started',
+                error: undefined,
+            },
+            markAsAllReadState: {
+                fetchState: 'Not-Started',
+                error: undefined,
+            },
+            hasValidState() {
+                return this.fetchState == 'Completed';
+            },
+            fetchState: 'Not-Started',
+            error: undefined,
+        },
+    },
+};
+const notificationView = (0, toolkit_1.createSlice)({
+    name: 'notificationView',
+    initialState: exports.initialState,
+    reducers: {
+        fetchNotificationView: {
+            reducer(draft, action) {
+                const { notificationGroup } = action.payload;
+                const notificationTab = (0, exports.toNotificationTab)(notificationGroup);
+                draft.stateByTab[notificationTab].fetchState = 'In-Progress';
+                draft.stateByTab[notificationTab].error = undefined;
+            },
+            prepare(notificationGroup, mode = 'dashboard', status = ['read', 'unread']) {
+                return {
+                    payload: {
+                        notificationGroup,
+                        mode,
+                        status,
+                    },
+                };
+            },
+        },
+        fetchNotificationViewSuccess: {
+            reducer(draft, action) {
+                const { notifications, pageToken, notificationGroup, totalCount } = action.payload;
+                const notificationTab = (0, exports.toNotificationTab)(notificationGroup);
+                draft.stateByTab[notificationTab].fetchState = 'In-Progress';
+                draft.stateByTab[notificationTab].error = undefined;
+                draft.stateByTab[notificationTab].allNotificationsIds = [
+                    ...new Set(draft.stateByTab[notificationTab].allNotificationsIds.concat(notifications.map((notification) => notification.user_notification_id))),
+                ];
+                if (totalCount -
+                    draft.stateByTab[notificationTab].allNotificationsIds.length >
+                    0) {
+                    draft.stateByTab[notificationTab].uiState.hasMore = true;
+                }
+                else {
+                    draft.stateByTab[notificationTab].uiState.hasMore = false;
+                }
+                draft.stateByTab[notificationTab].uiState.totalCount = totalCount;
+                draft.stateByTab[notificationTab].uiState.pageToken = pageToken;
+                draft.stateByTab[notificationTab].fetchState = 'Completed';
+                draft.stateByTab[notificationTab].error = undefined;
+            },
+            prepare(notifications, totalCount, notificationGroup, pageToken) {
+                return {
+                    payload: {
+                        notifications,
+                        totalCount,
+                        notificationGroup,
+                        pageToken,
+                    },
+                };
+            },
+        },
+        fetchNotificationViewFailure(draft, action) {
+            const { notificationGroup } = action.payload;
+            const notificationTab = (0, exports.toNotificationTab)(notificationGroup);
+            draft.stateByTab[notificationTab].fetchState = 'Error';
+            draft.stateByTab[notificationTab].error = action.payload.status;
+        },
+        fetchNotificationUnreadCount: {
+            reducer(draft, action) {
+                const { notificationGroup } = action.payload;
+                const notificationTab = (0, exports.toNotificationTab)(notificationGroup);
+                draft.stateByTab[notificationTab].fetchCountState.fetchState =
+                    'In-Progress';
+                draft.stateByTab[notificationTab].fetchCountState.error = undefined;
+            },
+            prepare(notificationGroup, mode = 'dashboard') {
+                return {
+                    payload: {
+                        notificationGroup,
+                        mode,
+                    },
+                };
+            },
+        },
+        fetchNotificationUnreadCountSuccess: {
+            reducer(draft, action) {
+                const { unreadCount, notificationGroup } = action.payload;
+                const notificationTab = (0, exports.toNotificationTab)(notificationGroup);
+                draft.stateByTab[notificationTab].uiState.unreadCount = unreadCount;
+                draft.stateByTab[notificationTab].fetchCountState.fetchState =
+                    'Completed';
+                draft.stateByTab[notificationTab].fetchCountState.error = undefined;
+            },
+            prepare(unreadCount, notificationGroup) {
+                return {
+                    payload: {
+                        unreadCount,
+                        notificationGroup,
+                    },
+                };
+            },
+        },
+        fetchNotificationUnreadCountFailure(draft, action) {
+            const { notificationGroup } = action.payload;
+            const notificationTab = (0, exports.toNotificationTab)(notificationGroup);
+            draft.stateByTab[notificationTab].fetchCountState.fetchState = 'Error';
+            draft.stateByTab[notificationTab].fetchCountState.error =
+                action.payload.status;
+        },
+        updateNotificationViewNotificationStatus: {
+            reducer(draft, action) {
+                const { notificationGroup } = action.payload;
+                const notificationTab = (0, exports.toNotificationTab)(notificationGroup);
+                draft.stateByTab[notificationTab].markAsReadState.fetchState =
+                    'In-Progress';
+                draft.stateByTab[notificationTab].markAsReadState.error = undefined;
+            },
+            prepare(notificationGroup, status, notificationIds = [], showSnackBarOnSuccess = true) {
+                return {
+                    payload: {
+                        notificationGroup,
+                        status,
+                        notificationIds,
+                        showSnackBarOnSuccess,
+                    },
+                };
+            },
+        },
+        updateNotificationViewNotificationStatusSuccess: {
+            reducer(draft, action) {
+                const { notificationGroup, reduceUnreadCountBy } = action.payload;
+                const notificationTab = (0, exports.toNotificationTab)(notificationGroup);
+                draft.stateByTab[notificationTab].markAsReadState.fetchState =
+                    'Completed';
+                draft.stateByTab[notificationTab].markAsReadState.error = undefined;
+                draft.stateByTab[notificationTab].uiState.unreadCount =
+                    draft.stateByTab[notificationTab].uiState.unreadCount -
+                        reduceUnreadCountBy >
+                        0
+                        ? draft.stateByTab[notificationTab].uiState.unreadCount -
+                            reduceUnreadCountBy
+                        : 0;
+                draft.stateByTab[notificationTab].selectedNotificationIds = [];
+            },
+            prepare(notificationGroup, reduceUnreadCountBy) {
+                return {
+                    payload: {
+                        notificationGroup,
+                        reduceUnreadCountBy,
+                    },
+                };
+            },
+        },
+        updateNotificationViewNotificationStatusFailure(draft, action) {
+            const { notificationGroup } = action.payload;
+            const notificationTab = (0, exports.toNotificationTab)(notificationGroup);
+            draft.stateByTab[notificationTab].markAsReadState.fetchState = 'Error';
+            draft.stateByTab[notificationTab].markAsReadState.error =
+                action.payload.status;
+        },
+        updateNotificationViewAllNotificationsStatus: {
+            reducer(draft, action) {
+                const { notificationGroup } = action.payload;
+                const notificationTab = (0, exports.toNotificationTab)(notificationGroup);
+                draft.stateByTab[notificationTab].markAsAllReadState.fetchState =
+                    'In-Progress';
+                draft.stateByTab[notificationTab].markAsAllReadState.error = undefined;
+            },
+            prepare(notificationGroup, status) {
+                return {
+                    payload: {
+                        notificationGroup,
+                        status,
+                    },
+                };
+            },
+        },
+        updateNotificationViewAllNotificationsStatusSuccess: {
+            reducer(draft, action) {
+                const { notificationGroup } = action.payload;
+                const notificationTab = (0, exports.toNotificationTab)(notificationGroup);
+                draft.stateByTab[notificationTab].markAsAllReadState.fetchState =
+                    'Completed';
+                draft.stateByTab[notificationTab].markAsAllReadState.error = undefined;
+                draft.stateByTab[notificationTab].uiState.unreadCount = 0;
+                draft.stateByTab[notificationTab].selectedNotificationIds = [];
+            },
+            prepare(notificationGroup) {
+                return {
+                    payload: {
+                        notificationGroup,
+                    },
+                };
+            },
+        },
+        updateNotificationViewAllNotificationsStatusFailure(draft, action) {
+            const { notificationGroup } = action.payload;
+            const notificationTab = (0, exports.toNotificationTab)(notificationGroup);
+            draft.stateByTab[notificationTab].markAsAllReadState.fetchState = 'Error';
+            draft.stateByTab[notificationTab].markAsAllReadState.error =
+                action.payload.status;
+        },
+        updateNotificationViewCurrentTabAndSubTab: {
+            reducer(draft, action) {
+                const { newTab, newSubTab } = action.payload;
+                draft.currentTab = newTab;
+                if (newSubTab != null) {
+                    draft.currentSubTab = newSubTab;
+                }
+                else if (newSubTab == null &&
+                    (0, notificationView_helpers_1.getSubTabsForATab)(newTab).includes(draft.currentSubTab) === false) {
+                    draft.currentSubTab = (0, notificationView_helpers_1.getSubTabsForATab)(newTab)[0];
+                }
+            },
+            prepare(newTab, newSubTab) {
+                return {
+                    payload: {
+                        newTab,
+                        newSubTab,
+                    },
+                };
+            },
+        },
+        updateNotificationViewSubTab: {
+            reducer(draft, action) {
+                const { newSubTab } = action.payload;
+                draft.currentSubTab = newSubTab;
+            },
+            prepare(newSubTab) {
+                return {
+                    payload: {
+                        newSubTab,
+                    },
+                };
+            },
+        },
+        updateNotificationViewUIState: {
+            reducer(draft, action) {
+                const { uiState, tab } = action.payload;
+                const { scrollYOffset, totalCount, hasMore, unreadCount } = uiState;
+                if (scrollYOffset != null) {
+                    draft.stateByTab[tab].uiState.scrollYOffset = scrollYOffset;
+                }
+                if (totalCount != null) {
+                    draft.stateByTab[tab].uiState.totalCount = totalCount;
+                }
+                if (unreadCount != null) {
+                    draft.stateByTab[tab].uiState.unreadCount = unreadCount;
+                }
+                if (hasMore != null) {
+                    draft.stateByTab[tab].uiState.hasMore = hasMore;
+                }
+            },
+            prepare(uiState, tab) {
+                return {
+                    payload: {
+                        uiState,
+                        tab,
+                    },
+                };
+            },
+        },
+        updateNotificationViewTabState: {
+            reducer(draft, action) {
+                const { notificationTabState, tab } = action.payload;
+                const { allNotificationsIds, selectedNotificationIds, fetchCountState, markAsReadState, markAsAllReadState, } = notificationTabState;
+                if (allNotificationsIds != null) {
+                    draft.stateByTab[tab].allNotificationsIds = allNotificationsIds;
+                }
+                if (selectedNotificationIds != null) {
+                    draft.stateByTab[tab].selectedNotificationIds =
+                        selectedNotificationIds;
+                }
+                if (fetchCountState != null) {
+                    draft.stateByTab[tab].fetchCountState = fetchCountState;
+                }
+                if (markAsReadState != null) {
+                    draft.stateByTab[tab].markAsReadState = markAsReadState;
+                }
+                if (markAsAllReadState != null) {
+                    draft.stateByTab[tab].markAsAllReadState = markAsAllReadState;
+                }
+            },
+            prepare(notificationTabState, tab) {
+                return {
+                    payload: {
+                        notificationTabState,
+                        tab,
+                    },
+                };
+            },
+        },
+        clearNotificationView(draft) {
+            Object.assign(draft, exports.initialState);
+        },
+    },
+});
+_a = notificationView.actions, exports.fetchNotificationView = _a.fetchNotificationView, exports.fetchNotificationViewSuccess = _a.fetchNotificationViewSuccess, exports.fetchNotificationViewFailure = _a.fetchNotificationViewFailure, exports.fetchNotificationUnreadCount = _a.fetchNotificationUnreadCount, exports.fetchNotificationUnreadCountSuccess = _a.fetchNotificationUnreadCountSuccess, exports.fetchNotificationUnreadCountFailure = _a.fetchNotificationUnreadCountFailure, exports.updateNotificationViewNotificationStatus = _a.updateNotificationViewNotificationStatus, exports.updateNotificationViewNotificationStatusSuccess = _a.updateNotificationViewNotificationStatusSuccess, exports.updateNotificationViewNotificationStatusFailure = _a.updateNotificationViewNotificationStatusFailure, exports.updateNotificationViewAllNotificationsStatus = _a.updateNotificationViewAllNotificationsStatus, exports.updateNotificationViewAllNotificationsStatusSuccess = _a.updateNotificationViewAllNotificationsStatusSuccess, exports.updateNotificationViewAllNotificationsStatusFailure = _a.updateNotificationViewAllNotificationsStatusFailure, exports.updateNotificationViewTabState = _a.updateNotificationViewTabState, exports.updateNotificationViewCurrentTabAndSubTab = _a.updateNotificationViewCurrentTabAndSubTab, exports.updateNotificationViewSubTab = _a.updateNotificationViewSubTab, exports.updateNotificationViewUIState = _a.updateNotificationViewUIState, exports.clearNotificationView = _a.clearNotificationView;
+exports.default = notificationView.reducer;
+/**
+ * Helpers
+ */
+const toNotificationTab = (notificationGroup) => {
+    if (notificationGroup === 'task_manager') {
+        return 'tasks';
+    }
+    return 'tasks'; // For now notificationGroup will be task_manager, in future we will be adding switch case here
+};
+exports.toNotificationTab = toNotificationTab;

package/lib/view/notificationView/notificationViewSelector.d.ts

@@ -0,0 +1,29 @@
+import { CoreNotificationData } from '@cord-sdk/types';
+import { RootState } from '../../reducer';
+import { NotificationSubTabType, NotificationTabType, NotificationTabState } from './notificationViewState';
+import { NotificationWithAuthors } from '../../entity/notification/types/notificationSelectorTypes';
+import { View } from '../../commonStateTypes/viewAndReport/viewAndReport';
+import { FetchStateAndError, ID } from '../../commonStateTypes/common';
+interface NotificationDetails extends NotificationTabState {
+    allNotificationsIdsForSubTab: ID[];
+    selectedNotificationIdsForSubTab: ID[];
+}
+export interface NotificationView extends View {
+    currentTab: NotificationTabType;
+    currentSubTab: NotificationSubTabType;
+    allSubTabs: NotificationSubTabType[];
+    notificationDetailsByTab: Record<NotificationTabType, NotificationDetails>;
+    allNotifications: NotificationWithAuthors[];
+    allExternalNotifications: CoreNotificationData[];
+    notificationsForCurrentTabAndSubTab: NotificationWithAuthors[];
+    externalNotificationsForCurrentTabAndSubTab: CoreNotificationData[];
+    reducedFetchCountState: FetchStateAndError;
+    totalUnreadCount: number;
+}
+export declare const getNotificationView: (state: RootState) => NotificationView;
+/**
+ * Helpers
+ */
+export declare const getNotificationsForSelectedSubTab: (notifications: NotificationWithAuthors[], currentSubTab: NotificationSubTabType) => NotificationWithAuthors[];
+export declare const getExternalNotificationsForSelectedSubTab: (externalNotifications: CoreNotificationData[], currentSubTab: NotificationSubTabType) => CoreNotificationData[];
+export {};