@zeniai/client-epic-state 5.0.37 → 5.0.38-betaNB1

package/lib/view/featureNotificationView/featureNotificationViewSelector.d.ts

@@ -0,0 +1,6 @@
+import { RootState } from '../../reducer';
+import { FeatureInterest } from './featureNotificationViewState';
+export declare const getFeatureNotificationView: (state: RootState) => import("./featureNotificationViewState").FeatureNotificationViewState;
+export declare const getRegisteredInterests: (state: RootState) => FeatureInterest[];
+export declare const getRegisteredInterestsByFeature: (state: RootState, feature: string) => FeatureInterest[];
+export declare const isFeatureInterestRegistered: (state: RootState, feature: string, additionalInfo: string) => boolean;

package/lib/view/featureNotificationView/featureNotificationViewSelector.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isFeatureInterestRegistered = exports.getRegisteredInterestsByFeature = exports.getRegisteredInterests = exports.getFeatureNotificationView = void 0;
+const getFeatureNotificationView = (state) => state.featureNotificationViewState;
+exports.getFeatureNotificationView = getFeatureNotificationView;
+const getRegisteredInterests = (state) => state.featureNotificationViewState.registeredInterests;
+exports.getRegisteredInterests = getRegisteredInterests;
+const getRegisteredInterestsByFeature = (state, feature) => state.featureNotificationViewState.registeredInterests.filter((interest) => interest.feature === feature);
+exports.getRegisteredInterestsByFeature = getRegisteredInterestsByFeature;
+const isFeatureInterestRegistered = (state, feature, additionalInfo) => state.featureNotificationViewState.registeredInterests.some((interest) => interest.feature === feature && interest.additionalInfo === additionalInfo);
+exports.isFeatureInterestRegistered = isFeatureInterestRegistered;

package/lib/view/featureNotificationView/featureNotificationViewState.d.ts

@@ -0,0 +1,26 @@
+import { FetchStateAndError, ID } from '../../commonStateTypes/common';
+import { ZeniDate } from '../../zeniDayJS';
+/**
+ * A single user-feature interest record returned by
+ * `GET /1.0/feature-interests` and `POST /1.0/feature-interests`.
+ *
+ * Used by the Integrations page "Notify me" buttons to register that the
+ * user wants an email when a not-yet-shipped connector becomes available.
+ * Generic enough to drive any future "Notify me" UI by adding a slug to
+ * the backend allowlist (FEATURE_INTEREST_ALLOWED_VALUES).
+ */
+export interface FeatureInterest {
+    createTime: ZeniDate;
+    feature: string;
+    interestId: ID;
+    notified: boolean;
+    updateTime: ZeniDate;
+    additionalInfo?: string;
+    email?: string;
+    notifiedTime?: ZeniDate;
+}
+export interface FeatureNotificationViewState {
+    fetchRegisteredInterestsState: FetchStateAndError;
+    notifyMeForFeatureState: FetchStateAndError;
+    registeredInterests: FeatureInterest[];
+}

package/lib/view/featureNotificationView/featureNotificationViewState.js

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

package/lib/view/taskManager/cannedResponsesView/cannedResponses.d.ts

@@ -0,0 +1,19 @@
+import { FetchState, ID } from '../../../commonStateTypes/common';
+import { ZeniAPIStatus } from '../../../responsePayload';
+import { ZeniDate } from '../../../zeniDayJS';
+export interface CannedResponse {
+    cannedResponseId: ID;
+    content: string;
+    createdBy: ID;
+    createTime: ZeniDate;
+    isDeleted: boolean;
+    name: string;
+    updateTime: ZeniDate;
+}
+export interface CannedResponsesViewState {
+    cannedResponses: CannedResponse[];
+    deleteFetchState: FetchState;
+    fetchState: FetchState;
+    saveFetchState: FetchState;
+    error?: ZeniAPIStatus;
+}

package/lib/view/taskManager/cannedResponsesView/cannedResponses.js

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

package/lib/view/taskManager/cannedResponsesView/cannedResponsesPayload.d.ts

@@ -0,0 +1,21 @@
+import { ZeniAPIResponse } from '../../../responsePayload';
+import { CannedResponse } from './cannedResponses';
+export interface CannedResponsePayload {
+    canned_response_id: string;
+    content: string;
+    create_time: string;
+    created_by: string;
+    is_deleted: boolean;
+    name: string;
+    update_time: string;
+}
+interface FetchCannedResponsesPayload {
+    canned_responses: CannedResponsePayload[];
+}
+export type FetchCannedResponsesResponse = ZeniAPIResponse<FetchCannedResponsesPayload>;
+export type SaveCannedResponseResponse = ZeniAPIResponse<{
+    canned_response: CannedResponsePayload;
+}>;
+export type DeleteCannedResponseResponse = ZeniAPIResponse<unknown>;
+export declare function mapCannedResponsePayloadToCannedResponse(payload: CannedResponsePayload): CannedResponse;
+export {};

