Files
Checkmate/client/src/Pages/Infrastructure/Monitors/index.tsx
T

275 lines
8.1 KiB
TypeScript
Raw Normal View History

2026-01-28 21:34:43 +00:00
import Stack from "@mui/material/Stack";
2026-05-20 12:18:17 -07:00
import Typography from "@mui/material/Typography";
2026-01-28 21:34:43 +00:00
import useMediaQuery from "@mui/material/useMediaQuery";
2026-05-20 12:18:17 -07:00
import { MonitorBasePageWithStates, ColoredLabel } from "@/Components/design-elements";
2026-02-20 18:13:39 +00:00
import { HeaderCreate } from "@/Components/common";
import {
ControlsFilter,
HeaderMonitorsSummary,
BulkActionsBar,
} from "@/Components/monitors";
import { TextField, Dialog, Button } from "@/Components/inputs";
import { Play, Pause } from "lucide-react";
2026-01-28 21:34:43 +00:00
import { useGet, useDelete } from "@/Hooks/UseApi";
import { useIsAdmin } from "@/Hooks/useIsAdmin";
import type { Monitor, MonitorsWithChecksResponse } from "@/Types/Monitor";
2026-05-20 12:18:17 -07:00
import type { Tag } from "@/Types/Tag";
2026-01-28 21:34:43 +00:00
import { useTheme } from "@mui/material";
2026-05-20 12:18:17 -07:00
import { SPACING } from "@/Utils/Theme/constants";
2026-01-28 21:34:43 +00:00
import { useState, useCallback, useMemo } from "react";
import { useTranslation } from "react-i18next";
import { useSelector, useDispatch } from "react-redux";
import { setRowsPerPage } from "@/Features/UI/uiSlice.js";
import type { RootState } from "@/Types/state";
import { InfraMonitorsTable } from "./Components/MonitorsTable";
import useDebounce from "@/Hooks/useDebounce";
import { useBulkMonitorActions } from "@/Hooks/useBulkMonitorActions";
2026-01-28 21:34:43 +00:00
2026-01-28 20:48:02 +00:00
const InfrastructureMonitors = () => {
2026-01-28 21:34:43 +00:00
const { t } = useTranslation();
const theme = useTheme();
const isSmall = useMediaQuery(theme.breakpoints.down("md"));
const isAdmin = useIsAdmin();
const dispatch = useDispatch();
// Redux state
const rowsPerPage = useSelector(
(state: RootState) => state.ui?.infrastructure?.rowsPerPage ?? 5
);
// Local state
const [selectedStatus, setSelectedStatus] = useState<string>("");
const [selectedState, setSelectedState] = useState<string>("");
2026-05-20 12:18:17 -07:00
const [selectedTags, setSelectedTags] = useState<string[]>([]);
2026-01-28 21:34:43 +00:00
const [search, setSearch] = useState<string>("");
const [page, setPage] = useState<number>(0);
const [sortField, setSortField] = useState<string>("");
const [sortOrder, setSortOrder] = useState<"asc" | "desc">("asc");
const [selectedMonitor, setSelectedMonitor] = useState<Monitor | null>(null);
2026-05-20 12:18:17 -07:00
const { data: tags } = useGet<Tag[]>("/tags/team");
2026-01-28 21:34:43 +00:00
const isDialogOpen = Boolean(selectedMonitor);
const debouncedSearch = useDebounce<string>(search, 300);
2026-01-28 21:34:43 +00:00
const handleClearFilters = useCallback(() => {
setSelectedStatus("");
setSelectedState("");
2026-05-20 12:18:17 -07:00
setSelectedTags([]);
2026-01-28 21:34:43 +00:00
setSearch("");
}, []);
// Convert filter selections to API filter values
const toFilterStatus = useMemo(() => {
if (selectedStatus === "up") return "true";
if (selectedStatus === "down") return "false";
return undefined;
}, [selectedStatus]);
const toFilterActive = useMemo(() => {
if (selectedState === "active") return "true";
if (selectedState === "paused") return "false";
return undefined;
}, [selectedState]);
// Determine field and filter for the API request
// Priority: status > isActive > search
const filterLookup = new Map<string | undefined, string>([
[toFilterStatus, "status"],
[toFilterActive, "isActive"],
]);
const activeFilter = [...filterLookup].find(([key]) => key !== undefined);
const field = activeFilter?.[1] || (debouncedSearch ? "name" : sortField || undefined);
const filter = activeFilter?.[0] || debouncedSearch || undefined;
2026-01-28 21:34:43 +00:00
// Build URL for monitors with checks
const monitorsWithChecksUrl = useMemo(() => {
const params = new URLSearchParams();
params.append("type", "hardware");
2026-05-20 12:18:17 -07:00
selectedTags.forEach((tagId) => params.append("tags", tagId));
2026-01-28 21:34:43 +00:00
params.append("limit", "1");
if (page !== undefined) params.append("page", String(page));
if (rowsPerPage) params.append("rowsPerPage", String(rowsPerPage));
if (filter) params.append("filter", filter);
if (field) params.append("field", field);
if (sortOrder) params.append("order", sortOrder);
return `/monitors/team/with-checks?${params.toString()}`;
2026-05-20 12:18:17 -07:00
}, [page, rowsPerPage, filter, field, sortOrder, selectedTags]);
2026-01-28 21:34:43 +00:00
const {
data: monitorsWithChecksData,
isLoading: monitorsWithChecksLoading,
error: monitorsWithChecksError,
refetch,
} = useGet<MonitorsWithChecksResponse>(
monitorsWithChecksUrl,
{},
{ refreshInterval: 5000, keepPreviousData: true }
);
2026-02-11 20:11:22 +00:00
const { summary, count } = monitorsWithChecksData ?? { summary: null, count: 0 };
2026-02-05 18:30:43 +00:00
const isLoading = monitorsWithChecksLoading;
2026-01-28 21:34:43 +00:00
// Bulk actions
const {
selectedRows,
setSelectedRows,
handleBulkPause,
handleBulkResume,
handleCancelSelection,
} = useBulkMonitorActions(refetch, page);
2026-02-05 18:56:54 +00:00
// Check if any filters are active
2026-05-20 12:18:17 -07:00
const hasActiveFilters = Boolean(
selectedStatus || selectedState || selectedTags.length > 0 || search
);
2026-02-05 18:56:54 +00:00
// Show empty state only when there are truly no monitors (not just filtered out)
const effectiveTotalCount =
hasActiveFilters && (summary?.totalMonitors ?? 0) === 0
? 1
: (summary?.totalMonitors ?? 0);
2026-01-28 21:34:43 +00:00
// Delete hook
const { deleteFn, loading: isDeleting } = useDelete();
const handleConfirm = async () => {
if (!selectedMonitor) return;
await deleteFn(`/monitors/${selectedMonitor.id}`);
setSelectedMonitor(null);
refetch();
};
const handleCancel = () => {
setSelectedMonitor(null);
};
return (
<MonitorBasePageWithStates
headerKey="infrastructure"
2026-01-28 21:34:43 +00:00
loading={isLoading}
2026-02-05 18:30:43 +00:00
error={monitorsWithChecksError}
2026-02-05 18:56:54 +00:00
totalCount={effectiveTotalCount}
2026-01-28 21:34:43 +00:00
page="infrastructure"
actionLink="/infrastructure/create"
>
<HeaderCreate
path="/infrastructure/create"
isLoading={isLoading}
isAdmin={isAdmin}
/>
2026-02-14 23:09:27 +00:00
<HeaderMonitorsSummary
summary={summary}
showBreached={true}
/>
2026-01-28 21:34:43 +00:00
<Stack
direction={isSmall ? "column" : "row"}
justifyContent={isSmall ? "flex-start" : "space-between"}
gap={theme.spacing(4)}
>
<ControlsFilter
showTypes={false}
selectedStatus={selectedStatus}
setSelectedStatus={setSelectedStatus}
selectedState={selectedState}
setSelectedState={setSelectedState}
2026-05-20 12:18:17 -07:00
tagOptions={tags ?? []}
selectedTags={selectedTags}
setSelectedTags={setSelectedTags}
2026-01-28 21:34:43 +00:00
onClearFilters={handleClearFilters}
/>
<TextField
placeholder={t("pages.uptime.filters.search.placeholder")}
value={search}
onChange={(event) => {
setSearch(event.target.value);
}}
/>
</Stack>
2026-05-20 12:18:17 -07:00
{selectedTags.length > 0 && (
<Stack
direction={isSmall ? "column" : "row"}
alignItems={isSmall ? "flex-start" : "center"}
flexWrap="wrap"
gap={theme.spacing(SPACING.XL)}
>
<Typography color={theme.palette.text.secondary}>
{t("pages.uptime.filters.activeTags")}
</Typography>
{selectedTags.map((tagId) => {
const tag = tags?.find((t) => t.id === tagId);
if (!tag) return null;
return (
<ColoredLabel
key={tag.id}
text={tag.name}
color={tag.color}
/>
);
})}
</Stack>
)}
{!isLoading && (
<BulkActionsBar
selectedCount={selectedRows.length}
onCancel={handleCancelSelection}
>
<Button
size="small"
startIcon={<Play size={16} />}
onClick={handleBulkResume}
>
{t("common.buttons.resume")}
</Button>
<Button
size="small"
startIcon={<Pause size={16} />}
onClick={handleBulkPause}
>
{t("common.buttons.pause")}
</Button>
</BulkActionsBar>
)}
2026-01-28 21:34:43 +00:00
<InfraMonitorsTable
monitors={monitorsWithChecksData?.monitors || []}
2026-05-20 12:18:17 -07:00
tags={tags ?? []}
2026-01-28 21:34:43 +00:00
refetch={refetch}
setSelectedMonitor={setSelectedMonitor}
sortField={sortField}
setSortField={setSortField}
sortOrder={sortOrder}
setSortOrder={setSortOrder}
count={count || 0}
page={page}
setPage={setPage}
rowsPerPage={rowsPerPage}
setRowsPerPage={(value: number) => {
dispatch(
setRowsPerPage({
value,
table: "infrastructure",
})
);
setPage(0);
}}
selectedRows={selectedRows}
onSelectionChange={setSelectedRows}
2026-01-28 21:34:43 +00:00
/>
<Dialog
open={isDialogOpen}
title={t("common.dialogs.delete.title")}
content={t("common.dialogs.delete.description")}
onConfirm={handleConfirm}
onCancel={handleCancel}
loading={isDeleting}
/>
</MonitorBasePageWithStates>
);
2026-01-28 20:48:02 +00:00
};
export default InfrastructureMonitors;