From 33e76f263db026f4f59e674eaef8a3abebd548fe Mon Sep 17 00:00:00 2001 From: Ken Hibino Date: Wed, 30 Mar 2022 19:18:16 -0700 Subject: [PATCH] (ui): Add action buttons to AggregatingTasksTable --- ui/src/actions/tasksActions.ts | 334 +++++++++++++++++++- ui/src/api.ts | 18 +- ui/src/components/AggregatingTasksTable.tsx | 129 +++++++- ui/src/reducers/queuesReducer.ts | 176 +++++++++++ ui/src/reducers/tasksReducer.ts | 172 ++++++++++ 5 files changed, 811 insertions(+), 18 deletions(-) diff --git a/ui/src/actions/tasksActions.ts b/ui/src/actions/tasksActions.ts index de2b510..009ff5a 100644 --- a/ui/src/actions/tasksActions.ts +++ b/ui/src/actions/tasksActions.ts @@ -51,6 +51,14 @@ import { TaskInfo, getTaskInfo, deleteAllAggregatingTasks, + archiveAllAggregatingTasks, + runAllAggregatingTasks, + batchDeleteAggregatingTasks, + batchArchiveAggregatingTasks, + batchRunAggregatingTasks, + deleteAggregatingTask, + runAggregatingTask, + archiveAggregatingTask, } from "../api"; import { Dispatch } from "redux"; import { toErrorString, toErrorStringWithHttpStatus } from "../utils"; @@ -117,6 +125,17 @@ export const ARCHIVE_SCHEDULED_TASK_ERROR = "ARCHIVE_SCHEDULED_TASK_ERROR"; export const ARCHIVE_RETRY_TASK_BEGIN = "ARCHIVE_RETRY_TASK_BEGIN"; export const ARCHIVE_RETRY_TASK_SUCCESS = "ARCHIVE_RETRY_TASK_SUCCESS"; export const ARCHIVE_RETRY_TASK_ERROR = "ARCHIVE_RETRY_TASK_ERROR"; +export const RUN_AGGREGATING_TASK_BEGIN = "RUN_AGGREGATING_TASK_BEGIN"; +export const RUN_AGGREGATING_TASK_SUCCESS = "RUN_AGGREGATING_TASK_SUCCESS"; +export const RUN_AGGREGATING_TASK_ERROR = "RUN_AGGREGATING_TASK_ERROR"; +export const DELETE_AGGREGATING_TASK_BEGIN = "DELETE_AGGREGATING_TASK_BEGIN"; +export const DELETE_AGGREGATING_TASK_SUCCESS = + "DELETE_AGGREGATING_TASK_SUCCESS"; +export const DELETE_AGGREGATING_TASK_ERROR = "DELETE_AGGREGATING_TASK_ERROR"; +export const ARCHIVE_AGGREGATING_TASK_BEGIN = "ARCHIVE_AGGREGATING_TASK_BEGIN"; +export const ARCHIVE_AGGREGATING_TASK_SUCCESS = + "ARCHIVE_AGGREGATING_TASK_SUCCESS"; +export const ARCHIVE_AGGREGATING_TASK_ERROR = "ARCHIVE_AGGREGATING_TASK_ERROR"; export const BATCH_ARCHIVE_PENDING_TASKS_BEGIN = "BATCH_ARCHIVE_PENDING_TASKS_BEGIN"; export const BATCH_ARCHIVE_PENDING_TASKS_SUCCESS = @@ -1062,21 +1081,81 @@ interface DeleteAllCompletedTasksErrorAction { error: string; } +interface DeleteAggregatingTaskBeginAction { + type: typeof DELETE_AGGREGATING_TASK_BEGIN; + queue: string; + taskId: string; +} + +interface DeleteAggregatingTaskSuccessAction { + type: typeof DELETE_AGGREGATING_TASK_SUCCESS; + queue: string; + taskId: string; +} + +interface DeleteAggregatingTaskErrorAction { + type: typeof DELETE_AGGREGATING_TASK_ERROR; + queue: string; + taskId: string; + error: string; +} + +interface RunAggregatingTaskBeginAction { + type: typeof RUN_AGGREGATING_TASK_BEGIN; + queue: string; + taskId: string; +} + +interface RunAggregatingTaskSuccessAction { + type: typeof RUN_AGGREGATING_TASK_SUCCESS; + queue: string; + taskId: string; +} + +interface RunAggregatingTaskErrorAction { + type: typeof RUN_AGGREGATING_TASK_ERROR; + queue: string; + taskId: string; + error: string; +} + +interface ArchiveAggregatingTaskBeginAction { + type: typeof ARCHIVE_AGGREGATING_TASK_BEGIN; + queue: string; + taskId: string; +} + +interface ArchiveAggregatingTaskSuccessAction { + type: typeof ARCHIVE_AGGREGATING_TASK_SUCCESS; + queue: string; + taskId: string; +} + +interface ArchiveAggregatingTaskErrorAction { + type: typeof ARCHIVE_AGGREGATING_TASK_ERROR; + queue: string; + taskId: string; + error: string; +} + interface BatchDeleteAggregatingTasksBeginAction { type: typeof BATCH_DELETE_AGGREGATING_TASKS_BEGIN; queue: string; + group: string; taskIds: string[]; } interface BatchDeleteAggregatingTasksSuccessAction { type: typeof BATCH_DELETE_AGGREGATING_TASKS_SUCCESS; queue: string; + group: string; payload: BatchDeleteTasksResponse; } interface BatchDeleteAggregatingTasksErrorAction { type: typeof BATCH_DELETE_AGGREGATING_TASKS_ERROR; queue: string; + group: string; taskIds: string[]; error: string; } @@ -1084,18 +1163,21 @@ interface BatchDeleteAggregatingTasksErrorAction { interface BatchRunAggregatingTasksBeginAction { type: typeof BATCH_RUN_AGGREGATING_TASKS_BEGIN; queue: string; + group: string; taskIds: string[]; } interface BatchRunAggregatingTasksSuccessAction { type: typeof BATCH_RUN_AGGREGATING_TASKS_SUCCESS; queue: string; + group: string; payload: BatchRunTasksResponse; } interface BatchRunAggregatingTasksErrorAction { type: typeof BATCH_RUN_AGGREGATING_TASKS_ERROR; queue: string; + group: string; taskIds: string[]; error: string; } @@ -1108,6 +1190,7 @@ interface RunAllAggregatingTasksBeginAction { interface RunAllAggregatingTasksSuccessAction { type: typeof RUN_ALL_AGGREGATING_TASKS_SUCCESS; + scheduled: number; queue: string; group: string; } @@ -1151,6 +1234,7 @@ interface ArchiveAllAggregatingTasksSuccessAction { type: typeof ARCHIVE_ALL_AGGREGATING_TASKS_SUCCESS; queue: string; group: string; + archived: number; } interface ArchiveAllAggregatingTasksErrorAction { @@ -1331,7 +1415,16 @@ export type TasksActionTypes = | ArchiveAllAggregatingTasksErrorAction | DeleteAllAggregatingTasksBeginAction | DeleteAllAggregatingTasksSuccessAction - | DeleteAllAggregatingTasksErrorAction; + | DeleteAllAggregatingTasksErrorAction + | DeleteAggregatingTaskBeginAction + | DeleteAggregatingTaskSuccessAction + | DeleteAggregatingTaskErrorAction + | RunAggregatingTaskBeginAction + | RunAggregatingTaskSuccessAction + | RunAggregatingTaskErrorAction + | ArchiveAggregatingTaskBeginAction + | ArchiveAggregatingTaskSuccessAction + | ArchiveAggregatingTaskErrorAction; export function getTaskInfoAsync(qname: string, id: string) { return async (dispatch: Dispatch) => { @@ -1913,6 +2006,121 @@ export function batchArchivePendingTasksAsync( }; } +export function deleteAggregatingTaskAsync( + queue: string, + group: string, + taskId: string +) { + return async (dispatch: Dispatch) => { + dispatch({ type: DELETE_AGGREGATING_TASK_BEGIN, queue, taskId }); + try { + await deleteAggregatingTask(queue, group, taskId); + dispatch({ type: DELETE_AGGREGATING_TASK_SUCCESS, queue, taskId }); + } catch (error) { + console.error( + "deleteAggregatingTaskAsync: ", + toErrorStringWithHttpStatus(error) + ); + dispatch({ + type: DELETE_AGGREGATING_TASK_ERROR, + error: toErrorString(error), + queue, + taskId, + }); + } + }; +} + +export function runAggregatingTaskAsync( + queue: string, + group: string, + taskId: string +) { + return async (dispatch: Dispatch) => { + dispatch({ type: RUN_AGGREGATING_TASK_BEGIN, queue, taskId }); + try { + await runAggregatingTask(queue, group, taskId); + dispatch({ type: RUN_AGGREGATING_TASK_SUCCESS, queue, taskId }); + } catch (error) { + console.error( + "runAggregatingTaskAsync: ", + toErrorStringWithHttpStatus(error) + ); + dispatch({ + type: RUN_AGGREGATING_TASK_ERROR, + error: toErrorString(error), + queue, + taskId, + }); + } + }; +} + +export function archiveAggregatingTaskAsync( + queue: string, + group: string, + taskId: string +) { + return async (dispatch: Dispatch) => { + dispatch({ type: ARCHIVE_AGGREGATING_TASK_BEGIN, queue, taskId }); + try { + await archiveAggregatingTask(queue, group, taskId); + dispatch({ type: ARCHIVE_AGGREGATING_TASK_SUCCESS, queue, taskId }); + } catch (error) { + console.error( + "archiveAggregatingTaskAsync: ", + toErrorStringWithHttpStatus(error) + ); + dispatch({ + type: ARCHIVE_AGGREGATING_TASK_ERROR, + error: toErrorString(error), + queue, + taskId, + }); + } + }; +} + +export function batchArchiveAggregatingTasksAsync( + queue: string, + group: string, + taskIds: string[] +) { + return async (dispatch: Dispatch) => { + dispatch({ + type: BATCH_ARCHIVE_AGGREGATING_TASKS_BEGIN, + queue, + group, + taskIds, + }); + try { + const response = await batchArchiveAggregatingTasks( + queue, + group, + taskIds + ); + dispatch({ + type: BATCH_ARCHIVE_AGGREGATING_TASKS_SUCCESS, + payload: response, + queue, + group, + }); + } catch (error) { + console.error( + "batchArchiveAggregatingTasksAsync: ", + toErrorStringWithHttpStatus(error) + ); + dispatch({ + type: BATCH_ARCHIVE_AGGREGATING_TASKS_ERROR, + error: toErrorString(error), + queue, + group, + taskIds, + }); + } + }; +} + export function archiveAllPendingTasksAsync(queue: string) { return async (dispatch: Dispatch) => { dispatch({ type: ARCHIVE_ALL_PENDING_TASKS_BEGIN, queue }); @@ -2047,6 +2255,58 @@ export function archiveAllScheduledTasksAsync(queue: string) { }; } +export function archiveAllAggregatingTasksAsync(queue: string, group: string) { + return async (dispatch: Dispatch) => { + dispatch({ type: ARCHIVE_ALL_AGGREGATING_TASKS_BEGIN, queue, group }); + try { + const response = await archiveAllAggregatingTasks(queue, group); + dispatch({ + type: ARCHIVE_ALL_AGGREGATING_TASKS_SUCCESS, + archived: response.archived, + queue, + group, + }); + } catch (error) { + console.error( + "archiveAllAggregatingTasksAsync: ", + toErrorStringWithHttpStatus(error) + ); + dispatch({ + type: ARCHIVE_ALL_AGGREGATING_TASKS_ERROR, + error: toErrorString(error), + queue, + group, + }); + } + }; +} + +export function runAllAggregatingTasksAsync(queue: string, group: string) { + return async (dispatch: Dispatch) => { + dispatch({ type: RUN_ALL_AGGREGATING_TASKS_BEGIN, queue, group }); + try { + const resp = await runAllAggregatingTasks(queue, group); + dispatch({ + type: RUN_ALL_AGGREGATING_TASKS_SUCCESS, + scheduled: resp.scheduled, + queue, + group, + }); + } catch (error) { + console.error( + "runAllAggregatingTasksAsync: ", + toErrorStringWithHttpStatus(error) + ); + dispatch({ + type: RUN_ALL_AGGREGATING_TASKS_ERROR, + error: toErrorString(error), + queue, + group, + }); + } + }; +} + export function deleteRetryTaskAsync(queue: string, taskId: string) { return async (dispatch: Dispatch) => { dispatch({ type: DELETE_RETRY_TASK_BEGIN, queue, taskId }); @@ -2118,6 +2378,42 @@ export function batchRunRetryTasksAsync(queue: string, taskIds: string[]) { }; } +export function batchRunAggregatingTasksAsync( + queue: string, + group: string, + taskIds: string[] +) { + return async (dispatch: Dispatch) => { + dispatch({ + type: BATCH_RUN_AGGREGATING_TASKS_BEGIN, + queue, + group, + taskIds, + }); + try { + const response = await batchRunAggregatingTasks(queue, group, taskIds); + dispatch({ + type: BATCH_RUN_AGGREGATING_TASKS_SUCCESS, + payload: response, + queue, + group, + }); + } catch (error) { + console.error( + "batchRunAggregatingTasksAsync: ", + toErrorStringWithHttpStatus(error) + ); + dispatch({ + type: BATCH_RUN_AGGREGATING_TASKS_ERROR, + error: toErrorString(error), + queue, + group, + taskIds, + }); + } + }; +} + export function batchArchiveRetryTasksAsync(queue: string, taskIds: string[]) { return async (dispatch: Dispatch) => { dispatch({ type: BATCH_ARCHIVE_RETRY_TASKS_BEGIN, queue, taskIds }); @@ -2374,6 +2670,42 @@ export function batchDeleteCompletedTasksAsync( }; } +export function batchDeleteAggregatingTasksAsync( + queue: string, + group: string, + taskIds: string[] +) { + return async (dispatch: Dispatch) => { + dispatch({ + type: BATCH_DELETE_AGGREGATING_TASKS_BEGIN, + queue, + group, + taskIds, + }); + try { + const response = await batchDeleteAggregatingTasks(queue, group, taskIds); + dispatch({ + type: BATCH_DELETE_AGGREGATING_TASKS_SUCCESS, + payload: response, + queue, + group, + }); + } catch (error) { + console.error( + "batchDeleteAggregatingTasksAsync: ", + toErrorStringWithHttpStatus(error) + ); + dispatch({ + type: BATCH_DELETE_AGGREGATING_TASKS_ERROR, + error: toErrorString(error), + queue, + group, + taskIds, + }); + } + }; +} + export function deleteAllCompletedTasksAsync(queue: string) { return async (dispatch: Dispatch) => { dispatch({ type: DELETE_ALL_COMPLETED_TASKS_BEGIN, queue }); diff --git a/ui/src/api.ts b/ui/src/api.ts index b13cb2d..a2c9df4 100644 --- a/ui/src/api.ts +++ b/ui/src/api.ts @@ -54,6 +54,14 @@ export interface DeleteAllTasksResponse { deleted: number; } +export interface ArchiveAllTasksResponse { + archived: number; +} + +export interface RunAllTasksResponse { + scheduled: number; +} + export interface ListQueueStatsResponse { stats: { [qname: string]: DailyStat[] }; } @@ -674,11 +682,12 @@ export async function batchRunAggregatingTasks( export async function runAllAggregatingTasks( qname: string, gname: string -): Promise { - await axios({ +): Promise { + const resp = await axios({ method: "post", url: `${getBaseUrl()}/queues/${qname}/groups/${gname}/aggregating_tasks:run_all`, }); + return resp.data; } export async function archiveAggregatingTask( @@ -710,11 +719,12 @@ export async function batchArchiveAggregatingTasks( export async function archiveAllAggregatingTasks( qname: string, gname: string -): Promise { - await axios({ +): Promise { + const resp = await axios({ method: "post", url: `${getBaseUrl()}/queues/${qname}/groups/${gname}/aggregating_tasks:archive_all`, }); + return resp.data; } export async function runScheduledTask( diff --git a/ui/src/components/AggregatingTasksTable.tsx b/ui/src/components/AggregatingTasksTable.tsx index 9fbe216..75b3b88 100644 --- a/ui/src/components/AggregatingTasksTable.tsx +++ b/ui/src/components/AggregatingTasksTable.tsx @@ -16,6 +16,7 @@ import Tooltip from "@material-ui/core/Tooltip"; import ArchiveIcon from "@material-ui/icons/Archive"; import DeleteIcon from "@material-ui/icons/Delete"; import MoreHorizIcon from "@material-ui/icons/MoreHoriz"; +import PlayArrowIcon from "@material-ui/icons/PlayArrow"; import FileCopyOutlinedIcon from "@material-ui/icons/FileCopyOutlined"; import Alert from "@material-ui/lab/Alert"; import AlertTitle from "@material-ui/lab/AlertTitle"; @@ -37,6 +38,14 @@ import TablePaginationActions, { import { listAggregatingTasksAsync, deleteAllAggregatingTasksAsync, + archiveAllAggregatingTasksAsync, + runAllAggregatingTasksAsync, + batchDeleteAggregatingTasksAsync, + batchRunAggregatingTasksAsync, + batchArchiveAggregatingTasksAsync, + deleteAggregatingTaskAsync, + runAggregatingTaskAsync, + archiveAggregatingTaskAsync, } from "../actions/tasksActions"; import { taskRowsPerPageChange } from "../actions/settingsActions"; @@ -67,6 +76,8 @@ function mapStateToProps(state: AppState) { groups: state.groups.data, groupsError: state.groups.error, loading: state.tasks.aggregatingTasks.loading, + allActionPending: state.tasks.aggregatingTasks.allActionPending, + batchActionPending: state.tasks.aggregatingTasks.batchActionPending, error: state.tasks.aggregatingTasks.error, group: state.tasks.aggregatingTasks.group, tasks: state.tasks.aggregatingTasks.data, @@ -79,6 +90,14 @@ const mapDispatchToProps = { listGroupsAsync, listAggregatingTasksAsync, deleteAllAggregatingTasksAsync, + archiveAllAggregatingTasksAsync, + runAllAggregatingTasksAsync, + batchDeleteAggregatingTasksAsync, + batchRunAggregatingTasksAsync, + batchArchiveAggregatingTasksAsync, + deleteAggregatingTaskAsync, + runAggregatingTaskAsync, + archiveAggregatingTaskAsync, taskRowsPerPageChange, }; @@ -142,6 +161,51 @@ function AggregatingTasksTable( props.deleteAllAggregatingTasksAsync(queue, selectedGroup.group); }; + const handleArchiveAllClick = () => { + if (selectedGroup === null) { + return; + } + props.archiveAllAggregatingTasksAsync(queue, selectedGroup.group); + }; + + const handleRunAllClick = () => { + if (selectedGroup === null) { + return; + } + props.runAllAggregatingTasksAsync(queue, selectedGroup.group); + }; + + const handleBatchRunClick = () => { + if (selectedGroup === null) { + return; + } + props + .batchRunAggregatingTasksAsync(queue, selectedGroup.group, selectedIds) + .then(() => setSelectedIds([])); + }; + + const handleBatchDeleteClick = () => { + if (selectedGroup === null) { + return; + } + props + .batchDeleteAggregatingTasksAsync(queue, selectedGroup.group, selectedIds) + .then(() => setSelectedIds([])); + }; + + const handleBatchArchiveClick = () => { + if (selectedGroup === null) { + return; + } + props + .batchArchiveAggregatingTasksAsync( + queue, + selectedGroup.group, + selectedIds + ) + .then(() => setSelectedIds([])); + }; + const fetchGroups = useCallback(() => { listGroupsAsync(queue); }, [listGroupsAsync, queue]); @@ -192,26 +256,37 @@ function AggregatingTasksTable( { tooltip: "Delete", icon: , - onClick: () => {}, // TODO: handleBatchDeleteClick, - disabled: false, //TODO: props.batchActionPending, + onClick: handleBatchDeleteClick, + disabled: props.batchActionPending, }, { tooltip: "Archive", icon: , - onClick: () => {}, //TODO: handleBatchArchiveClick, - disabled: false, //TODO: props.batchActionPending, + onClick: handleBatchArchiveClick, + disabled: props.batchActionPending, + }, + { + tooltip: "Run", + icon: , + onClick: handleBatchRunClick, + disabled: props.batchActionPending, }, ]} menuItemActions={[ { label: "Delete All", onClick: handleDeleteAllClick, - disabled: false, // TODO: props.allActionPending, + disabled: props.allActionPending, }, { label: "Archive All", - onClick: () => {}, // TODO: handleArchiveAllClick, - disabled: false, // TODO: props.allActionPending, + onClick: handleArchiveAllClick, + disabled: props.allActionPending, + }, + { + label: "Run All", + onClick: handleRunAllClick, + disabled: props.allActionPending, }, ]} /> @@ -276,13 +351,30 @@ function AggregatingTasksTable( ); } }} - allActionPending={false /* TODO: props.allActionPending */} - onDeleteClick={ - () => {} - //TODO: props.deletePendingTaskAsync(queue, task.id) - } + allActionPending={props.allActionPending} + onDeleteClick={() => { + if (selectedGroup === null) return; + props.deleteAggregatingTaskAsync( + queue, + selectedGroup.group, + task.id + ); + }} onArchiveClick={() => { - // TODO: props.archivePendingTaskAsync(queue, task.id); + if (selectedGroup === null) return; + props.archiveAggregatingTaskAsync( + queue, + selectedGroup.group, + task.id + ); + }} + onRunClick={() => { + if (selectedGroup === null) return; + props.runAggregatingTaskAsync( + queue, + selectedGroup.group, + task.id + ); }} onActionCellEnter={() => setActiveTaskId(task.id)} onActionCellLeave={() => setActiveTaskId("")} @@ -360,6 +452,7 @@ interface RowProps { onSelectChange: (checked: boolean) => void; onDeleteClick: () => void; onArchiveClick: () => void; + onRunClick: () => void; allActionPending: boolean; showActions: boolean; onActionCellEnter: () => void; @@ -446,6 +539,16 @@ function Row(props: RowProps) { + + + + + ) : ( diff --git a/ui/src/reducers/queuesReducer.ts b/ui/src/reducers/queuesReducer.ts index ea1dcf7..a8f8ed9 100644 --- a/ui/src/reducers/queuesReducer.ts +++ b/ui/src/reducers/queuesReducer.ts @@ -53,6 +53,15 @@ import { DELETE_COMPLETED_TASK_SUCCESS, DELETE_ALL_COMPLETED_TASKS_SUCCESS, BATCH_DELETE_COMPLETED_TASKS_SUCCESS, + DELETE_ALL_AGGREGATING_TASKS_SUCCESS, + ARCHIVE_ALL_AGGREGATING_TASKS_SUCCESS, + RUN_ALL_AGGREGATING_TASKS_SUCCESS, + BATCH_DELETE_AGGREGATING_TASKS_SUCCESS, + BATCH_RUN_AGGREGATING_TASKS_SUCCESS, + BATCH_ARCHIVE_AGGREGATING_TASKS_SUCCESS, + DELETE_AGGREGATING_TASK_SUCCESS, + RUN_AGGREGATING_TASK_SUCCESS, + ARCHIVE_AGGREGATING_TASK_SUCCESS, } from "../actions/tasksActions"; import { Queue } from "../api"; @@ -175,6 +184,23 @@ function queuesReducer( return { ...state, data: newData }; } + case RUN_AGGREGATING_TASK_SUCCESS: { + const newData = state.data.map((queueInfo) => { + if (queueInfo.name !== action.queue) { + return queueInfo; + } + return { + ...queueInfo, + currentStats: { + ...queueInfo.currentStats, + pending: queueInfo.currentStats.pending + 1, + aggregating: queueInfo.currentStats.aggregating - 1, + }, + }; + }); + return { ...state, data: newData }; + } + case RUN_SCHEDULED_TASK_SUCCESS: { const newData = state.data.map((queueInfo) => { if (queueInfo.name !== action.queue) { @@ -243,6 +269,23 @@ function queuesReducer( return { ...state, data: newData }; } + case ARCHIVE_AGGREGATING_TASK_SUCCESS: { + const newData = state.data.map((queueInfo) => { + if (queueInfo.name !== action.queue) { + return queueInfo; + } + return { + ...queueInfo, + currentStats: { + ...queueInfo.currentStats, + archived: queueInfo.currentStats.archived + 1, + aggregating: queueInfo.currentStats.aggregating - 1, + }, + }; + }); + return { ...state, data: newData }; + } + case ARCHIVE_SCHEDULED_TASK_SUCCESS: { const newData = state.data.map((queueInfo) => { if (queueInfo.name !== action.queue) { @@ -311,6 +354,23 @@ function queuesReducer( return { ...state, data: newData }; } + case DELETE_AGGREGATING_TASK_SUCCESS: { + const newData = state.data.map((queueInfo) => { + if (queueInfo.name !== action.queue) { + return queueInfo; + } + return { + ...queueInfo, + currentStats: { + ...queueInfo.currentStats, + size: queueInfo.currentStats.size - 1, + aggregating: queueInfo.currentStats.aggregating - 1, + }, + }; + }); + return { ...state, data: newData }; + } + case BATCH_ARCHIVE_PENDING_TASKS_SUCCESS: { const newData = state.data.map((queueInfo) => { if (queueInfo.name !== action.queue) { @@ -370,6 +430,24 @@ function queuesReducer( return { ...state, data: newData }; } + case ARCHIVE_ALL_AGGREGATING_TASKS_SUCCESS: { + const newData = state.data.map((queueInfo) => { + if (queueInfo.name !== action.queue) { + return queueInfo; + } + return { + ...queueInfo, + currentStats: { + ...queueInfo.currentStats, + groups: queueInfo.currentStats.groups - 1, + archived: queueInfo.currentStats.archived + action.archived, + aggregating: queueInfo.currentStats.aggregating - action.archived, + }, + }; + }); + return { ...state, data: newData }; + } + case DELETE_ALL_PENDING_TASKS_SUCCESS: { const newData = state.data.map((queueInfo) => { if (queueInfo.name !== action.queue) { @@ -449,6 +527,24 @@ function queuesReducer( return { ...state, data: newData }; } + case RUN_ALL_AGGREGATING_TASKS_SUCCESS: { + const newData = state.data.map((queueInfo) => { + if (queueInfo.name !== action.queue) { + return queueInfo; + } + return { + ...queueInfo, + currentStats: { + ...queueInfo.currentStats, + groups: queueInfo.currentStats.groups - 1, + pending: queueInfo.currentStats.pending + action.scheduled, + aggregating: queueInfo.currentStats.aggregating - action.scheduled, + }, + }; + }); + return { ...state, data: newData }; + } + case RUN_ALL_SCHEDULED_TASKS_SUCCESS: { const newData = state.data.map((queueInfo) => { if (queueInfo.name !== action.queue) { @@ -486,6 +582,24 @@ function queuesReducer( return { ...state, data: newData }; } + case DELETE_ALL_AGGREGATING_TASKS_SUCCESS: { + const newData = state.data.map((queueInfo) => { + if (queueInfo.name !== action.queue) { + return queueInfo; + } + return { + ...queueInfo, + currentStats: { + ...queueInfo.currentStats, + size: queueInfo.currentStats.size - action.deleted, + groups: queueInfo.currentStats.groups - 1, + aggregating: queueInfo.currentStats.aggregating - action.deleted, + }, + }; + }); + return { ...state, data: newData }; + } + case DELETE_ALL_SCHEDULED_TASKS_SUCCESS: { const newData = state.data.map((queueInfo) => { if (queueInfo.name !== action.queue) { @@ -579,6 +693,68 @@ function queuesReducer( return { ...state, data: newData }; } + case BATCH_RUN_AGGREGATING_TASKS_SUCCESS: { + const newData = state.data.map((queueInfo) => { + if (queueInfo.name !== action.queue) { + return queueInfo; + } + return { + ...queueInfo, + currentStats: { + ...queueInfo.currentStats, + pending: + queueInfo.currentStats.pending + + action.payload.pending_ids.length, + aggregating: + queueInfo.currentStats.aggregating - + action.payload.pending_ids.length, + }, + }; + }); + return { ...state, data: newData }; + } + + case BATCH_ARCHIVE_AGGREGATING_TASKS_SUCCESS: { + const newData = state.data.map((queueInfo) => { + if (queueInfo.name !== action.queue) { + return queueInfo; + } + return { + ...queueInfo, + currentStats: { + ...queueInfo.currentStats, + archived: + queueInfo.currentStats.archived + + action.payload.archived_ids.length, + aggregating: + queueInfo.currentStats.aggregating - + action.payload.archived_ids.length, + }, + }; + }); + return { ...state, data: newData }; + } + + case BATCH_DELETE_AGGREGATING_TASKS_SUCCESS: { + const newData = state.data.map((queueInfo) => { + if (queueInfo.name !== action.queue) { + return queueInfo; + } + return { + ...queueInfo, + currentStats: { + ...queueInfo.currentStats, + size: + queueInfo.currentStats.size - action.payload.deleted_ids.length, + aggregating: + queueInfo.currentStats.aggregating - + action.payload.deleted_ids.length, + }, + }; + }); + return { ...state, data: newData }; + } + case RUN_ALL_RETRY_TASKS_SUCCESS: { const newData = state.data.map((queueInfo) => { if (queueInfo.name !== action.queue) { diff --git a/ui/src/reducers/tasksReducer.ts b/ui/src/reducers/tasksReducer.ts index 301db04..801ad55 100644 --- a/ui/src/reducers/tasksReducer.ts +++ b/ui/src/reducers/tasksReducer.ts @@ -135,6 +135,30 @@ import { DELETE_ALL_AGGREGATING_TASKS_BEGIN, DELETE_ALL_AGGREGATING_TASKS_SUCCESS, DELETE_ALL_AGGREGATING_TASKS_ERROR, + ARCHIVE_ALL_AGGREGATING_TASKS_BEGIN, + ARCHIVE_ALL_AGGREGATING_TASKS_SUCCESS, + ARCHIVE_ALL_AGGREGATING_TASKS_ERROR, + RUN_ALL_AGGREGATING_TASKS_BEGIN, + RUN_ALL_AGGREGATING_TASKS_SUCCESS, + RUN_ALL_AGGREGATING_TASKS_ERROR, + BATCH_ARCHIVE_AGGREGATING_TASKS_BEGIN, + BATCH_RUN_AGGREGATING_TASKS_BEGIN, + BATCH_DELETE_AGGREGATING_TASKS_BEGIN, + BATCH_RUN_AGGREGATING_TASKS_ERROR, + BATCH_ARCHIVE_AGGREGATING_TASKS_ERROR, + BATCH_DELETE_AGGREGATING_TASKS_ERROR, + BATCH_DELETE_AGGREGATING_TASKS_SUCCESS, + BATCH_RUN_AGGREGATING_TASKS_SUCCESS, + BATCH_ARCHIVE_AGGREGATING_TASKS_SUCCESS, + RUN_AGGREGATING_TASK_BEGIN, + ARCHIVE_AGGREGATING_TASK_BEGIN, + DELETE_AGGREGATING_TASK_BEGIN, + RUN_AGGREGATING_TASK_ERROR, + ARCHIVE_AGGREGATING_TASK_ERROR, + DELETE_AGGREGATING_TASK_ERROR, + RUN_AGGREGATING_TASK_SUCCESS, + ARCHIVE_AGGREGATING_TASK_SUCCESS, + DELETE_AGGREGATING_TASK_SUCCESS, } from "../actions/tasksActions"; import { TaskInfo } from "../api"; @@ -1105,6 +1129,148 @@ function tasksReducer( }, }; + case RUN_AGGREGATING_TASK_BEGIN: + case ARCHIVE_AGGREGATING_TASK_BEGIN: + case DELETE_AGGREGATING_TASK_BEGIN: + return { + ...state, + aggregatingTasks: { + ...state.aggregatingTasks, + data: state.aggregatingTasks.data.map((task) => { + if (task.id !== action.taskId) { + return task; + } + return { ...task, requestPending: true }; + }), + }, + }; + + case RUN_AGGREGATING_TASK_ERROR: + case ARCHIVE_AGGREGATING_TASK_ERROR: + case DELETE_AGGREGATING_TASK_ERROR: + return { + ...state, + aggregatingTasks: { + ...state.aggregatingTasks, + data: state.aggregatingTasks.data.map((task) => { + if (task.id !== action.taskId) { + return task; + } + return { ...task, requestPending: false }; + }), + }, + }; + + case RUN_AGGREGATING_TASK_SUCCESS: + case ARCHIVE_AGGREGATING_TASK_SUCCESS: + case DELETE_AGGREGATING_TASK_SUCCESS: + return { + ...state, + aggregatingTasks: { + ...state.aggregatingTasks, + data: state.aggregatingTasks.data.filter( + (task) => task.id !== action.taskId + ), + }, + }; + + case BATCH_RUN_AGGREGATING_TASKS_BEGIN: + case BATCH_ARCHIVE_AGGREGATING_TASKS_BEGIN: + case BATCH_DELETE_AGGREGATING_TASKS_BEGIN: + if (action.group !== state.aggregatingTasks.group) { + return state; + } + return { + ...state, + aggregatingTasks: { + ...state.aggregatingTasks, + batchActionPending: true, + data: state.aggregatingTasks.data.map((task) => { + if (!action.taskIds.includes(task.id)) { + return task; + } + return { + ...task, + requestPending: true, + }; + }), + }, + }; + + case BATCH_RUN_AGGREGATING_TASKS_ERROR: + case BATCH_ARCHIVE_AGGREGATING_TASKS_ERROR: + case BATCH_DELETE_AGGREGATING_TASKS_ERROR: + if (action.group !== state.aggregatingTasks.group) { + return state; + } + return { + ...state, + aggregatingTasks: { + ...state.aggregatingTasks, + batchActionPending: false, + data: state.scheduledTasks.data.map((task) => { + if (!action.taskIds.includes(task.id)) { + return task; + } + return { + ...task, + requestPending: false, + }; + }), + }, + }; + + case BATCH_DELETE_AGGREGATING_TASKS_SUCCESS: { + if (action.group !== state.aggregatingTasks.group) { + return state; + } + const newData = state.aggregatingTasks.data.filter( + (task) => !action.payload.deleted_ids.includes(task.id) + ); + return { + ...state, + aggregatingTasks: { + ...state.aggregatingTasks, + batchActionPending: false, + data: newData, + }, + }; + } + + case BATCH_RUN_AGGREGATING_TASKS_SUCCESS: { + if (action.group !== state.aggregatingTasks.group) { + return state; + } + const newData = state.aggregatingTasks.data.filter( + (task) => !action.payload.pending_ids.includes(task.id) + ); + return { + ...state, + aggregatingTasks: { + ...state.aggregatingTasks, + batchActionPending: false, + data: newData, + }, + }; + } + + case BATCH_ARCHIVE_AGGREGATING_TASKS_SUCCESS: { + if (action.group !== state.aggregatingTasks.group) { + return state; + } + const newData = state.aggregatingTasks.data.filter( + (task) => !action.payload.archived_ids.includes(task.id) + ); + return { + ...state, + aggregatingTasks: { + ...state.aggregatingTasks, + batchActionPending: false, + data: newData, + }, + }; + } + case RUN_RETRY_TASK_BEGIN: case ARCHIVE_RETRY_TASK_BEGIN: case DELETE_RETRY_TASK_BEGIN: @@ -1405,6 +1571,8 @@ function tasksReducer( }, }; + case RUN_ALL_AGGREGATING_TASKS_BEGIN: + case ARCHIVE_ALL_AGGREGATING_TASKS_BEGIN: case DELETE_ALL_AGGREGATING_TASKS_BEGIN: if (state.aggregatingTasks.group !== action.group) { return state; @@ -1417,6 +1585,8 @@ function tasksReducer( }, }; + case RUN_ALL_AGGREGATING_TASKS_SUCCESS: + case ARCHIVE_ALL_AGGREGATING_TASKS_SUCCESS: case DELETE_ALL_AGGREGATING_TASKS_SUCCESS: if (state.aggregatingTasks.group !== action.group) { return state; @@ -1430,6 +1600,8 @@ function tasksReducer( }, }; + case RUN_ALL_AGGREGATING_TASKS_ERROR: + case ARCHIVE_ALL_AGGREGATING_TASKS_ERROR: case DELETE_ALL_AGGREGATING_TASKS_ERROR: if (state.aggregatingTasks.group !== action.group) { return state;