@zeniai/client-epic-state 5.3.7 → 5.3.8-beta0DI

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

@@ -32,6 +32,7 @@ const getTaskDetail = (state, taskId) => {
     let isDeleted = undefined;
     let depth = undefined;
     let recurringSourceTaskId = undefined;
+    let taskCategoryId = undefined;
     let snoozedUntil = undefined;
     let taskGroupId = undefined;
     let subtasks = [];
@@ -45,6 +46,7 @@ const getTaskDetail = (state, taskId) => {
         if (taskEntity != null) {
             createdByUser = (0, userAndRole_1.getUserAndUserRole)(userState, userRoleState, addressState, taskEntity.createdBy);
             depth = taskEntity.depth;
+            taskCategoryId = taskEntity.taskCategoryId;
             isArchived = taskEntity.isArchived;
             isDeleted = taskEntity.isDeleted;
             recurringSourceTaskId = taskEntity.recurringSourceTaskId;
@@ -109,6 +111,7 @@ const getTaskDetail = (state, taskId) => {
         version: 0,
         createdByUser,
         depth,
+        taskCategoryId,
         isArchived,
         isDeleted,
         recurringSourceTaskId,

package/lib/view/taskManager/taskListView/taskList.d.ts

@@ -48,7 +48,7 @@ export interface TaskFilterCategory {
     values: (string | ZeniDate)[];
     valuesCombinationOperator: 'ANY';
 }
-export type TaskListFilterCategoryField = 'status' | 'dueDate' | 'assignee' | 'creationDate' | 'priority' | 'tag';
+export type TaskListFilterCategoryField = 'status' | 'dueDate' | 'assignee' | 'createdBy' | 'creationDate' | 'priority' | 'tag';
 export declare const TASK_LIST_GROUP_BY_KEYS: readonly ["groupName", "status", "dueDate", "assignee", "priority", "tag"];
 export declare const toTaskListGroupByKeyType: (v: string) => "status" | "dueDate" | "priority" | "assignee" | "tag" | "groupName";
 export declare const toTaskListGroupByKeyTypeStrict: (v: string) => "status" | "dueDate" | "priority" | "assignee" | "tag" | "groupName" | undefined;

package/lib/view/taskManager/taskListView/taskList.js

@@ -53,6 +53,11 @@ exports.TASK_LIST_FILTER_CATEGORIES = [
         type: 'user',
         multiple: true,
     },
+    {
+        value: 'createdBy',
+        type: 'user',
+        multiple: true,
+    },
     { value: 'creationDate', type: 'dateRange', multiple: true },
 ];
 exports.TASK_LIST_GROUP_BY_CATEGORIES = [

package/lib/view/taskManager/taskListView/taskListFilterHelpers.js

@@ -15,6 +15,8 @@ const getCategoryValueForTaskList = (key, task) => {
             return task.createTime;
         case 'assignee':
             return task.assignees;
+        case 'createdBy':
+            return task.createdBy;
         default:
             return undefined;
     }

package/lib/view/taskManager/taskListView/taskListViewHelpers.d.ts

@@ -3,7 +3,7 @@ import { Task } from '../../../entity/task/taskState';
 import { User } from '../../../entity/user/userState';
 import { ZeniDate } from '../../../zeniDayJS';
 import { TaskGroupKey } from './taskList';
-export type SubtaskSortKey = 'name' | 'status' | 'assignee' | 'tag';
+export type SubtaskSortKey = 'name' | 'status' | 'assignee' | 'tag' | 'priority' | 'dueDate' | 'timeSpent';
 export type SubtaskSortOrder = 'asc' | 'desc';
 export declare const getDueDateValueFromDueDateGroupId: (groupId: string) => ZeniDate;
 export declare const getTaskUpdates: (groupByKey: TaskGroupKey, groupId: string) => Partial<Task>;

package/lib/view/taskManager/taskListView/taskListViewHelpers.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sortSubtasks = exports.getTaskUpdates = exports.getDueDateValueFromDueDateGroupId = void 0;
+const formatMinutesToFromHHMM_1 = require("../../../commonStateTypes/fiscalYearHelpers/formatMinutesToFromHHMM");
 const zeniDayJS_1 = require("../../../zeniDayJS");
 const taskDetailSelector_1 = require("../taskDetailView/taskDetailSelector");
 const taskList_1 = require("./taskList");
@@ -68,6 +69,11 @@ const sortSubtasks = (subtasks, sortKey, sortOrder, userList, tagList) => {
         return acc;
     }, {});
     const unknownStatusRank = taskDetailSelector_1.allTaskStatus.length;
+    const priorityOrder = taskDetailSelector_1.allTaskPriority.reduce((acc, priority, index) => {
+        acc[priority.code] = index;
+        return acc;
+    }, {});
+    const unknownPriorityRank = taskDetailSelector_1.allTaskPriority.length;
     const cmpStr = (a, b) => a.localeCompare(b, undefined, { sensitivity: 'base' });
     const keyFn = (task) => {
         if (sortKey === 'name') {
@@ -94,6 +100,37 @@ const sortSubtasks = (subtasks, sortKey, sortOrder, userList, tagList) => {
             const tag = tagList.find((candidate) => candidate.tagId === firstTagId);
             return tag?.name ?? '';
         }
+        if (sortKey === 'priority') {
+            // Rank by the canonical order, not the code string: alphabetical would
+            // sort "high" before "urgent" and read as wrong to anyone scanning it.
+            return priorityOrder[task.priority?.code] ?? unknownPriorityRank;
+        }
+        if (sortKey === 'dueDate') {
+            // A task with no date is not "earliest", so undated rows belong at the
+            // bottom in BOTH directions. The comparator negates for 'desc', so one
+            // fixed sentinel would flip them to the top — the sentinel has to flip
+            // with the order to survive that negation.
+            // `dueDate` is already a ZeniDate (dayjs), so valueOf() is the epoch.
+            // An unparseable date yields NaN, and a NaN comparator leaves the array
+            // untouched -- the same silent failure the timeSpent branch guards.
+            // Treat it as undated rather than as a date.
+            const due = task.dueDate;
+            const epoch = due?.valueOf();
+            if (epoch == null || Number.isNaN(epoch)) {
+                return sortOrder === 'asc'
+                    ? Number.MAX_SAFE_INTEGER
+                    : Number.MIN_SAFE_INTEGER;
+            }
+            return epoch;
+        }
+        if (sortKey === 'timeSpent') {
+            // `timeSpent` is an "HHMM" STRING (no colon). Comparing it as text puts
+            // "1000" before "0900" only by luck of padding, and any malformed value
+            // makes the converter return NaN -- which a comparator turns into "no
+            // sort at all", silently. Coerce that to 0.
+            const minutes = (0, formatMinutesToFromHHMM_1.convertHHMMStrToMinutes)(task.timeSpent ?? '');
+            return Number.isFinite(minutes) ? minutes : 0;
+        }
         return '';
     };
     const copy = [...subtasks];

package/lib/view/taskManager/timeEntryView/epic/fetchTaskCategoriesEpic.d.ts

@@ -0,0 +1,18 @@
+import { ActionsObservable, StateObservable } from 'redux-observable';
+import { Observable } from 'rxjs';
+import { updateTaskCategories } from '../../../../entity/timeEntry/timeEntryReducer';
+import { RootState } from '../../../../rootStateTypes';
+import { ZeniAPI } from '../../../../zeniAPI';
+import { fetchTaskCategories, fetchTaskCategoriesFailure, fetchTaskCategoriesSuccess } from '../timeEntryViewReducer';
+export type ActionType = ReturnType<typeof fetchTaskCategories> | ReturnType<typeof fetchTaskCategoriesSuccess> | ReturnType<typeof fetchTaskCategoriesFailure> | ReturnType<typeof updateTaskCategories>;
+/**
+ * The 156-category catalog that fills the Category dropdown.
+ *
+ * `switchMap` here, unlike the entry epics: there is one catalog, so a second
+ * request supersedes the first rather than racing it.
+ *
+ * Zeni-only on the server (the billing marker is commercially sensitive), so
+ * a customer user gets a 401 — surfaced as Error rather than an empty list,
+ * because an empty catalog looks like "no categories exist".
+ */
+export declare const fetchTaskCategoriesEpic: (actions$: ActionsObservable<ActionType>, _state$: StateObservable<RootState>, zeniAPI: ZeniAPI) => Observable<ActionType>;

package/lib/view/taskManager/timeEntryView/epic/fetchTaskCategoriesEpic.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchTaskCategoriesEpic = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const operators_2 = require("rxjs/operators");
+const timeEntryReducer_1 = require("../../../../entity/timeEntry/timeEntryReducer");
+const responsePayload_1 = require("../../../../responsePayload");
+const timeEntryViewReducer_1 = require("../timeEntryViewReducer");
+/**
+ * The 156-category catalog that fills the Category dropdown.
+ *
+ * `switchMap` here, unlike the entry epics: there is one catalog, so a second
+ * request supersedes the first rather than racing it.
+ *
+ * Zeni-only on the server (the billing marker is commercially sensitive), so
+ * a customer user gets a 401 — surfaced as Error rather than an empty list,
+ * because an empty catalog looks like "no categories exist".
+ */
+const fetchTaskCategoriesEpic = (actions$, _state$, zeniAPI) => actions$.pipe((0, operators_1.filter)(timeEntryViewReducer_1.fetchTaskCategories.match), (0, operators_1.switchMap)(() => zeniAPI
+    .getJSON(`${zeniAPI.apiEndPoints.taskMicroServiceBaseUrl}/1.0/task-manager/task-categories`)
+    .pipe((0, operators_2.mergeMap)((response) => {
+    if ((0, responsePayload_1.isSuccessResponse)(response) && response.data != null) {
+        return (0, rxjs_1.of)((0, timeEntryReducer_1.updateTaskCategories)(response.data.task_categories ?? []), (0, timeEntryViewReducer_1.fetchTaskCategoriesSuccess)());
+    }
+    return (0, rxjs_1.of)((0, timeEntryViewReducer_1.fetchTaskCategoriesFailure)(response.status));
+}), (0, operators_1.catchError)((error) => (0, rxjs_1.of)((0, timeEntryViewReducer_1.fetchTaskCategoriesFailure)((0, responsePayload_1.createZeniAPIStatus)('Unexpected Error', 'Fetch task categories errored out' + JSON.stringify(error))))))));
+exports.fetchTaskCategoriesEpic = fetchTaskCategoriesEpic;

package/lib/view/taskManager/timeEntryView/epic/fetchTimeEntriesEpic.d.ts

@@ -0,0 +1,23 @@
+import { ActionsObservable, StateObservable } from 'redux-observable';
+import { Observable } from 'rxjs';
+import { updateTimeEntries } from '../../../../entity/timeEntry/timeEntryReducer';
+import { RootState } from '../../../../rootStateTypes';
+import { ZeniAPI } from '../../../../zeniAPI';
+import { fetchTimeEntriesForRange, fetchTimeEntriesForRangeFailure, fetchTimeEntriesForRangeSuccess, fetchTimeEntriesForTask, fetchTimeEntriesForTaskFailure, fetchTimeEntriesForTaskSuccess } from '../timeEntryViewReducer';
+export type ActionType = ReturnType<typeof fetchTimeEntriesForTask> | ReturnType<typeof fetchTimeEntriesForTaskSuccess> | ReturnType<typeof fetchTimeEntriesForTaskFailure> | ReturnType<typeof fetchTimeEntriesForRange> | ReturnType<typeof fetchTimeEntriesForRangeSuccess> | ReturnType<typeof fetchTimeEntriesForRangeFailure> | ReturnType<typeof updateTimeEntries>;
+/**
+ * Every entry on one task, all users — the task detail breakdown.
+ *
+ * `mergeMap`, not `switchMap`: a detail page and an expanded board row can
+ * ask for two different tasks at once, and cancelling the first would leave
+ * its breakdown stuck In-Progress forever.
+ */
+export declare const fetchTimeEntriesForTaskEpic: (actions$: ActionsObservable<ActionType>, state$: StateObservable<RootState>, zeniAPI: ZeniAPI) => Observable<ActionType>;
+/**
+ * One user's entries in an inclusive date range — the weekly timesheet.
+ *
+ * Needs the `is_deleted + user_id + entry_date` composite index (api #593).
+ * Without it the server returns 500, not an empty list, so the failure is
+ * surfaced rather than rendered as a blank week.
+ */
+export declare const fetchTimeEntriesForRangeEpic: (actions$: ActionsObservable<ActionType>, _state$: StateObservable<RootState>, zeniAPI: ZeniAPI) => Observable<ActionType>;

package/lib/view/taskManager/timeEntryView/epic/fetchTimeEntriesEpic.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchTimeEntriesForRangeEpic = exports.fetchTimeEntriesForTaskEpic = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const timeEntryReducer_1 = require("../../../../entity/timeEntry/timeEntryReducer");
+const responsePayload_1 = require("../../../../responsePayload");
+const timeEntryViewReducer_1 = require("../timeEntryViewReducer");
+const timeEntryViewState_1 = require("../timeEntryViewState");
+/**
+ * Every entry on one task, all users — the task detail breakdown.
+ *
+ * `mergeMap`, not `switchMap`: a detail page and an expanded board row can
+ * ask for two different tasks at once, and cancelling the first would leave
+ * its breakdown stuck In-Progress forever.
+ */
+const fetchTimeEntriesForTaskEpic = (actions$, state$, zeniAPI) => actions$.pipe((0, operators_1.filter)(timeEntryViewReducer_1.fetchTimeEntriesForTask.match), (0, operators_1.mergeMap)((action) => {
+    const { taskId, cacheOverride } = action.payload;
+    const cached = state$.value.timeEntryViewState.timeEntryIdsByTaskId[taskId];
+    const status = state$.value.timeEntryViewState.fetchStateByTaskId[taskId];
+    // The reducer has already flipped this request to In-Progress, so the
+    // guard reads the COMPLETED cache, never the fetch state -- a fetch
+    // state is not an in-flight signal.
+    if (cacheOverride !== true &&
+        cached != null &&
+        status?.fetchState === 'In-Progress') {
+        return (0, rxjs_1.of)((0, timeEntryViewReducer_1.fetchTimeEntriesForTaskSuccess)({ taskId, timeEntryIds: cached }));
+    }
+    return zeniAPI
+        .getJSON(`${zeniAPI.apiEndPoints.taskMicroServiceBaseUrl}/1.0/task-manager/tasks/${taskId}/time-entries`)
+        .pipe((0, operators_1.mergeMap)((response) => {
+        if ((0, responsePayload_1.isSuccessResponse)(response) && response.data != null) {
+            const entries = response.data.time_entries ?? [];
+            return (0, rxjs_1.of)((0, timeEntryReducer_1.updateTimeEntries)(entries), (0, timeEntryViewReducer_1.fetchTimeEntriesForTaskSuccess)({
+                taskId,
+                timeEntryIds: entries.map((entry) => entry.time_entry_id),
+            }));
+        }
+        return (0, rxjs_1.of)((0, timeEntryViewReducer_1.fetchTimeEntriesForTaskFailure)({ taskId, status: response.status }));
+    }), (0, operators_1.catchError)((error) => (0, rxjs_1.of)((0, timeEntryViewReducer_1.fetchTimeEntriesForTaskFailure)({
+        taskId,
+        status: (0, responsePayload_1.createZeniAPIStatus)('Unexpected Error', 'Fetch time entries for task errored out' +
+            JSON.stringify(error)),
+    }))));
+}));
+exports.fetchTimeEntriesForTaskEpic = fetchTimeEntriesForTaskEpic;
+/**
+ * One user's entries in an inclusive date range — the weekly timesheet.
+ *
+ * Needs the `is_deleted + user_id + entry_date` composite index (api #593).
+ * Without it the server returns 500, not an empty list, so the failure is
+ * surfaced rather than rendered as a blank week.
+ */
+const fetchTimeEntriesForRangeEpic = (actions$, _state$, zeniAPI) => actions$.pipe((0, operators_1.filter)(timeEntryViewReducer_1.fetchTimeEntriesForRange.match), (0, operators_1.mergeMap)((action) => {
+    const { userId, startDate, endDate } = action.payload;
+    const rangeKey = (0, timeEntryViewState_1.toTimeEntryRangeKey)(userId, startDate, endDate);
+    const query = `user_id=${encodeURIComponent(userId)}&start_date=${encodeURIComponent(startDate)}&end_date=${encodeURIComponent(endDate)}`;
+    return zeniAPI
+        .getJSON(`${zeniAPI.apiEndPoints.taskMicroServiceBaseUrl}/1.0/task-manager/time-entries?${query}`)
+        .pipe((0, operators_1.mergeMap)((response) => {
+        if ((0, responsePayload_1.isSuccessResponse)(response) && response.data != null) {
+            const entries = response.data.time_entries ?? [];
+            return (0, rxjs_1.of)((0, timeEntryReducer_1.updateTimeEntries)(entries), (0, timeEntryViewReducer_1.fetchTimeEntriesForRangeSuccess)({
+                rangeKey,
+                timeEntryIds: entries.map((entry) => entry.time_entry_id),
+            }));
+        }
+        return (0, rxjs_1.of)((0, timeEntryViewReducer_1.fetchTimeEntriesForRangeFailure)({
+            rangeKey,
+            status: response.status,
+        }));
+    }), (0, operators_1.catchError)((error) => (0, rxjs_1.of)((0, timeEntryViewReducer_1.fetchTimeEntriesForRangeFailure)({
+        rangeKey,
+        status: (0, responsePayload_1.createZeniAPIStatus)('Unexpected Error', 'Fetch time entries for range errored out' +
+            JSON.stringify(error)),
+    }))));
+}));
+exports.fetchTimeEntriesForRangeEpic = fetchTimeEntriesForRangeEpic;

package/lib/view/taskManager/timeEntryView/epic/writeTimeEntryEpic.d.ts

@@ -0,0 +1,23 @@
+import { ActionsObservable, StateObservable } from 'redux-observable';
+import { Observable } from 'rxjs';
+import { updateTaskTimeSpentMinutes } from '../../../../entity/task/taskReducer';
+import { removeTimeEntry, updateTimeEntries } from '../../../../entity/timeEntry/timeEntryReducer';
+import { RootState } from '../../../../rootStateTypes';
+import { ZeniAPI } from '../../../../zeniAPI';
+import { deleteTimeEntry, logTime, logTimeFailure, logTimeSuccess, timeEntryWriteFailure, timeEntryWriteSuccess, updateTimeEntryMinutes } from '../timeEntryViewReducer';
+export type ActionType = ReturnType<typeof logTime> | ReturnType<typeof logTimeSuccess> | ReturnType<typeof logTimeFailure> | ReturnType<typeof updateTimeEntryMinutes> | ReturnType<typeof deleteTimeEntry> | ReturnType<typeof timeEntryWriteSuccess> | ReturnType<typeof timeEntryWriteFailure> | ReturnType<typeof updateTimeEntries> | ReturnType<typeof removeTimeEntry> | ReturnType<typeof updateTaskTimeSpentMinutes>;
+/**
+ * Log time against a task.
+ *
+ * `mergeMap`, not `switchMap`: two rows on the board can be edited in quick
+ * succession and cancelling the first would silently drop that entry.
+ */
+export declare const logTimeEpic: (actions$: ActionsObservable<ActionType>, _state$: StateObservable<RootState>, zeniAPI: ZeniAPI) => Observable<ActionType>;
+/** Correct an entry's minutes. Owner, or a Zeni user as the admin path. */
+export declare const updateTimeEntryEpic: (actions$: ActionsObservable<ActionType>, _state$: StateObservable<RootState>, zeniAPI: ZeniAPI) => Observable<ActionType>;
+/**
+ * Soft delete. The row stays in Datastore for the audit trail but leaves the
+ * totals, so the client drops it from the store rather than keeping something
+ * every reader would then have to remember to filter.
+ */
+export declare const deleteTimeEntryEpic: (actions$: ActionsObservable<ActionType>, state$: StateObservable<RootState>, zeniAPI: ZeniAPI) => Observable<ActionType>;

package/lib/view/taskManager/timeEntryView/epic/writeTimeEntryEpic.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteTimeEntryEpic = exports.updateTimeEntryEpic = exports.logTimeEpic = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const taskReducer_1 = require("../../../../entity/task/taskReducer");
+const timeEntryReducer_1 = require("../../../../entity/timeEntry/timeEntryReducer");
+const timeEntrySelector_1 = require("../../../../entity/timeEntry/timeEntrySelector");
+const responsePayload_1 = require("../../../../responsePayload");
+const timeEntryViewReducer_1 = require("../timeEntryViewReducer");
+const unexpected = (what, error) => (0, responsePayload_1.createZeniAPIStatus)('Unexpected Error', `${what} errored out${JSON.stringify(error)}`);
+/**
+ * Log time against a task.
+ *
+ * `mergeMap`, not `switchMap`: two rows on the board can be edited in quick
+ * succession and cancelling the first would silently drop that entry.
+ */
+const logTimeEpic = (actions$, _state$, zeniAPI) => actions$.pipe((0, operators_1.filter)(timeEntryViewReducer_1.logTime.match), (0, operators_1.mergeMap)((action) => {
+    const { taskId, minutes, entryDate, source, identifier } = action.payload;
+    return zeniAPI
+        .postAndGetJSON(`${zeniAPI.apiEndPoints.taskMicroServiceBaseUrl}/1.0/task-manager/tasks/${taskId}/time-entries`, {
+        minutes,
+        entry_date: entryDate,
+        source,
+        // Sent only when the caller has one. The server treats it as the
+        // entity key, which is what makes a retried timer stop idempotent.
+        ...(identifier != null ? { identifier } : {}),
+    })
+        .pipe((0, operators_1.mergeMap)((response) => {
+        if ((0, responsePayload_1.isSuccessResponse)(response) && response.data != null) {
+            const { time_entry, task_time_spent_minutes } = response.data;
+            return (0, rxjs_1.of)((0, timeEntryReducer_1.updateTimeEntries)([time_entry]), 
+            // The board reads `Task.time_spent` per row, so it has to be
+            // told the new total; otherwise the row keeps the old number
+            // until something refetches the whole list.
+            (0, taskReducer_1.updateTaskTimeSpentMinutes)({
+                taskId,
+                minutes: task_time_spent_minutes ?? 0,
+            }), (0, timeEntryViewReducer_1.logTimeSuccess)({ taskId, timeEntryId: time_entry.time_entry_id }));
+        }
+        return (0, rxjs_1.of)((0, timeEntryViewReducer_1.logTimeFailure)({ taskId, status: response.status }));
+    }), (0, operators_1.catchError)((error) => (0, rxjs_1.of)((0, timeEntryViewReducer_1.logTimeFailure)({ taskId, status: unexpected('Log time', error) }))));
+}));
+exports.logTimeEpic = logTimeEpic;
+/** Correct an entry's minutes. Owner, or a Zeni user as the admin path. */
+const updateTimeEntryEpic = (actions$, _state$, zeniAPI) => actions$.pipe((0, operators_1.filter)(timeEntryViewReducer_1.updateTimeEntryMinutes.match), (0, operators_1.mergeMap)((action) => {
+    const { timeEntryId, minutes } = action.payload;
+    return zeniAPI
+        .putAndGetJSON(`${zeniAPI.apiEndPoints.taskMicroServiceBaseUrl}/1.0/task-manager/time-entries/${timeEntryId}`, { minutes })
+        .pipe((0, operators_1.mergeMap)((response) => {
+        if ((0, responsePayload_1.isSuccessResponse)(response) && response.data != null) {
+            return (0, rxjs_1.of)((0, timeEntryReducer_1.updateTimeEntries)([response.data.time_entry]), (0, timeEntryViewReducer_1.timeEntryWriteSuccess)({ timeEntryId }));
+        }
+        return (0, rxjs_1.of)((0, timeEntryViewReducer_1.timeEntryWriteFailure)({ timeEntryId, status: response.status }));
+    }), (0, operators_1.catchError)((error) => (0, rxjs_1.of)((0, timeEntryViewReducer_1.timeEntryWriteFailure)({
+        timeEntryId,
+        status: unexpected('Update time entry', error),
+    }))));
+}));
+exports.updateTimeEntryEpic = updateTimeEntryEpic;
+/**
+ * Soft delete. The row stays in Datastore for the audit trail but leaves the
+ * totals, so the client drops it from the store rather than keeping something
+ * every reader would then have to remember to filter.
+ */
+const deleteTimeEntryEpic = (actions$, state$, zeniAPI) => actions$.pipe((0, operators_1.filter)(timeEntryViewReducer_1.deleteTimeEntry.match), (0, operators_1.mergeMap)((action) => {
+    const timeEntryId = action.payload;
+    // Read the task id BEFORE the delete: the entry is about to leave the
+    // store, and the view slice needs to know which task's id list to prune.
+    const taskId = (0, timeEntrySelector_1.getTimeEntryById)(state$.value.timeEntryState, timeEntryId)?.taskId;
+    return zeniAPI
+        .deleteAndGetJSON(`${zeniAPI.apiEndPoints.taskMicroServiceBaseUrl}/1.0/task-manager/time-entries/${timeEntryId}`)
+        .pipe((0, operators_1.mergeMap)((response) => {
+        if ((0, responsePayload_1.isSuccessResponse)(response)) {
+            return (0, rxjs_1.of)((0, timeEntryReducer_1.removeTimeEntry)(timeEntryId), (0, timeEntryViewReducer_1.timeEntryWriteSuccess)({ timeEntryId, removedFromTaskId: taskId }));
+        }
+        return (0, rxjs_1.of)((0, timeEntryViewReducer_1.timeEntryWriteFailure)({ timeEntryId, status: response.status }));
+    }), (0, operators_1.catchError)((error) => (0, rxjs_1.of)((0, timeEntryViewReducer_1.timeEntryWriteFailure)({
+        timeEntryId,
+        status: unexpected('Delete time entry', error),
+    }))));
+}));
+exports.deleteTimeEntryEpic = deleteTimeEntryEpic;

package/lib/view/taskManager/timeEntryView/timeEntryViewPayload.d.ts

@@ -0,0 +1,27 @@
+import { ID } from '../../../commonStateTypes/common';
+import { TaskCategoryPayload, TimeEntryPayload } from '../../../entity/timeEntry/timeEntryPayload';
+import { ZeniAPIResponse } from '../../../responsePayload';
+export interface TimeEntriesPayload {
+    time_entries: TimeEntryPayload[];
+    total_minutes: number;
+}
+export interface TimeEntryRangePayload extends TimeEntriesPayload {
+    end_date: string;
+    start_date: string;
+    user_id: ID;
+}
+export interface TimeEntryWritePayload {
+    /** The ids whose `time_spent` the server recomputed. The client refreshes
+     *  exactly these board rows instead of the whole list. */
+    recomputed_task_ids: ID[];
+    time_entry: TimeEntryPayload;
+    task_time_spent_minutes?: number;
+}
+export interface TaskCategoriesPayload {
+    count: number;
+    task_categories: TaskCategoryPayload[];
+}
+export type TimeEntriesResponse = ZeniAPIResponse<TimeEntriesPayload>;
+export type TimeEntryRangeResponse = ZeniAPIResponse<TimeEntryRangePayload>;
+export type TimeEntryWriteResponse = ZeniAPIResponse<TimeEntryWritePayload>;
+export type TaskCategoriesResponse = ZeniAPIResponse<TaskCategoriesPayload>;

package/lib/view/taskManager/timeEntryView/timeEntryViewPayload.js

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

package/lib/view/taskManager/timeEntryView/timeEntryViewReducer.d.ts

@@ -0,0 +1,48 @@
+import { ID } from '../../../commonStateTypes/common';
+import { ZeniAPIStatus } from '../../../responsePayload';
+import { TimeEntryRangeKey, TimeEntryViewState } from './timeEntryViewState';
+export declare const initialState: TimeEntryViewState;
+export declare const fetchTimeEntriesForTask: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[taskId: string, cacheOverride?: any], {
+    taskId: string;
+    cacheOverride: any;
+}, "timeEntryView/fetchTimeEntriesForTask", never, never>, fetchTimeEntriesForTaskSuccess: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    taskId: ID;
+    timeEntryIds: ID[];
+}, "timeEntryView/fetchTimeEntriesForTaskSuccess">, fetchTimeEntriesForTaskFailure: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    status: ZeniAPIStatus;
+    taskId: ID;
+}, "timeEntryView/fetchTimeEntriesForTaskFailure">, fetchTimeEntriesForRange: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[userId: string, startDate: string, endDate: string, cacheOverride?: any], {
+    userId: string;
+    startDate: string;
+    endDate: string;
+    cacheOverride: any;
+}, "timeEntryView/fetchTimeEntriesForRange", never, never>, fetchTimeEntriesForRangeSuccess: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    rangeKey: TimeEntryRangeKey;
+    timeEntryIds: ID[];
+}, "timeEntryView/fetchTimeEntriesForRangeSuccess">, fetchTimeEntriesForRangeFailure: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    rangeKey: TimeEntryRangeKey;
+    status: ZeniAPIStatus;
+}, "timeEntryView/fetchTimeEntriesForRangeFailure">, logTime: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[taskId: string, minutes: number, entryDate: string, source?: "manual" | "timer" | undefined, identifier?: string | undefined], {
+    taskId: string;
+    minutes: number;
+    entryDate: string;
+    source: "manual" | "timer";
+    identifier: string | undefined;
+}, "timeEntryView/logTime", never, never>, logTimeSuccess: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    taskId: ID;
+    timeEntryId: ID;
+}, "timeEntryView/logTimeSuccess">, logTimeFailure: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    status: ZeniAPIStatus;
+    taskId: ID;
+}, "timeEntryView/logTimeFailure">, updateTimeEntryMinutes: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[timeEntryId: string, minutes: number], {
+    timeEntryId: string;
+    minutes: number;
+}, "timeEntryView/updateTimeEntryMinutes", never, never>, deleteTimeEntry: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "timeEntryView/deleteTimeEntry">, timeEntryWriteSuccess: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    timeEntryId: ID;
+    removedFromTaskId?: ID;
+}, "timeEntryView/timeEntryWriteSuccess">, timeEntryWriteFailure: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    status: ZeniAPIStatus;
+    timeEntryId: ID;
+}, "timeEntryView/timeEntryWriteFailure">, fetchTaskCategories: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"timeEntryView/fetchTaskCategories">, fetchTaskCategoriesSuccess: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"timeEntryView/fetchTaskCategoriesSuccess">, fetchTaskCategoriesFailure: import("@reduxjs/toolkit").ActionCreatorWithPayload<ZeniAPIStatus<Record<string, unknown>>, "timeEntryView/fetchTaskCategoriesFailure">;
+declare const _default: import("redux").Reducer<TimeEntryViewState>;
+export default _default;