package/lib/view/taskManager/cannedResponsesView/cannedResponsesPayload.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapCannedResponsePayloadToCannedResponse = mapCannedResponsePayloadToCannedResponse;
+const zeniDayJS_1 = require("../../../zeniDayJS");
+function mapCannedResponsePayloadToCannedResponse(payload) {
+    return {
+        cannedResponseId: payload.canned_response_id,
+        content: payload.content,
+        createTime: (0, zeniDayJS_1.date)(payload.create_time),
+        createdBy: payload.created_by,
+        isDeleted: payload.is_deleted,
+        name: payload.name,
+        updateTime: (0, zeniDayJS_1.date)(payload.update_time),
+    };
+}

package/lib/view/taskManager/cannedResponsesView/cannedResponsesReducer.d.ts

@@ -0,0 +1,30 @@
+import { FetchState, ID } from '../../../commonStateTypes/common';
+import { ZeniAPIStatus } from '../../../responsePayload';
+import { CannedResponse, CannedResponsesViewState } from './cannedResponses';
+export declare const initialState: CannedResponsesViewState;
+export declare const fetchCannedResponses: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"cannedResponsesView/fetchCannedResponses">, updateCannedResponses: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    cannedResponses: CannedResponse[];
+}, "cannedResponsesView/updateCannedResponses">, updateCannedResponsesFetchStatus: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    fetchState: FetchState;
+    error?: ZeniAPIStatus;
+}, "cannedResponsesView/updateCannedResponsesFetchStatus">, saveCannedResponse: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[payload: {
+    content: string;
+    name: string;
+    cannedResponseId?: ID;
+}], {
+    content: string;
+    name: string;
+    cannedResponseId?: ID;
+}, "cannedResponsesView/saveCannedResponse", never, never>, saveCannedResponseSuccess: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"cannedResponsesView/saveCannedResponseSuccess">, saveCannedResponseFailure: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    error?: ZeniAPIStatus;
+}, "cannedResponsesView/saveCannedResponseFailure">, deleteCannedResponse: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[payload: {
+    cannedResponseId: ID;
+}], {
+    cannedResponseId: ID;
+}, "cannedResponsesView/deleteCannedResponse", never, never>, deleteCannedResponseSuccess: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    cannedResponseId: ID;
+}, "cannedResponsesView/deleteCannedResponseSuccess">, deleteCannedResponseFailure: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    error?: ZeniAPIStatus;
+}, "cannedResponsesView/deleteCannedResponseFailure">, clearCannedResponses: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"cannedResponsesView/clearCannedResponses">;
+declare const _default: import("redux").Reducer<CannedResponsesViewState>;
+export default _default;

package/lib/view/taskManager/cannedResponsesView/cannedResponsesReducer.js

@@ -0,0 +1,68 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearCannedResponses = exports.deleteCannedResponseFailure = exports.deleteCannedResponseSuccess = exports.deleteCannedResponse = exports.saveCannedResponseFailure = exports.saveCannedResponseSuccess = exports.saveCannedResponse = exports.updateCannedResponsesFetchStatus = exports.updateCannedResponses = exports.fetchCannedResponses = exports.initialState = void 0;
+const toolkit_1 = require("@reduxjs/toolkit");
+exports.initialState = {
+    cannedResponses: [],
+    fetchState: 'Not-Started',
+    saveFetchState: 'Not-Started',
+    deleteFetchState: 'Not-Started',
+    error: undefined,
+};
+const cannedResponsesView = (0, toolkit_1.createSlice)({
+    name: 'cannedResponsesView',
+    initialState: exports.initialState,
+    reducers: {
+        fetchCannedResponses(draft) {
+            draft.fetchState =
+                draft.cannedResponses.length > 0 ? 'Completed' : 'In-Progress';
+            draft.error = undefined;
+        },
+        updateCannedResponses(draft, action) {
+            draft.cannedResponses = action.payload.cannedResponses;
+            draft.fetchState = 'Completed';
+            draft.error = undefined;
+        },
+        updateCannedResponsesFetchStatus(draft, action) {
+            draft.fetchState = action.payload.fetchState;
+            draft.error = action.payload.error;
+        },
+        saveCannedResponse: {
+            reducer(draft) {
+                draft.saveFetchState = 'In-Progress';
+            },
+            prepare(payload) {
+                return { payload };
+            },
+        },
+        saveCannedResponseSuccess(draft) {
+            draft.saveFetchState = 'Completed';
+        },
+        saveCannedResponseFailure(draft, action) {
+            draft.saveFetchState = 'Error';
+            draft.error = action.payload.error;
+        },
+        deleteCannedResponse: {
+            reducer(draft) {
+                draft.deleteFetchState = 'In-Progress';
+            },
+            prepare(payload) {
+                return { payload };
+            },
+        },
+        deleteCannedResponseSuccess(draft, action) {
+            draft.deleteFetchState = 'Completed';
+            draft.cannedResponses = draft.cannedResponses.filter((r) => r.cannedResponseId !== action.payload.cannedResponseId);
+        },
+        deleteCannedResponseFailure(draft, action) {
+            draft.deleteFetchState = 'Error';
+            draft.error = action.payload.error;
+        },
+        clearCannedResponses() {
+            return exports.initialState;
+        },
+    },
+});
+_a = cannedResponsesView.actions, exports.fetchCannedResponses = _a.fetchCannedResponses, exports.updateCannedResponses = _a.updateCannedResponses, exports.updateCannedResponsesFetchStatus = _a.updateCannedResponsesFetchStatus, exports.saveCannedResponse = _a.saveCannedResponse, exports.saveCannedResponseSuccess = _a.saveCannedResponseSuccess, exports.saveCannedResponseFailure = _a.saveCannedResponseFailure, exports.deleteCannedResponse = _a.deleteCannedResponse, exports.deleteCannedResponseSuccess = _a.deleteCannedResponseSuccess, exports.deleteCannedResponseFailure = _a.deleteCannedResponseFailure, exports.clearCannedResponses = _a.clearCannedResponses;
+exports.default = cannedResponsesView.reducer;

