Debian Codegraph @

install/freeipa-webui/src/pages/SudoRules/SudoRules.tsx

raw
1 import React, { useEffect, useState } from "react";
2 // PatternFly
3 import {
4 Flex,
5 FlexItem,
6 PageSection,
7 PaginationVariant,
8 ToolbarItemVariant,
9 } from "@patternfly/react-core";
10 // PatternFly table
11 import {
12 InnerScrollContainer,
13 OuterScrollContainer,
14 } from "@patternfly/react-table";
15 // Data types
16 import { SudoRule } from "src/utils/datatypes/globalDataTypes";
17 import { ToolbarItem } from "src/components/layouts/ToolbarLayout";
18 // Redux
19 import { useAppSelector, useAppDispatch } from "src/store/hooks";
20 // Layouts
21 import TitleLayout from "src/components/layouts/TitleLayout";
22 import HelpTextWithIconLayout from "src/components/layouts/HelpTextWithIconLayout";
23 import SecondaryButton from "src/components/layouts/SecondaryButton";
24 import ToolbarLayout from "src/components/layouts/ToolbarLayout";
25 import SearchInputLayout from "src/components/layouts/SearchInputLayout";
26 // Tables
27 import SudoRulesTable from "./SudoRulesTable";
28 // Components
29 import PaginationLayout from "../../components/layouts/PaginationLayout";
30 import BulkSelectorPrep from "src/components/BulkSelectorPrep";
31 // Modals
32 import AddSudoRule from "src/components/modals/SudoModals/AddSudoRule";
33 import DeleteSudoRule from "src/components/modals/SudoModals/DeleteSudoRule";
34 import DisableEnableSudoRules from "src/components/modals/SudoModals/DisableEnableSudoRules";
35 // Hooks
36 import { addAlert } from "src/store/Global/alerts-slice";
37 import useUpdateRoute from "src/hooks/useUpdateRoute";
38 import useListPageSearchParams from "src/hooks/useListPageSearchParams";
39 // Utils
40 import { API_VERSION_BACKUP, isSudoRuleSelectable } from "src/utils/utils";
41 // RPC client
42 import { GenericPayload, useSearchEntriesMutation } from "src/services/rpc";
43 import { useGettingSudoRulesQuery } from "src/services/rpcSudoRules";
44 // Errors
45 import { FetchBaseQueryError } from "@reduxjs/toolkit/query";
46 import { SerializedError } from "@reduxjs/toolkit";
47 import useApiError from "src/hooks/useApiError";
48 import GlobalErrors from "src/components/errors/GlobalErrors";
49 import ModalErrors from "src/components/errors/ModalErrors";
50
51 const SudoRules = () => {
52 const dispatch = useAppDispatch();
53
54 // Update current route data to Redux and highlight the current page in the Nav bar
55 const { browserTitle } = useUpdateRoute({ pathname: "sudo-rules" });
56
57 // Set the page title to be shown in the browser tab
58 React.useEffect(() => {
59 document.title = browserTitle;
60 }, [browserTitle]);
61
62 // Retrieve API version from environment data
63 const apiVersion = useAppSelector(
64 (state) => state.global.environment.api_version
65 ) as string;
66
67 // Set the page title to be shown in the browser tab
68 React.useEffect(() => {
69 document.title = browserTitle;
70 }, [browserTitle]);
71
72 const [rulesList, setRulesList] = useState<SudoRule[]>([]);
73
74 // Handle API calls errors
75 const globalErrors = useApiError([]);
76 const modalErrors = useApiError([]);
77
78 // URL parameters: page number, page size, search value
79 const { page, setPage, perPage, setPerPage, searchValue, setSearchValue } =
80 useListPageSearchParams();
81
82 const [totalCount, setRulesTotalCount] = useState<number>(0);
83 const [searchDisabled, setSearchIsDisabled] = useState<boolean>(false);
84
85 // Page indexes
86 const firstIdx = (page - 1) * perPage;
87 const lastIdx = page * perPage;
88
89 // Derived states - what we get from API
90 const rulesDataResponse = useGettingSudoRulesQuery({
91 searchValue: "",
92 sizeLimit: 0,
93 apiVersion: apiVersion || API_VERSION_BACKUP,
94 startIdx: firstIdx,
95 stopIdx: lastIdx,
96 } as GenericPayload);
97
98 const {
99 data: batchResponse,
100 isLoading: isBatchLoading,
101 error: batchError,
102 } = rulesDataResponse;
103
104 // Handle data when the API call is finished
105 useEffect(() => {
106 if (rulesDataResponse.isFetching) {
107 setShowTableRows(false);
108 // Reset selected users on refresh
109 setRulesTotalCount(0);
110 globalErrors.clear();
111 return;
112 }
113
114 // API response: Success
115 if (
116 rulesDataResponse.isSuccess &&
117 rulesDataResponse.data &&
118 batchResponse !== undefined
119 ) {
120 const rulesListResult = batchResponse.result.results;
121 const totalCount = batchResponse.result.totalCount;
122 const rulesListSize = batchResponse.result.count;
123 const rulesList: SudoRule[] = [];
124
125 for (let i = 0; i < rulesListSize; i++) {
126 rulesList.push(rulesListResult[i].result);
127 }
128
129 setRulesTotalCount(totalCount);
130 // Update the list
131 setRulesList(rulesList);
132 // Show table elements
133 setShowTableRows(true);
134 }
135
136 // API response: Error
137 if (
138 !rulesDataResponse.isLoading &&
139 rulesDataResponse.isError &&
140 rulesDataResponse.error !== undefined
141 ) {
142 // This normally happens when the user is not authorized to view the data
143 // So instead of adding an error, refresh page
144 window.location.reload();
145 }
146 }, [rulesDataResponse]);
147
148 // Refresh button handling
149 const refreshRulesData = () => {
150 setShowTableRows(false);
151 setRulesTotalCount(0);
152 clearSelectedRules();
153 rulesDataResponse.refetch();
154 };
155
156 // Always refetch data when the component is loaded.
157 // This ensures the data is always up-to-date.
158 React.useEffect(() => {
159 rulesDataResponse.refetch();
160 }, [page, perPage]);
161
162 // 'Delete' button state
163 const [isDeleteButtonDisabled, setIsDeleteButtonDisabled] =
164 useState<boolean>(true);
165
166 const updateIsDeleteButtonDisabled = (value: boolean) => {
167 setIsDeleteButtonDisabled(value);
168 };
169
170 const [isDeletion, setIsDeletion] = useState(false);
171 const updateIsDeletion = (value: boolean) => {
172 setIsDeletion(value);
173 };
174
175 // 'Enable' button state
176 const [isEnableButtonDisabled, setIsEnableButtonDisabled] =
177 useState<boolean>(true);
178
179 const updateIsEnableButtonDisabled = (value: boolean) => {
180 setIsEnableButtonDisabled(value);
181 };
182
183 // 'Disable' button state
184 const [isDisableButtonDisabled, setIsDisableButtonDisabled] =
185 useState<boolean>(true);
186
187 const updateIsDisableButtonDisabled = (value: boolean) => {
188 setIsDisableButtonDisabled(value);
189 };
190
191 // If some entries' status has been updated, unselect selected rows
192 const [isDisableEnableOp, setIsDisableEnableOp] = useState(false);
193
194 const updateIsDisableEnableOp = (value: boolean) => {
195 setIsDisableEnableOp(value);
196 };
197
198 // Elements selected (per page)
199 // - This will help to calculate the remaining elements on a specific page (bulk selector)
200 const [selectedPerPage, setSelectedPerPage] = useState<number>(0);
201
202 const updateSelectedPerPage = (selected: number) => {
203 setSelectedPerPage(selected);
204 };
205
206 // Pagination
207 const updatePage = (newPage: number) => {
208 setPage(newPage);
209 };
210
211 const updatePerPage = (newSetPerPage: number) => {
212 setPerPage(newSetPerPage);
213 };
214
215 // Rules displayed on the first page
216 const updateShownRulesList = (newShownRulesList: SudoRule[]) => {
217 setRulesList(newShownRulesList);
218 };
219
220 // Update search input valie
221 const updateSearchValue = (value: string) => {
222 setSearchValue(value);
223 };
224
225 const [selectedRules, setSelectedRules] = useState<SudoRule[]>([]);
226
227 const clearSelectedRules = () => {
228 const emptyList: SudoRule[] = [];
229 setSelectedRules(emptyList);
230 };
231
232 const [retrieveRules] = useSearchEntriesMutation({});
233
234 // Issue a search using a specific search value
235 const submitSearchValue = () => {
236 setShowTableRows(false);
237 setSearchIsDisabled(true);
238 setRulesTotalCount(0);
239 retrieveRules({
240 searchValue: searchValue,
241 sizeLimit: 0,
242 apiVersion: apiVersion || API_VERSION_BACKUP,
243 startIdx: firstIdx,
244 stopIdx: lastIdx,
245 entryType: "sudorule",
246 } as GenericPayload).then((result) => {
247 // Manage new response here
248 if ("data" in result) {
249 const searchError = result.data?.error as
250 | FetchBaseQueryError
251 | SerializedError;
252
253 if (searchError) {
254 // Error
255 let error: string | undefined = "";
256 if ("error" in searchError) {
257 error = searchError.error;
258 } else if ("message" in searchError) {
259 error = searchError.message;
260 }
261 dispatch(
262 addAlert({
263 name: "submit-search-value-error",
264 title: error || "Error when searching for sudo rules",
265 variant: "danger",
266 })
267 );
268 } else {
269 // Success
270 const rulesListResult = result.data?.result.results || [];
271 const rulesListSize = result.data?.result.count || 0;
272 const totalCount = result.data?.result.totalCount || 0;
273 const rulesList: SudoRule[] = [];
274
275 for (let i = 0; i < rulesListSize; i++) {
276 rulesList.push(rulesListResult[i].result);
277 }
278
279 setRulesTotalCount(totalCount);
280 setRulesList(rulesList);
281 // Show table elements
282 setShowTableRows(true);
283 }
284 setSearchIsDisabled(false);
285 }
286 });
287 };
288
289 // Show table rows
290 const [showTableRows, setShowTableRows] = useState(!isBatchLoading);
291
292 // Show table rows only when data is fully retrieved
293 useEffect(() => {
294 if (showTableRows !== !isBatchLoading) {
295 setShowTableRows(!isBatchLoading);
296 }
297 }, [isBatchLoading]);
298
299 // Modals functionality
300 const [showAddModal, setShowAddModal] = useState(false);
301 const [showDeleteModal, setShowDeleteModal] = useState(false);
302 const [showEnableDisableModal, setShowEnableDisableModal] = useState(false);
303 const [enableDisableOptionSelected, setEnableDisableOptionSelected] =
304 useState(false);
305 const onAddClickHandler = () => {
306 setShowAddModal(true);
307 };
308
309 const onCloseAddModal = () => {
310 setShowAddModal(false);
311 };
312
313 const onAddModalToggle = () => {
314 setShowAddModal(!showAddModal);
315 };
316
317 const onDeleteHandler = () => {
318 setShowDeleteModal(true);
319 };
320
321 const onDeleteModalToggle = () => {
322 setShowDeleteModal(!showDeleteModal);
323 };
324
325 const onEnableDisableHandler = (optionClicked: boolean) => {
326 setIsDeleteButtonDisabled(true); // prevents 'Delete' button to be enabled
327 setIsEnableButtonDisabled(true); // prevents 'Enable' button to be enabled
328 setIsDisableButtonDisabled(true); // prevents 'Disable' button to be enabled
329 setEnableDisableOptionSelected(optionClicked);
330 setShowEnableDisableModal(true);
331 };
332
333 const onEnableDisableModalToggle = () => {
334 setIsEnableButtonDisabled(true); // prevents 'Enable' button to be enabled
335 setIsDisableButtonDisabled(true); // prevents 'Disable' button to be enabled
336 setShowEnableDisableModal(!showEnableDisableModal);
337 };
338
339 // Table-related shared functionality
340 // - Selectable checkboxes on table
341 const selectableRulesTable = rulesList.filter(isSudoRuleSelectable); // elements per Table
342
343 const updateSelectedRules = (rules: SudoRule[], isSelected: boolean) => {
344 let newSelectedRules: SudoRule[] = [];
345 if (isSelected) {
346 newSelectedRules = JSON.parse(JSON.stringify(selectedRules));
347 for (let i = 0; i < rules.length; i++) {
348 if (
349 selectedRules.find(
350 (selectedRule) => selectedRule.cn[0] === rules[i].cn[0]
351 )
352 ) {
353 // Already in the list
354 continue;
355 }
356 // Add rule to list
357 newSelectedRules.push(rules[i]);
358 }
359 } else {
360 // Remove rule
361 for (let i = 0; i < selectedRules.length; i++) {
362 let found = false;
363 for (let ii = 0; ii < rules.length; ii++) {
364 if (selectedRules[i].cn[0] === rules[ii].cn[0]) {
365 found = true;
366 break;
367 }
368 }
369 if (!found) {
370 // Keep this valid selected entry
371 newSelectedRules.push(selectedRules[i]);
372 }
373 }
374 }
375 setSelectedRules(newSelectedRules);
376 setIsDeleteButtonDisabled(newSelectedRules.length === 0);
377 };
378
379 // - Helper method to set the selected entries from the table
380 const setRulesSelected = (rule: SudoRule, isSelecting = true) => {
381 if (isSudoRuleSelectable(rule)) {
382 updateSelectedRules([rule], isSelecting);
383 }
384 };
385
386 // Data wrappers
387 // TODO: Better separation of concerts
388 // - 'PaginationLayout'
389 const paginationData = {
390 page,
391 perPage,
392 updatePage,
393 updatePerPage,
394 updateSelectedPerPage,
395 updateShownElementsList: updateShownRulesList,
396 totalCount,
397 };
398
399 // - 'BulkSelectorSudoRulesPrep'
400 const rulesBulkSelectorData = {
401 selected: selectedRules,
402 updateSelected: updateSelectedRules,
403 selectableTable: selectableRulesTable,
404 nameAttr: "cn",
405 };
406
407 const buttonsData = {
408 updateIsDeleteButtonDisabled,
409 updateIsEnableButtonDisabled,
410 updateIsDisableButtonDisabled,
411 updateIsDisableEnableOp,
412 };
413
414 const selectedPerPageData = {
415 selectedPerPage,
416 updateSelectedPerPage,
417 };
418
419 // 'DeleteRules'
420 const deleteRulesButtonsData = {
421 updateIsDeleteButtonDisabled,
422 updateIsDeletion,
423 };
424
425 const selectedRulesData = {
426 selectedRules,
427 clearSelectedRules,
428 };
429
430 // 'DisableEnableRules'
431 const disableEnableButtonsData = {
432 updateIsEnableButtonDisabled,
433 updateIsDisableButtonDisabled,
434 updateIsDisableEnableOp,
435 };
436
437 // 'RulesTable'
438 const rulesTableData = {
439 isSudoRuleSelectable,
440 selectedRules,
441 selectableRulesTable,
442 setRulesSelected,
443 clearSelectedRules,
444 };
445
446 const rulesTableButtonsData = {
447 updateIsDeleteButtonDisabled,
448 updateIsEnableButtonDisabled,
449 updateIsDisableButtonDisabled,
450 isDeletion,
451 updateIsDeletion,
452 isDisableEnableOp,
453 updateIsDisableEnableOp,
454 };
455
456 // SearchInputLayout
457 const searchValueData = {
458 searchValue,
459 updateSearchValue,
460 submitSearchValue,
461 };
462
463 // List of Toolbar items
464 const toolbarItems: ToolbarItem[] = [
465 {
466 key: 0,
467 element: (
468 <BulkSelectorPrep
469 list={rulesList}
470 shownElementsList={rulesList}
471 elementData={rulesBulkSelectorData}
472 buttonsData={buttonsData}
473 selectedPerPageData={selectedPerPageData}
474 />
475 ),
476 },
477 {
478 key: 1,
479 element: (
480 <SearchInputLayout
481 dataCy="search"
482 name="search"
483 ariaLabel="Search rules"
484 placeholder="Search"
485 searchValueData={searchValueData}
486 isDisabled={searchDisabled}
487 />
488 ),
489 toolbarItemVariant: ToolbarItemVariant.label,
490 toolbarItemGap: { default: "gapMd" },
491 },
492 {
493 key: 2,
494 toolbarItemVariant: ToolbarItemVariant.separator,
495 },
496 {
497 key: 3,
498 element: (
499 <SecondaryButton
500 onClickHandler={refreshRulesData}
501 isDisabled={!showTableRows}
502 dataCy="sudo-rules-button-refresh"
503 >
504 Refresh
505 </SecondaryButton>
506 ),
507 },
508 {
509 key: 4,
510 element: (
511 <SecondaryButton
512 isDisabled={isDeleteButtonDisabled || !showTableRows}
513 onClickHandler={onDeleteHandler}
514 dataCy="sudo-rules-button-delete"
515 >
516 Delete
517 </SecondaryButton>
518 ),
519 },
520 {
521 key: 5,
522 element: (
523 <SecondaryButton
524 onClickHandler={onAddClickHandler}
525 isDisabled={!showTableRows}
526 dataCy="sudo-rules-button-add"
527 >
528 Add
529 </SecondaryButton>
530 ),
531 },
532 {
533 key: 6,
534 element: (
535 <SecondaryButton
536 isDisabled={isDisableButtonDisabled || !showTableRows}
537 onClickHandler={() => onEnableDisableHandler(true)}
538 dataCy="sudo-rules-button-disable"
539 >
540 Disable
541 </SecondaryButton>
542 ),
543 },
544 {
545 key: 7,
546 element: (
547 <SecondaryButton
548 isDisabled={isEnableButtonDisabled || !showTableRows}
549 onClickHandler={() => onEnableDisableHandler(false)}
550 dataCy="sudo-rules-button-enable"
551 >
552 Enable
553 </SecondaryButton>
554 ),
555 },
556 {
557 key: 9,
558 toolbarItemVariant: ToolbarItemVariant.separator,
559 },
560 {
561 key: 10,
562 element: <HelpTextWithIconLayout textContent="Help" />,
563 },
564 {
565 key: 11,
566 element: (
567 <PaginationLayout
568 list={rulesList}
569 paginationData={paginationData}
570 widgetId="pagination-options-menu-top"
571 isCompact={true}
572 />
573 ),
574 toolbarItemAlignment: { default: "alignEnd" },
575 },
576 ];
577
578 return (
579 <div>
580 <PageSection hasBodyWrapper={false}>
581 <TitleLayout id="sudorules title" headingLevel="h1" text="Sudo rules" />
582 </PageSection>
583 <PageSection hasBodyWrapper={false} isFilled={false}>
584 <Flex direction={{ default: "column" }}>
585 <FlexItem>
586 <ToolbarLayout toolbarItems={toolbarItems} />
587 </FlexItem>
588 <FlexItem style={{ flex: "0 0 auto" }}>
589 <OuterScrollContainer>
590 <InnerScrollContainer
591 style={{ height: "60vh", overflow: "auto" }}
592 >
593 {batchError !== undefined && batchError ? (
594 <GlobalErrors errors={globalErrors.getAll()} />
595 ) : (
596 <SudoRulesTable
597 shownElementsList={rulesList}
598 showTableRows={showTableRows}
599 rulesData={rulesTableData}
600 buttonsData={rulesTableButtonsData}
601 paginationData={selectedPerPageData}
602 searchValue={searchValue}
603 />
604 )}
605 </InnerScrollContainer>
606 </OuterScrollContainer>
607 </FlexItem>
608 <FlexItem style={{ flex: "0 0 auto", position: "sticky", bottom: 0 }}>
609 <PaginationLayout
610 list={rulesList}
611 paginationData={paginationData}
612 variant={PaginationVariant.bottom}
613 widgetId="pagination-options-menu-bottom"
614 />
615 </FlexItem>
616 </Flex>
617 </PageSection>
618 <AddSudoRule
619 show={showAddModal}
620 handleModalToggle={onAddModalToggle}
621 onOpenAddModal={onAddClickHandler}
622 onCloseAddModal={onCloseAddModal}
623 onRefresh={refreshRulesData}
624 />
625 <DeleteSudoRule
626 show={showDeleteModal}
627 handleModalToggle={onDeleteModalToggle}
628 selectedRulesData={selectedRulesData}
629 buttonsData={deleteRulesButtonsData}
630 onRefresh={refreshRulesData}
631 />
632 <DisableEnableSudoRules
633 show={showEnableDisableModal}
634 handleModalToggle={onEnableDisableModalToggle}
635 optionSelected={enableDisableOptionSelected}
636 selectedRulesData={selectedRulesData}
637 buttonsData={disableEnableButtonsData}
638 onRefresh={refreshRulesData}
639 />
640 <ModalErrors
641 errors={modalErrors.getAll()}
642 dataCy="sudo-rules-modal-error"
643 />
644 </div>
645 );
646 };
647
648 export default SudoRules;