Files
Checkmate/Client/src/Pages/Uptime/Home/index.jsx
T

229 lines
6.2 KiB
React
Raw Normal View History

// Components
import { Box, Stack, Button } from "@mui/material";
import Greeting from "../../../Utils/greeting";
2024-08-27 15:18:18 -07:00
import SkeletonLayout from "./skeleton";
import Fallback from "./fallback";
2024-08-27 19:46:09 -07:00
import StatusBox from "./StatusBox";
import UptimeDataTable from "./UptimeDataTable";
import { Pagination } from "../../../Components/Table/TablePagination";
// Utils
import { useTheme } from "@emotion/react";
2025-01-08 13:47:42 -08:00
import { useEffect, useState, useCallback, useMemo } from "react";
2025-01-08 11:53:13 -08:00
import { setRowsPerPage } from "../../../Features/UI/uiSlice";
import { useIsAdmin } from "../../../Hooks/useIsAdmin";
import { useSelector, useDispatch } from "react-redux";
import { useNavigate } from "react-router-dom";
import { createToast } from "../../../Utils/toastUtils";
import Breadcrumbs from "../../../Components/Breadcrumbs";
import useDebounce from "../../../Utils/debounce";
2025-01-08 13:47:42 -08:00
import { networkService } from "../../../main";
2024-08-27 15:18:18 -07:00
2024-12-10 14:23:46 +08:00
const BREADCRUMBS = [{ name: `Uptime`, path: "/uptime" }];
2024-12-12 09:15:39 -05:00
const UptimeMonitors = () => {
// Redux state
2025-01-08 11:53:13 -08:00
const rowsPerPage = useSelector((state) => state.ui.monitors.rowsPerPage);
// Local state
const [monitors, setMonitors] = useState([]);
const [sort, setSort] = useState({});
const [search, setSearch] = useState("");
const [page, setPage] = useState(0);
const [isSearching, setIsSearching] = useState(false);
2025-01-08 13:47:42 -08:00
const [isLoading, setIsLoading] = useState(false);
2024-12-11 10:46:54 +08:00
const [monitorUpdateTrigger, setMonitorUpdateTrigger] = useState(false);
2025-01-08 13:47:42 -08:00
const [monitorsSummary, setMonitorsSummary] = useState({});
2024-12-11 10:46:54 +08:00
// Utils
const debouncedFilter = useDebounce(search, 500);
const dispatch = useDispatch();
const theme = useTheme();
const navigate = useNavigate();
const isAdmin = useIsAdmin();
const authState = useSelector((state) => state.auth);
const fetchParams = useMemo(
() => ({
authToken: authState.authToken,
teamId: authState.user.teamId,
sort: { field: sort.field, order: sort.order },
filter: debouncedFilter,
page,
rowsPerPage,
}),
[authState.authToken, authState.user.teamId, sort, debouncedFilter, page, rowsPerPage]
);
const getMonitorWithPercentage = useCallback((monitor, theme) => {
let uptimePercentage = "";
let percentageColor = theme.palette.percentage.uptimeExcellent;
if (monitor.uptimePercentage !== undefined) {
uptimePercentage =
monitor.uptimePercentage === 0
? "0"
: (monitor.uptimePercentage * 100).toFixed(2);
percentageColor =
monitor.uptimePercentage < 0.25
? theme.palette.percentage.uptimePoor
: monitor.uptimePercentage < 0.5
? theme.palette.percentage.uptimeFair
: monitor.uptimePercentage < 0.75
? theme.palette.percentage.uptimeGood
: theme.palette.percentage.uptimeExcellent;
}
return {
id: monitor._id,
name: monitor.name,
url: monitor.url,
title: monitor.name,
percentage: uptimePercentage,
percentageColor,
monitor: monitor,
};
}, []);
const fetchMonitors = useCallback(async () => {
try {
2025-01-08 13:47:42 -08:00
setIsLoading(true);
const config = fetchParams;
const res = await networkService.getMonitorsByTeamId({
authToken: config.authToken,
teamId: config.teamId,
limit: 25,
types: ["http", "ping", "docker", "port"],
page: config.page,
rowsPerPage: config.rowsPerPage,
filter: config.filter,
field: config.sort.field,
order: config.sort.order,
});
const { monitors, summary } = res.data.data;
const mappedMonitors = monitors.map((monitor) =>
getMonitorWithPercentage(monitor, theme)
);
setMonitors(mappedMonitors);
setMonitorsSummary(summary);
} catch (error) {
createToast({
body: "Error fetching monitors",
});
} finally {
2025-01-08 13:47:42 -08:00
setIsLoading(false);
setIsSearching(false);
}
2025-01-08 13:47:42 -08:00
}, [fetchParams, getMonitorWithPercentage, theme]);
2024-10-18 14:49:48 -04:00
useEffect(() => {
fetchMonitors();
2025-01-08 13:47:42 -08:00
}, [fetchMonitors, monitorUpdateTrigger]);
const handleChangePage = (event, newPage) => {
setPage(newPage);
};
const handleChangeRowsPerPage = (event) => {
dispatch(
setRowsPerPage({
value: parseInt(event.target.value, 10),
table: "monitors",
})
);
setPage(0);
};
2024-09-18 17:14:03 -04:00
const triggerUpdate = () => {
setMonitorUpdateTrigger((prev) => !prev);
};
2025-01-08 14:17:29 -08:00
const totalMonitors = monitorsSummary?.totalMonitors ?? 0;
const hasMonitors = monitorsSummary?.totalMonitors ?? 0;
2024-10-18 14:49:48 -04:00
const canAddMonitor = isAdmin && hasMonitors;
return (
<Stack
className="monitors"
gap={theme.spacing(8)}
>
<Box>
2024-12-10 14:23:46 +08:00
<Breadcrumbs list={BREADCRUMBS} />
<Stack
direction="row"
2024-12-10 14:23:46 +08:00
justifyContent="end"
alignItems="center"
mt={theme.spacing(5)}
2024-10-16 21:57:41 -04:00
gap={theme.spacing(6)}
>
2024-10-18 14:49:48 -04:00
{canAddMonitor && (
<Button
variant="contained"
color="primary"
onClick={() => {
2024-12-10 14:23:46 +08:00
navigate("/uptime/create");
}}
2024-12-11 21:18:09 -05:00
sx={{ fontWeight: 500, whiteSpace: "nowrap" }}
>
2024-12-10 14:23:46 +08:00
Create new
</Button>
)}
</Stack>
2024-12-10 14:23:46 +08:00
<Greeting type="uptime" />
</Box>
{
<>
{!isLoading && !hasMonitors && <Fallback isAdmin={isAdmin} />}
2025-01-08 14:03:23 -08:00
{isLoading ? (
<SkeletonLayout />
) : (
hasMonitors && (
<>
<Stack
gap={theme.spacing(8)}
direction="row"
justifyContent="space-between"
>
<StatusBox
title="up"
value={monitorsSummary?.upMonitors ?? 0}
/>
<StatusBox
title="down"
value={monitorsSummary?.downMonitors ?? 0}
/>
<StatusBox
title="paused"
value={monitorsSummary?.pausedMonitors ?? 0}
/>
</Stack>
<UptimeDataTable
isAdmin={isAdmin}
isLoading={isLoading}
monitors={monitors}
monitorCount={totalMonitors}
sort={sort}
setSort={setSort}
search={search}
setSearch={setSearch}
isSearching={isSearching}
setIsSearching={setIsSearching}
setIsLoading={setIsLoading}
triggerUpdate={triggerUpdate}
/>
2025-01-08 14:03:23 -08:00
<Pagination
monitorCount={totalMonitors}
page={page}
rowsPerPage={rowsPerPage}
handleChangePage={handleChangePage}
handleChangeRowsPerPage={handleChangeRowsPerPage}
/>
2025-01-08 14:03:23 -08:00
</>
)
)}
</>
}
</Stack>
);
2024-08-27 15:18:18 -07:00
};
2024-12-10 14:23:46 +08:00
export default UptimeMonitors;