package/lib/view/taskManager/cannedResponsesView/cannedResponsesSelector.d.ts

@@ -0,0 +1,3 @@
+import { RootState } from '../../../reducer';
+import { CannedResponsesViewState } from './cannedResponses';
+export declare function getCannedResponsesView(state: RootState): CannedResponsesViewState;

package/lib/view/taskManager/cannedResponsesView/cannedResponsesSelector.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCannedResponsesView = getCannedResponsesView;
+function getCannedResponsesView(state) {
+    return state.cannedResponsesState;
+}

package/lib/view/taskManager/cannedResponsesView/epics/deleteCannedResponseEpic.d.ts

@@ -0,0 +1,7 @@
+import { ActionsObservable, StateObservable } from 'redux-observable';
+import { Observable } from 'rxjs';
+import { RootState } from '../../../../reducer';
+import { ZeniAPI } from '../../../../zeniAPI';
+import { deleteCannedResponse, deleteCannedResponseFailure, deleteCannedResponseSuccess } from '../cannedResponsesReducer';
+export type ActionType = ReturnType<typeof deleteCannedResponse> | ReturnType<typeof deleteCannedResponseSuccess> | ReturnType<typeof deleteCannedResponseFailure>;
+export declare const deleteCannedResponseEpic: (actions$: ActionsObservable<ActionType>, _state$: StateObservable<RootState>, zeniAPI: ZeniAPI) => Observable<ActionType>;

package/lib/view/taskManager/cannedResponsesView/epics/deleteCannedResponseEpic.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteCannedResponseEpic = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const responsePayload_1 = require("../../../../responsePayload");
+const cannedResponsesReducer_1 = require("../cannedResponsesReducer");
+const deleteCannedResponseEpic = (actions$, _state$, zeniAPI) => actions$.pipe((0, operators_1.filter)(cannedResponsesReducer_1.deleteCannedResponse.match), (0, operators_1.mergeMap)((action) => {
+    const { cannedResponseId } = action.payload;
+    return zeniAPI
+        .deleteAndGetJSON(`${zeniAPI.apiEndPoints.taskMicroServiceBaseUrl}/1.0/task-manager/canned-responses/${cannedResponseId}`)
+        .pipe((0, operators_1.mergeMap)((response) => {
+        if ((0, responsePayload_1.isSuccessResponse)(response)) {
+            return (0, rxjs_1.of)((0, cannedResponsesReducer_1.deleteCannedResponseSuccess)({ cannedResponseId }));
+        }
+        return (0, rxjs_1.of)((0, cannedResponsesReducer_1.deleteCannedResponseFailure)({ error: response.status }));
+    }), (0, operators_1.catchError)((error) => (0, rxjs_1.of)((0, cannedResponsesReducer_1.deleteCannedResponseFailure)({
+        error: (0, responsePayload_1.createZeniAPIStatus)('Unexpected Error', 'Delete Canned Response errored: ' + JSON.stringify(error)),
+    }))));
+}));
+exports.deleteCannedResponseEpic = deleteCannedResponseEpic;

package/lib/view/taskManager/cannedResponsesView/epics/fetchCannedResponsesEpic.d.ts