package/lib/view/taskManager/timeEntryView/timeEntryViewReducer.js

@@ -0,0 +1,164 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchTaskCategoriesFailure = exports.fetchTaskCategoriesSuccess = exports.fetchTaskCategories = exports.timeEntryWriteFailure = exports.timeEntryWriteSuccess = exports.deleteTimeEntry = exports.updateTimeEntryMinutes = exports.logTimeFailure = exports.logTimeSuccess = exports.logTime = exports.fetchTimeEntriesForRangeFailure = exports.fetchTimeEntriesForRangeSuccess = exports.fetchTimeEntriesForRange = exports.fetchTimeEntriesForTaskFailure = exports.fetchTimeEntriesForTaskSuccess = exports.fetchTimeEntriesForTask = exports.initialState = void 0;
+const toolkit_1 = require("@reduxjs/toolkit");
+const rootActions_1 = require("../../../rootActions");
+const NOT_STARTED = { fetchState: 'Not-Started', error: undefined };
+exports.initialState = {
+    timeEntryIdsByTaskId: {},
+    fetchStateByTaskId: {},
+    timeEntryIdsByRangeKey: {},
+    fetchStateByRangeKey: {},
+    saveStateByTaskId: {},
+    saveStateByTimeEntryId: {},
+    taskCategoryFetchState: NOT_STARTED,
+};
+const timeEntryView = (0, toolkit_1.createSlice)({
+    name: 'timeEntryView',
+    initialState: exports.initialState,
+    reducers: {
+        fetchTimeEntriesForTask: {
+            prepare(taskId, cacheOverride = false) {
+                return { payload: { taskId, cacheOverride } };
+            },
+            reducer(draft, action) {
+                draft.fetchStateByTaskId[action.payload.taskId] = {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                };
+            },
+        },
+        fetchTimeEntriesForTaskSuccess(draft, action) {
+            const { taskId, timeEntryIds } = action.payload;
+            // Replaced, not merged: the server is authoritative about which entries
+            // a task has, and a merge would resurrect one that was just deleted.
+            draft.timeEntryIdsByTaskId[taskId] = timeEntryIds;
+            draft.fetchStateByTaskId[taskId] = {
+                fetchState: 'Completed',
+                error: undefined,
+            };
+        },
+        fetchTimeEntriesForTaskFailure(draft, action) {
+            draft.fetchStateByTaskId[action.payload.taskId] = {
+                fetchState: 'Error',
+                error: action.payload.status,
+            };
+        },
+        fetchTimeEntriesForRange: {
+            prepare(userId, startDate, endDate, cacheOverride = false) {
+                return { payload: { userId, startDate, endDate, cacheOverride } };
+            },
+            reducer(draft, action) {
+                const { userId, startDate, endDate } = action.payload;
+                draft.fetchStateByRangeKey[`${userId}_${startDate}_${endDate}`] = {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                };
+            },
+        },
+        fetchTimeEntriesForRangeSuccess(draft, action) {
+            const { rangeKey, timeEntryIds } = action.payload;
+            draft.timeEntryIdsByRangeKey[rangeKey] = timeEntryIds;
+            draft.fetchStateByRangeKey[rangeKey] = {
+                fetchState: 'Completed',
+                error: undefined,
+            };
+        },
+        fetchTimeEntriesForRangeFailure(draft, action) {
+            draft.fetchStateByRangeKey[action.payload.rangeKey] = {
+                fetchState: 'Error',
+                error: action.payload.status,
+            };
+        },
+        logTime: {
+            prepare(taskId, minutes, entryDate, source = 'manual', identifier) {
+                return { payload: { taskId, minutes, entryDate, source, identifier } };
+            },
+            reducer(draft, action) {
+                draft.saveStateByTaskId[action.payload.taskId] = {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                };
+            },
+        },
+        logTimeSuccess(draft, action) {
+            const { taskId, timeEntryId } = action.payload;
+            draft.saveStateByTaskId[taskId] = {
+                fetchState: 'Completed',
+                error: undefined,
+            };
+            const existing = draft.timeEntryIdsByTaskId[taskId] ?? [];
+            // Guarded against a duplicate id: a retried write with the same
+            // deterministic identifier returns the SAME entry, and pushing it twice
+            // would double it in the breakdown even though the server has one row.
+            if (!existing.includes(timeEntryId)) {
+                draft.timeEntryIdsByTaskId[taskId] = [...existing, timeEntryId];
+            }
+        },
+        logTimeFailure(draft, action) {
+            draft.saveStateByTaskId[action.payload.taskId] = {
+                fetchState: 'Error',
+                error: action.payload.status,
+            };
+        },
+        updateTimeEntryMinutes: {
+            prepare(timeEntryId, minutes) {
+                return { payload: { timeEntryId, minutes } };
+            },
+            reducer(draft, action) {
+                draft.saveStateByTimeEntryId[action.payload.timeEntryId] = {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                };
+            },
+        },
+        deleteTimeEntry(draft, action) {
+            draft.saveStateByTimeEntryId[action.payload] = {
+                fetchState: 'In-Progress',
+                error: undefined,
+            };
+        },
+        timeEntryWriteSuccess(draft, action) {
+            const { timeEntryId, removedFromTaskId } = action.payload;
+            draft.saveStateByTimeEntryId[timeEntryId] = {
+                fetchState: 'Completed',
+                error: undefined,
+            };
+            if (removedFromTaskId != null) {
+                draft.timeEntryIdsByTaskId[removedFromTaskId] = (draft.timeEntryIdsByTaskId[removedFromTaskId] ?? []).filter((candidate) => candidate !== timeEntryId);
+            }
+        },
+        timeEntryWriteFailure(draft, action) {
+            draft.saveStateByTimeEntryId[action.payload.timeEntryId] = {
+                fetchState: 'Error',
+                error: action.payload.status,
+            };
+        },
+        fetchTaskCategories(draft) {
+            draft.taskCategoryFetchState = {
+                fetchState: 'In-Progress',
+                error: undefined,
+            };
+        },
+        fetchTaskCategoriesSuccess(draft) {
+            draft.taskCategoryFetchState = {
+                fetchState: 'Completed',
+                error: undefined,
+            };
+        },
+        fetchTaskCategoriesFailure(draft, action) {
+            draft.taskCategoryFetchState = {
+                fetchState: 'Error',
+                error: action.payload,
+            };
+        },
+    },
+    extraReducers: (builder) => {
+        builder.addCase(rootActions_1.clearAll, (draft) => {
+            Object.assign(draft, exports.initialState);
+        });
+    },
+});
+_a = timeEntryView.actions, exports.fetchTimeEntriesForTask = _a.fetchTimeEntriesForTask, exports.fetchTimeEntriesForTaskSuccess = _a.fetchTimeEntriesForTaskSuccess, exports.fetchTimeEntriesForTaskFailure = _a.fetchTimeEntriesForTaskFailure, exports.fetchTimeEntriesForRange = _a.fetchTimeEntriesForRange, exports.fetchTimeEntriesForRangeSuccess = _a.fetchTimeEntriesForRangeSuccess, exports.fetchTimeEntriesForRangeFailure = _a.fetchTimeEntriesForRangeFailure, exports.logTime = _a.logTime, exports.logTimeSuccess = _a.logTimeSuccess, exports.logTimeFailure = _a.logTimeFailure, exports.updateTimeEntryMinutes = _a.updateTimeEntryMinutes, exports.deleteTimeEntry = _a.deleteTimeEntry, exports.timeEntryWriteSuccess = _a.timeEntryWriteSuccess, exports.timeEntryWriteFailure = _a.timeEntryWriteFailure, exports.fetchTaskCategories = _a.fetchTaskCategories, exports.fetchTaskCategoriesSuccess = _a.fetchTaskCategoriesSuccess, exports.fetchTaskCategoriesFailure = _a.fetchTaskCategoriesFailure;
+exports.default = timeEntryView.reducer;