@@ -0,0 +1,7 @@
+import { ActionsObservable, StateObservable } from 'redux-observable';
+import { Observable } from 'rxjs';
+import { RootState } from '../../../../reducer';
+import { ZeniAPI } from '../../../../zeniAPI';
+import { fetchCannedResponses, updateCannedResponses, updateCannedResponsesFetchStatus } from '../cannedResponsesReducer';
+export type ActionType = ReturnType<typeof fetchCannedResponses> | ReturnType<typeof updateCannedResponses> | ReturnType<typeof updateCannedResponsesFetchStatus>;
+export declare const fetchCannedResponsesEpic: (actions$: ActionsObservable<ActionType>, _state$: StateObservable<RootState>, zeniAPI: ZeniAPI) => Observable<ActionType>;

package/lib/view/taskManager/cannedResponsesView/epics/fetchCannedResponsesEpic.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchCannedResponsesEpic = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const responsePayload_1 = require("../../../../responsePayload");
+const cannedResponsesPayload_1 = require("../cannedResponsesPayload");
+const cannedResponsesReducer_1 = require("../cannedResponsesReducer");
+const fetchCannedResponsesEpic = (actions$, _state$, zeniAPI) => actions$.pipe((0, operators_1.filter)(cannedResponsesReducer_1.fetchCannedResponses.match), (0, operators_1.switchMap)(() => zeniAPI
+    .getJSON(`${zeniAPI.apiEndPoints.taskMicroServiceBaseUrl}/1.0/task-manager/canned-responses`)
+    .pipe((0, operators_1.mergeMap)((response) => {
+    if ((0, responsePayload_1.isSuccessResponse)(response) && response.data != null) {
+        return (0, rxjs_1.of)((0, cannedResponsesReducer_1.updateCannedResponses)({
+            cannedResponses: (response.data.canned_responses ?? []).map(cannedResponsesPayload_1.mapCannedResponsePayloadToCannedResponse),
+        }));
+    }
+    return (0, rxjs_1.of)((0, cannedResponsesReducer_1.updateCannedResponsesFetchStatus)({
+        fetchState: 'Error',
+        error: response.status,
+    }));
+}), (0, operators_1.catchError)((error) => (0, rxjs_1.of)((0, cannedResponsesReducer_1.updateCannedResponsesFetchStatus)({
+    fetchState: 'Error',
+    error: (0, responsePayload_1.createZeniAPIStatus)('Unexpected Error', 'Fetch Canned Responses errored: ' + JSON.stringify(error)),
+}))))));
+exports.fetchCannedResponsesEpic = fetchCannedResponsesEpic;

package/lib/view/taskManager/cannedResponsesView/epics/saveCannedResponseEpic.d.ts

@@ -0,0 +1,7 @@
+import { ActionsObservable, StateObservable } from 'redux-observable';
+import { Observable } from 'rxjs';
+import { RootState } from '../../../../reducer';
+import { ZeniAPI } from '../../../../zeniAPI';
+import { fetchCannedResponses, saveCannedResponse, saveCannedResponseFailure, saveCannedResponseSuccess } from '../cannedResponsesReducer';
+export type ActionType = ReturnType<typeof saveCannedResponse> | ReturnType<typeof saveCannedResponseSuccess> | ReturnType<typeof saveCannedResponseFailure> | ReturnType<typeof fetchCannedResponses>;
+export declare const saveCannedResponseEpic: (actions$: ActionsObservable<ActionType>, _state$: StateObservable<RootState>, zeniAPI: ZeniAPI) => Observable<ActionType>;

package/lib/view/taskManager/cannedResponsesView/epics/saveCannedResponseEpic.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saveCannedResponseEpic = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const responsePayload_1 = require("../../../../responsePayload");
+const cannedResponsesReducer_1 = require("../cannedResponsesReducer");
+const saveCannedResponseEpic = (actions$, _state$, zeniAPI) => actions$.pipe((0, operators_1.filter)(cannedResponsesReducer_1.saveCannedResponse.match), (0, operators_1.switchMap)((action) => {
+    const { name, content, cannedResponseId } = action.payload;
+    const isUpdate = cannedResponseId != null;
+    const url = isUpdate
+        ? `${zeniAPI.apiEndPoints.taskMicroServiceBaseUrl}/1.0/task-manager/canned-responses/${cannedResponseId}`
+        : `${zeniAPI.apiEndPoints.taskMicroServiceBaseUrl}/1.0/task-manager/canned-responses`;
+    const apiCall = isUpdate
+        ? zeniAPI.putAndGetJSON(url, {
+            name,
+            content,
+        })
+        : zeniAPI.postAndGetJSON(url, {
+            name,
+            content,
+        });
+    return apiCall.pipe((0, operators_1.mergeMap)((response) => {
+        if ((0, responsePayload_1.isSuccessResponse)(response)) {
+            return (0, rxjs_1.of)((0, cannedResponsesReducer_1.saveCannedResponseSuccess)(), (0, cannedResponsesReducer_1.fetchCannedResponses)() // Refresh list after save
+            );
+        }
+        return (0, rxjs_1.of)((0, cannedResponsesReducer_1.saveCannedResponseFailure)({ error: response.status }));
+    }), (0, operators_1.catchError)((error) => (0, rxjs_1.of)((0, cannedResponsesReducer_1.saveCannedResponseFailure)({
+        error: (0, responsePayload_1.createZeniAPIStatus)('Unexpected Error', 'Save Canned Response errored: ' + JSON.stringify(error)),
+    }))));
+}));
+exports.saveCannedResponseEpic = saveCannedResponseEpic;

package/lib/view/taskManager/taskDetailView/epics/archiveTaskEpic.d.ts

@@ -3,6 +3,7 @@ import { openSnackbar } from '../../../../entity/snackbar/snackbarReducer';
 import { updateTasks } from '../../../../entity/task/taskReducer';
 import { RootState } from '../../../../reducer';
 import { ZeniAPI } from '../../../../zeniAPI';
+import { fetchTaskList, removeTaskFromList } from '../../taskListView/taskListReducer';
 import { archiveTask, archiveTaskSuccessOrFailure } from '../taskDetailReducer';
-export type ActionType = ReturnType<typeof archiveTask> | ReturnType<typeof updateTasks> | ReturnType<typeof openSnackbar> | ReturnType<typeof archiveTaskSuccessOrFailure>;
+export type ActionType = ReturnType<typeof archiveTask> | ReturnType<typeof updateTasks> | ReturnType<typeof openSnackbar> | ReturnType<typeof fetchTaskList> | ReturnType<typeof archiveTaskSuccessOrFailure> | ReturnType<typeof removeTaskFromList>;
 export declare const archiveTaskEpic: (actions$: ActionsObservable<ActionType>, state$: StateObservable<RootState>, zeniAPI: ZeniAPI) => import("rxjs").Observable<ActionType>;

package/lib/view/taskManager/taskDetailView/epics/archiveTaskEpic.js

@@ -7,6 +7,7 @@ const snackbarReducer_1 = require("../../../../entity/snackbar/snackbarReducer")
 const taskReducer_1 = require("../../../../entity/task/taskReducer");
 const taskSelector_1 = require("../../../../entity/task/taskSelector");
 const responsePayload_1 = require("../../../../responsePayload");
+const taskListReducer_1 = require("../../taskListView/taskListReducer");
 const taskDetailReducer_1 = require("../taskDetailReducer");
 // Epic function to handle archiving of tasks
 const archiveTaskEpic = (actions$, state$, zeniAPI) => actions$.pipe((0, operators_1.filter)(taskDetailReducer_1.archiveTask.match), (0, operators_1.mergeMap)((action) => handleArchiveTask(action.payload.taskId, state$, zeniAPI)));
@@ -29,6 +30,8 @@ const handleApiResponse = (response, taskId) => {
         response.data.tasks.length > 0) {
         const fetchActions = [
             (0, taskReducer_1.updateTasks)(response.data.tasks),
+            (0, taskListReducer_1.removeTaskFromList)(taskId),
+            (0, taskListReducer_1.fetchTaskList)(),
             (0, taskDetailReducer_1.archiveTaskSuccessOrFailure)({
                 fetchState: 'Completed',
                 taskId,

package/lib/view/taskManager/taskDetailView/epics/deleteTaskEpic.d.ts

@@ -2,6 +2,7 @@ import { ActionsObservable, StateObservable } from 'redux-observable';
 import { openSnackbar } from '../../../../entity/snackbar/snackbarReducer';
 import { RootState } from '../../../../reducer';
 import { ZeniAPI } from '../../../../zeniAPI';
+import { fetchTaskList, removeTaskFromList } from '../../taskListView/taskListReducer';
 import { deleteTask, deleteTaskSuccessOrFailure } from '../taskDetailReducer';
-export type ActionType = ReturnType<typeof deleteTask> | ReturnType<typeof openSnackbar> | ReturnType<typeof deleteTaskSuccessOrFailure>;
+export type ActionType = ReturnType<typeof deleteTask> | ReturnType<typeof openSnackbar> | ReturnType<typeof fetchTaskList> | ReturnType<typeof deleteTaskSuccessOrFailure> | ReturnType<typeof removeTaskFromList>;
 export declare const deleteTaskEpic: (actions$: ActionsObservable<ActionType>, _state$: StateObservable<RootState>, zeniAPI: ZeniAPI) => import("rxjs").Observable<ActionType>;

package/lib/view/taskManager/taskDetailView/epics/deleteTaskEpic.js

@@ -5,6 +5,7 @@ const rxjs_1 = require("rxjs");
 const operators_1 = require("rxjs/operators");
 const snackbarReducer_1 = require("../../../../entity/snackbar/snackbarReducer");
 const responsePayload_1 = require("../../../../responsePayload");
+const taskListReducer_1 = require("../../taskListView/taskListReducer");
 const taskDetailReducer_1 = require("../taskDetailReducer");
 const deleteTaskEpic = (actions$, _state$, zeniAPI) => actions$.pipe((0, operators_1.filter)(taskDetailReducer_1.deleteTask.match), (0, operators_1.mergeMap)((action) => {
     const { taskId } = action.payload;
@@ -13,6 +14,10 @@ const deleteTaskEpic = (actions$, _state$, zeniAPI) => actions$.pipe((0, operato
         .pipe((0, operators_1.mergeMap)((response) => {
         if ((0, responsePayload_1.isSuccessStatus)(response)) {
             const actions = [];
+            if (taskId != null) {
+                actions.push((0, taskListReducer_1.removeTaskFromList)(taskId));
+            }
+            actions.push((0, taskListReducer_1.fetchTaskList)());
             actions.push((0, taskDetailReducer_1.deleteTaskSuccessOrFailure)({ fetchState: 'Completed', taskId }));
             return (0, rxjs_1.from)(actions);
         }

package/lib/view/taskManager/taskDetailView/epics/initializeTaskToLocalStoreEpic.js

@@ -31,6 +31,7 @@ const initializeTaskToLocalStoreEpic = (actions$, state$) => actions$.pipe((0, o
             savedRecurringEndDate: task.recurringEndDate,
             recurringStartDate: task.recurringStartDate,
             timeSpent: task.timeSpent,
+            isPrivate: task.isPrivate,
         };
         const actions = [
             (0, taskDetailReducer_1.saveTaskUpdatesToLocalStore)({ taskDetailLocalData, taskId }),

package/lib/view/taskManager/taskDetailView/epics/saveTaskDetailEpic.js

@@ -98,5 +98,6 @@ const prepareTaskPayload = (state, taskId, taskGroupId) => {
         sync_token: syncToken,
         task_group_ids: taskGroupId != null ? [taskGroupId] : [],
         time_spent: (0, formatMinutesToFromHHMM_1.convertHHMMStrToMinutes)(localData.timeSpent),
+        ...(taskId == null ? { is_private: localData.isPrivate ?? false } : {}),
     };
 };

package/lib/view/taskManager/taskDetailView/epics/snoozeTaskEpic.d.ts

@@ -0,0 +1,9 @@
+import { ActionsObservable, StateObservable } from 'redux-observable';
+import { openSnackbar } from '../../../../entity/snackbar/snackbarReducer';
+import { updateTasks } from '../../../../entity/task/taskReducer';
+import { RootState } from '../../../../reducer';
+import { ZeniAPI } from '../../../../zeniAPI';
+import { fetchTaskList, removeTaskFromList } from '../../taskListView/taskListReducer';
+import { snoozeTask, snoozeTaskSuccessOrFailure } from '../taskDetailReducer';
+export type ActionType = ReturnType<typeof snoozeTask> | ReturnType<typeof updateTasks> | ReturnType<typeof openSnackbar> | ReturnType<typeof fetchTaskList> | ReturnType<typeof snoozeTaskSuccessOrFailure> | ReturnType<typeof removeTaskFromList>;
+export declare const snoozeTaskEpic: (actions$: ActionsObservable<ActionType>, _state$: StateObservable<RootState>, zeniAPI: ZeniAPI) => import("rxjs").Observable<ActionType>;

package/lib/view/taskManager/taskDetailView/epics/snoozeTaskEpic.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.snoozeTaskEpic = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const formatZeniDateFY_1 = require("../../../../commonStateTypes/fiscalYearHelpers/formatZeniDateFY");
+const snackbarReducer_1 = require("../../../../entity/snackbar/snackbarReducer");
+const taskReducer_1 = require("../../../../entity/task/taskReducer");
+const responsePayload_1 = require("../../../../responsePayload");
+const zeniDayJS_1 = require("../../../../zeniDayJS");
+const taskListReducer_1 = require("../../taskListView/taskListReducer");
+const taskDetailReducer_1 = require("../taskDetailReducer");
+const snoozeTaskEpic = (actions$, _state$, zeniAPI) => actions$.pipe((0, operators_1.filter)(taskDetailReducer_1.snoozeTask.match), (0, operators_1.mergeMap)((action) => handleSnoozeTask(action.payload.taskId, action.payload.snoozedUntil, zeniAPI)));
+exports.snoozeTaskEpic = snoozeTaskEpic;
+const formatSnoozedUntilForDisplay = (snoozedUntil) => (0, zeniDayJS_1.date)(snoozedUntil).format(formatZeniDateFY_1.SNOOZED_DISPLAY_FORMAT);
+const handleSnoozeTask = (taskId, snoozedUntil, zeniAPI) => {
+    const snoozeTaskApi$ = zeniAPI.postAndGetJSON(`${zeniAPI.apiEndPoints.taskMicroServiceBaseUrl}/1.0/task-manager/tasks/${taskId}/snooze`, { snoozed_until: snoozedUntil });
+    return snoozeTaskApi$.pipe((0, operators_1.mergeMap)((response) => handleApiResponse(response, taskId, snoozedUntil)), (0, operators_1.catchError)((error) => (0, rxjs_1.of)((0, taskDetailReducer_1.snoozeTaskSuccessOrFailure)({
+        fetchState: 'Error',
+        taskId,
+        error: (0, responsePayload_1.createZeniAPIStatus)('Unexpected Error', 'Snooze Task REST API call errored out: ' + JSON.stringify(error)),
+    }))));
+};
+const handleApiResponse = (response, taskId, snoozedUntil) => {
+    if ((0, responsePayload_1.isSuccessResponse)(response) &&
+        response.data != null &&
+        response.data.tasks.length > 0) {
+        const fetchActions = [
+            (0, taskReducer_1.updateTasks)(response.data.tasks),
+            (0, taskListReducer_1.removeTaskFromList)(taskId),
+            (0, taskListReducer_1.fetchTaskList)(),
+            (0, taskDetailReducer_1.snoozeTaskSuccessOrFailure)({
+                fetchState: 'Completed',
+                taskId,
+            }),
+            (0, snackbarReducer_1.openSnackbar)({
+                messageSection: 'snooze_task',
+                messageText: 'success',
+                type: 'success',
+                variables: [
+                    {
+                        variableName: '_snoozed_until_',
+                        variableValue: formatSnoozedUntilForDisplay(snoozedUntil),
+                    },
+                ],
+            }),
+        ];
+        return (0, rxjs_1.from)(fetchActions);
+    }
+    else {
+        return (0, rxjs_1.from)([
+            (0, taskDetailReducer_1.snoozeTaskSuccessOrFailure)({
+                fetchState: 'Error',
+                taskId,
+                error: response.status,
+            }),
+            (0, snackbarReducer_1.openSnackbar)({
+                messageSection: 'snooze_task',
+                messageText: 'failed',
+                type: 'error',
+                variables: [
+                    {
+                        variableName: '_api-error_',
+                        variableValue: response.status.message,
+                    },
+                ],
+            }),
+        ]);
+    }
+};

package/lib/view/taskManager/taskDetailView/epics/unsnoozeTaskEpic.d.ts

@@ -0,0 +1,9 @@
+import { ActionsObservable, StateObservable } from 'redux-observable';
+import { openSnackbar } from '../../../../entity/snackbar/snackbarReducer';
+import { updateTasks } from '../../../../entity/task/taskReducer';
+import { RootState } from '../../../../reducer';
+import { ZeniAPI } from '../../../../zeniAPI';
+import { fetchTaskList, removeTaskFromList } from '../../taskListView/taskListReducer';
+import { snoozeTaskSuccessOrFailure, unsnoozeTask } from '../taskDetailReducer';
+export type ActionType = ReturnType<typeof unsnoozeTask> | ReturnType<typeof updateTasks> | ReturnType<typeof openSnackbar> | ReturnType<typeof fetchTaskList> | ReturnType<typeof removeTaskFromList> | ReturnType<typeof snoozeTaskSuccessOrFailure>;
+export declare const unsnoozeTaskEpic: (actions$: ActionsObservable<ActionType>, _state$: StateObservable<RootState>, zeniAPI: ZeniAPI) => import("rxjs").Observable<ActionType>;

package/lib/view/taskManager/taskDetailView/epics/unsnoozeTaskEpic.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unsnoozeTaskEpic = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const snackbarReducer_1 = require("../../../../entity/snackbar/snackbarReducer");
+const taskReducer_1 = require("../../../../entity/task/taskReducer");
+const responsePayload_1 = require("../../../../responsePayload");
+const taskListReducer_1 = require("../../taskListView/taskListReducer");
+const taskDetailReducer_1 = require("../taskDetailReducer");
+const unsnoozeTaskEpic = (actions$, _state$, zeniAPI) => actions$.pipe((0, operators_1.filter)(taskDetailReducer_1.unsnoozeTask.match), (0, operators_1.mergeMap)((action) => handleUnsnoozeTask(action.payload.taskId, zeniAPI)));
+exports.unsnoozeTaskEpic = unsnoozeTaskEpic;
+const handleUnsnoozeTask = (taskId, zeniAPI) => {
+    const unsnoozeTaskApi$ = zeniAPI.deleteAndGetJSON(`${zeniAPI.apiEndPoints.taskMicroServiceBaseUrl}/1.0/task-manager/tasks/${taskId}/snooze`);
+    return unsnoozeTaskApi$.pipe((0, operators_1.mergeMap)((response) => handleApiResponse(response, taskId)), (0, operators_1.catchError)((error) => (0, rxjs_1.of)((0, taskDetailReducer_1.snoozeTaskSuccessOrFailure)({
+        fetchState: 'Error',
+        taskId,
+        error: (0, responsePayload_1.createZeniAPIStatus)('Unexpected Error', 'Unsnooze Task REST API call errored out: ' + JSON.stringify(error)),
+    }))));
+};
+const handleApiResponse = (response, taskId) => {
+    if ((0, responsePayload_1.isSuccessResponse)(response) &&
+        response.data != null &&
+        response.data.tasks.length > 0) {
+        const fetchActions = [
+            (0, taskReducer_1.updateTasks)(response.data.tasks),
+            (0, taskListReducer_1.removeTaskFromList)(taskId),
+            (0, taskListReducer_1.fetchTaskList)(),
+            (0, taskDetailReducer_1.snoozeTaskSuccessOrFailure)({
+                fetchState: 'Completed',
+                taskId,
+            }),
+            (0, snackbarReducer_1.openSnackbar)({
+                messageSection: 'unsnooze_task',
+                messageText: 'success',
+                type: 'success',
+            }),
+        ];
+        return (0, rxjs_1.from)(fetchActions);
+    }
+    else {
+        return (0, rxjs_1.from)([
+            (0, taskDetailReducer_1.snoozeTaskSuccessOrFailure)({
+                fetchState: 'Error',
+                taskId,
+                error: response.status,
+            }),
+            (0, snackbarReducer_1.openSnackbar)({
+                messageSection: 'unsnooze_task',
+                messageText: 'failed',
+                type: 'error',
+                variables: [
+                    {
+                        variableName: '_api-error_',
+                        variableValue: response.status.message,
+                    },
+                ],
+            }),
+        ]);
+    }
+};

package/lib/view/taskManager/taskDetailView/taskDetail.d.ts

@@ -13,6 +13,7 @@ export interface EditTaskDetail {
     deleteTaskStatus: FetchStateAndError;
     fetchTaskStatus: FetchStateAndError;
     saveStatus: FetchStateAndError;
+    snoozeStatus: FetchStateAndError;
     taskDetailLocalData: EditTaskLocalData;
     taskId?: ID;
 }
@@ -32,6 +33,7 @@ export interface EditTaskLocalData {
     timeSpent: string;
     type: TaskType;
     dueDate?: ZeniDate;
+    isPrivate?: boolean;
     recurringFrequency?: RecurringFrequencyType;
     recurringStartDate?: ZeniDate;
     savedRecurringEndDate?: ZeniDate;

package/lib/view/taskManager/taskDetailView/taskDetail.js

@@ -34,5 +34,9 @@ exports.initialTaskDetail = {
         fetchState: 'Not-Started',
         error: undefined,
     },
+    snoozeStatus: {
+        fetchState: 'Not-Started',
+        error: undefined,
+    },
     taskDetailLocalData: exports.initialTaskDetailLocalData,
 };

package/lib/view/taskManager/taskDetailView/taskDetailReducer.d.ts

@@ -40,7 +40,16 @@ export declare const fetchTaskDetailPage: import("@reduxjs/toolkit").ActionCreat
     fetchState: FetchState;
     error?: ZeniAPIStatus;
     taskId?: ID;
-}, "taskDetailView/deleteTaskSuccessOrFailure">, fetchTaskHistory: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[taskId: string, cacheOverride?: any], {
+}, "taskDetailView/deleteTaskSuccessOrFailure">, snoozeTask: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[taskId: string, snoozedUntil: string], {
+    taskId: string;
+    snoozedUntil: string;
+}, "taskDetailView/snoozeTask", never, never>, snoozeTaskSuccessOrFailure: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    fetchState: FetchState;
+    taskId: ID;
+    error?: ZeniAPIStatus;
+}, "taskDetailView/snoozeTaskSuccessOrFailure">, unsnoozeTask: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[taskId: string], {
+    taskId: string;
+}, "taskDetailView/unsnoozeTask", never, never>, fetchTaskHistory: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[taskId: string, cacheOverride?: any], {
     taskId: string;
     cacheOverride: any;
 }, "taskDetailView/fetchTaskHistory", never, never>, updateTaskHistory: import("@reduxjs/toolkit").ActionCreatorWithPayload<{