@gen-epix/ui 1.14.4 → 1.15.0

package/src/pages/UserAccessCasePoliciesAdminPage/UserAccessCasePoliciesAdminPage.tsx

@@ -0,0 +1,209 @@
+import {
+  useCallback,
+  useMemo,
+} from 'react';
+import { useTranslation } from 'react-i18next';
+import {
+  boolean,
+  object,
+  string,
+} from 'yup';
+
+import type { UserAccessCasePolicy } from '../../api';
+import {
+  AbacApi,
+  CommandName,
+} from '../../api';
+import { useColSetOptionsQuery } from '../../dataHooks/useColSetsQuery';
+import { useCaseTypeSetOptionsQuery } from '../../dataHooks/useCaseTypeSetsQuery';
+import { useDataCollectionOptionsQuery } from '../../dataHooks/useDataCollectionsQuery';
+import { useUserOptionsQuery } from '../../dataHooks/useUsersQuery';
+import { useUserCasePolicyNameFactory } from '../../hooks/useUserCasePolicyNameFactory';
+import { useArray } from '../../hooks/useArray';
+import type { FormFieldDefinition } from '../../models/form';
+import { FORM_FIELD_DEFINITION_TYPE } from '../../models/form';
+import { QUERY_KEY } from '../../models/query';
+import type { TableColumn } from '../../models/table';
+import { TableUtil } from '../../utils/TableUtil';
+import { TestIdUtil } from '../../utils/TestIdUtil';
+import { CrudPage } from '../CrudPage';
+
+type FormFields = Pick<
+  UserAccessCasePolicy,
+  'user_id' |
+  'data_collection_id' |
+  'case_type_set_id' |
+  'read_col_set_id' |
+  'write_col_set_id' |
+  'add_case' |
+  'remove_case' |
+  'add_case_set' |
+  'remove_case_set' |
+  'read_case_set' |
+  'write_case_set' |
+  'is_active'
+>;
+
+export const UserAccessCasePoliciesAdminPage = () => {
+  const { t } = useTranslation();
+  const userOptionsQuery = useUserOptionsQuery();
+  const dataCollectionOptionsQuery = useDataCollectionOptionsQuery();
+  const colSetOptionsQuery = useColSetOptionsQuery();
+  const caseTypeSetOptions = useCaseTypeSetOptionsQuery();
+
+  const nameFactory = useUserCasePolicyNameFactory();
+
+  const loadables = useArray([nameFactory, userOptionsQuery, dataCollectionOptionsQuery, colSetOptionsQuery, caseTypeSetOptions]);
+
+  const fetchAll = useCallback(async (signal: AbortSignal) => {
+    return (await AbacApi.instance.userAccessCasePoliciesGetAll({ signal }))?.data;
+  }, []);
+
+  const deleteOne = useCallback(async (item: UserAccessCasePolicy) => {
+    return await AbacApi.instance.userAccessCasePoliciesDeleteOne(item.id);
+  }, []);
+
+  const updateOne = useCallback(async (variables: FormFields, item: UserAccessCasePolicy) => {
+    return (await AbacApi.instance.userAccessCasePoliciesPutOne(item.id, { id: item.id, ...variables })).data;
+  }, []);
+
+  const createOne = useCallback(async (variables: FormFields) => {
+    return (await AbacApi.instance.userAccessCasePoliciesPostOne(variables)).data;
+  }, []);
+
+  const getName = useCallback((item: UserAccessCasePolicy) => {
+    return nameFactory.getName(item);
+  }, [nameFactory]);
+
+  const schema = useMemo(() => {
+    return object<FormFields>().shape({
+      user_id: string().uuid4().required().max(100),
+      data_collection_id: string().uuid4().required().max(100),
+      case_type_set_id: string().uuid4().required().max(100),
+      read_col_set_id: string().uuid4().required().max(100),
+      write_col_set_id: string().uuid4().nullable().notRequired().max(100),
+      add_case: boolean().required(),
+      remove_case: boolean().required(),
+      add_case_set: boolean().required(),
+      remove_case_set: boolean().required(),
+      read_case_set: boolean().required(),
+      write_case_set: boolean().required(),
+      is_active: boolean().required(),
+    });
+  }, []);
+
+  const formFieldDefinitions = useMemo<FormFieldDefinition<FormFields>[]>(() => {
+    return [
+      {
+        definition: FORM_FIELD_DEFINITION_TYPE.AUTOCOMPLETE,
+        name: 'user_id',
+        label: t`User`,
+        options: userOptionsQuery.options,
+        loading: userOptionsQuery.isLoading,
+      } as const satisfies FormFieldDefinition<FormFields>,
+      {
+        definition: FORM_FIELD_DEFINITION_TYPE.AUTOCOMPLETE,
+        name: 'data_collection_id',
+        label: t`Data collection`,
+        options: dataCollectionOptionsQuery.options,
+        loading: dataCollectionOptionsQuery.isLoading,
+      } as const satisfies FormFieldDefinition<FormFields>,
+      {
+        definition: FORM_FIELD_DEFINITION_TYPE.AUTOCOMPLETE,
+        name: 'case_type_set_id',
+        label: t`Case type set`,
+        options: caseTypeSetOptions.options,
+        loading: caseTypeSetOptions.isLoading,
+      } as const satisfies FormFieldDefinition<FormFields>,
+      {
+        definition: FORM_FIELD_DEFINITION_TYPE.AUTOCOMPLETE,
+        name: 'read_col_set_id',
+        label: t`Read column set`,
+        options: colSetOptionsQuery.options,
+        loading: colSetOptionsQuery.isLoading,
+      } as const satisfies FormFieldDefinition<FormFields>,
+      {
+        definition: FORM_FIELD_DEFINITION_TYPE.AUTOCOMPLETE,
+        name: 'write_col_set_id',
+        label: t`Write column set`,
+        options: colSetOptionsQuery.options,
+        loading: colSetOptionsQuery.isLoading,
+      } as const satisfies FormFieldDefinition<FormFields>,
+      {
+        definition: FORM_FIELD_DEFINITION_TYPE.BOOLEAN,
+        name: 'add_case',
+        label: t`Add case`,
+      } as const satisfies FormFieldDefinition<FormFields>,
+      {
+        definition: FORM_FIELD_DEFINITION_TYPE.BOOLEAN,
+        name: 'remove_case',
+        label: t`Remove case`,
+      } as const satisfies FormFieldDefinition<FormFields>,
+      {
+        definition: FORM_FIELD_DEFINITION_TYPE.BOOLEAN,
+        name: 'add_case_set',
+        label: t`Add case set`,
+      } as const satisfies FormFieldDefinition<FormFields>,
+      {
+        definition: FORM_FIELD_DEFINITION_TYPE.BOOLEAN,
+        name: 'remove_case_set',
+        label: t`Remove case set`,
+      } as const satisfies FormFieldDefinition<FormFields>,
+      {
+        definition: FORM_FIELD_DEFINITION_TYPE.BOOLEAN,
+        name: 'read_case_set',
+        label: t`Read case set`,
+      } as const satisfies FormFieldDefinition<FormFields>,
+      {
+        definition: FORM_FIELD_DEFINITION_TYPE.BOOLEAN,
+        name: 'write_case_set',
+        label: t`Write case set`,
+      } as const satisfies FormFieldDefinition<FormFields>,
+      {
+        definition: FORM_FIELD_DEFINITION_TYPE.BOOLEAN,
+        name: 'is_active',
+        label: t`Is active`,
+      } as const satisfies FormFieldDefinition<FormFields>,
+    ] as const;
+  }, [colSetOptionsQuery.isLoading, colSetOptionsQuery.options, caseTypeSetOptions.isLoading, caseTypeSetOptions.options, dataCollectionOptionsQuery.isLoading, dataCollectionOptionsQuery.options, userOptionsQuery.isLoading, userOptionsQuery.options, t]);
+
+  const tableColumns = useMemo((): TableColumn<UserAccessCasePolicy>[] => {
+    return [
+      TableUtil.createOptionsColumn<UserAccessCasePolicy>({ id: 'user_id', name: t`User`, options: userOptionsQuery.options }),
+      TableUtil.createOptionsColumn<UserAccessCasePolicy>({ id: 'data_collection_id', name: t`Data collection`, options: dataCollectionOptionsQuery.options }),
+      TableUtil.createOptionsColumn<UserAccessCasePolicy>({ id: 'case_type_set_id', name: t`Case type set`, options: caseTypeSetOptions.options }),
+      TableUtil.createOptionsColumn<UserAccessCasePolicy>({ id: 'read_col_set_id', name: t`Read column set`, options: colSetOptionsQuery.options }),
+      TableUtil.createOptionsColumn<UserAccessCasePolicy>({ id: 'write_col_set_id', name: t`Write column set`, options: colSetOptionsQuery.options }),
+
+      TableUtil.createBooleanColumn<UserAccessCasePolicy>({ id: 'add_case', name: t`Add case` }),
+      TableUtil.createBooleanColumn<UserAccessCasePolicy>({ id: 'remove_case', name: t`Remove case` }),
+      TableUtil.createBooleanColumn<UserAccessCasePolicy>({ id: 'add_case_set', name: t`Add case set` }),
+      TableUtil.createBooleanColumn<UserAccessCasePolicy>({ id: 'remove_case_set', name: t`Remove case set` }),
+      TableUtil.createBooleanColumn<UserAccessCasePolicy>({ id: 'read_case_set', name: t`Read case set` }),
+      TableUtil.createBooleanColumn<UserAccessCasePolicy>({ id: 'write_case_set', name: t`Write case set` }),
+
+      TableUtil.createBooleanColumn<UserAccessCasePolicy>({ id: 'is_active', name: t`Active` }),
+    ];
+  }, [colSetOptionsQuery.options, caseTypeSetOptions.options, dataCollectionOptionsQuery.options, userOptionsQuery.options, t]);
+
+  return (
+    <CrudPage<FormFields, UserAccessCasePolicy>
+      createOne={createOne}
+      crudCommandType={CommandName.UserAccessCasePolicyCrudCommand}
+      createItemDialogTitle={t`Create new user access case policy`}
+      defaultSortByField={'user_id'}
+      defaultSortDirection={'asc'}
+      deleteOne={deleteOne}
+      fetchAll={fetchAll}
+      formFieldDefinitions={formFieldDefinitions}
+      getName={getName}
+      loadables={loadables}
+      resourceQueryKeyBase={QUERY_KEY.USER_ACCESS_CASE_POLICIES}
+      schema={schema}
+      tableColumns={tableColumns}
+      testIdAttributes={TestIdUtil.createAttributes('UserAccessCasePoliciesAdminPage')}
+      title={t`User access case policies`}
+      updateOne={updateOne}
+    />
+  );
+};

package/src/pages/UserAccessCasePoliciesAdminPage/index.ts

@@ -0,0 +1 @@
+export * from './UserAccessCasePoliciesAdminPage';

package/src/pages/UserEffectiveRightsAdminPage/UserEffectiveRightsAdminPage.tsx

@@ -0,0 +1,331 @@
+import { useTranslation } from 'react-i18next';
+import {
+  Box,
+  Link,
+  useTheme,
+} from '@mui/material';
+import {
+  useMemo,
+  useCallback,
+  useRef,
+  type MouseEvent as ReactMouseEvent,
+} from 'react';
+import { useParams } from 'react-router-dom';
+
+import { TestIdUtil } from '../../utils/TestIdUtil';
+import { PageContainer } from '../../components/ui/PageContainer';
+import { ResponseHandler } from '../../components/ui/ResponseHandler';
+import {
+  Table,
+  TableCaption,
+  TableMenu,
+  TableSidebarMenu,
+} from '../../components/ui/Table';
+import { useColSetMembersQuery } from '../../dataHooks/useColSetMembersQuery';
+import { useCaseTypeSetMembersQuery } from '../../dataHooks/useCaseTypeSetMembersQuery';
+import {
+  useDataCollectionsMapQuery,
+  useDataCollectionOptionsQuery,
+} from '../../dataHooks/useDataCollectionsQuery';
+import { useOrganizationAccessCasePoliciesQuery } from '../../dataHooks/useOrganizationAccessCasePoliciesQuery';
+import { useOrganizationShareCasePoliciesQuery } from '../../dataHooks/useOrganizationShareCasePoliciesQuery';
+import { useUserAccessCasePoliciesQuery } from '../../dataHooks/useUserAccessCasePoliciesQuery';
+import { useUserShareCasePoliciesQuery } from '../../dataHooks/useUserShareCasePoliciesQuery';
+import { useArray } from '../../hooks/useArray';
+import { useInitializeTableStore } from '../../hooks/useInitializeTableStore';
+import type {
+  TableColumn,
+  TableRowParams,
+} from '../../models/table';
+import {
+  createTableStore,
+  TableStoreContextProvider,
+} from '../../stores/tableStore';
+import { TableUtil } from '../../utils/TableUtil';
+import type { User } from '../../api';
+import { OrganizationApi } from '../../api';
+import { useItemQuery } from '../../hooks/useItemQuery';
+import { QUERY_KEY } from '../../models/query';
+import {
+  useCaseTypeSetNameFactory,
+  useCaseTypeSetsMapQuery,
+} from '../../dataHooks/useCaseTypeSetsQuery';
+import { useColSetMapQuery } from '../../dataHooks/useColSetsQuery';
+import { ConfigManager } from '../../classes/managers/ConfigManager';
+import { RouterManager } from '../../classes/managers/RouterManager';
+import type { UserEffectiveRight } from '../../models/caseAccess';
+import type {
+  UsersEffectiveRightsDetailsDialogOpenProps,
+  UsersEffectiveRightsDetailsDialogRefMethods,
+} from '../../components/ui/UsersEffectiveRightsDetailsDialog';
+import { UsersEffectiveRightsDetailsDialog } from '../../components/ui/UsersEffectiveRightsDetailsDialog';
+import { DataUtil } from '../../utils/DataUtil';
+import { EffectiveRightsUtil } from '../../utils/EffectiveRightsUtil';
+
+export const UserEffectiveRightsAdminPage = () => {
+  const { t } = useTranslation();
+  const theme = useTheme();
+  const usersEffectiveRightsDetailsDialogRef = useRef<UsersEffectiveRightsDetailsDialogRefMethods>(null);
+
+  const { userId } = useParams();
+
+  const { isLoading: isUserLoading, error: userError, data: user } = useItemQuery<User>({
+    baseQueryKey: QUERY_KEY.USERS,
+    itemId: userId,
+    useQueryOptions: {
+      queryFn: async ({ signal }) => {
+        const response = await OrganizationApi.instance.usersGetOne(userId, { signal });
+        return response.data;
+      },
+    },
+  });
+
+  const colSetMembersQuery = useColSetMembersQuery();
+  const caseTypeSetsMapQuery = useCaseTypeSetsMapQuery();
+  const colSetMapQuery = useColSetMapQuery();
+  const caseTypeSetMembersQuery = useCaseTypeSetMembersQuery();
+  const caseTypeSetNameFactory = useCaseTypeSetNameFactory();
+  const dataCollectionMapQuery = useDataCollectionsMapQuery();
+  const dataCollectionOptionsQuery = useDataCollectionOptionsQuery();
+  const organizationAccessCasePoliciesQuery = useOrganizationAccessCasePoliciesQuery(policies => policies.filter(policy => policy.is_active && policy.organization_id === user.organization_id));
+  const organizationShareCasePoliciesQuery = useOrganizationShareCasePoliciesQuery(policies => policies.filter(policy => policy.is_active && policy.organization_id === user.organization_id));
+  const userAccessCasePoliciesQuery = useUserAccessCasePoliciesQuery(policies => policies.filter(policy => policy.is_active && policy.user_id === user.id));
+  const userShareCasePoliciesQuery = useUserShareCasePoliciesQuery(policies => policies.filter(policy => policy.is_active && policy.user_id === user.id));
+
+  const loadables = useArray([
+    organizationAccessCasePoliciesQuery,
+    organizationShareCasePoliciesQuery,
+    userAccessCasePoliciesQuery,
+    userShareCasePoliciesQuery,
+    caseTypeSetMembersQuery,
+    colSetMembersQuery,
+    dataCollectionMapQuery,
+    dataCollectionOptionsQuery,
+    colSetMapQuery,
+    caseTypeSetNameFactory,
+    caseTypeSetsMapQuery,
+  ]);
+
+  const tableStore = useMemo(() => createTableStore<UserEffectiveRight>({
+    navigatorFunction: RouterManager.instance.router.navigate,
+    defaultSortByField: 'data_collection_id',
+    defaultSortDirection: 'asc',
+    idSelectorCallback: (entry) => entry.data_collection_id,
+    storageNamePostFix: 'UsersEffectiveRightsAdminPage-Table',
+    storageVersion: 1,
+  }), []);
+
+  const effectiveRights = useMemo<UserEffectiveRight[]>(() => {
+    const { data: organizationAccessCasePolicies } = organizationAccessCasePoliciesQuery;
+    const { data: organizationShareCasePolicies } = organizationShareCasePoliciesQuery;
+    const { data: userAccessCasePolicies } = userAccessCasePoliciesQuery;
+    const { data: userShareCasePolicies } = userShareCasePoliciesQuery;
+    const { data: caseTypeSetMembers } = caseTypeSetMembersQuery;
+    const { data: colSetMembers } = colSetMembersQuery;
+
+    return EffectiveRightsUtil.assembleUserEffectiveRights({
+      user,
+      organizationAccessCasePolicies,
+      organizationShareCasePolicies,
+      userAccessCasePolicies,
+      userShareCasePolicies,
+      caseTypeSetMembers,
+      colSetMembers,
+    });
+
+  }, [colSetMembersQuery, caseTypeSetMembersQuery, organizationAccessCasePoliciesQuery, organizationShareCasePoliciesQuery, user, userAccessCasePoliciesQuery, userShareCasePoliciesQuery]);
+
+  const renderSetCell = useCallback((params: { userEffectiveRight: UserEffectiveRight; setIds: string[]; uncategorizedMemberIds: string[]; getName: (memberId: string) => string; type: UsersEffectiveRightsDetailsDialogOpenProps['type'] }) => {
+    const { userEffectiveRight, setIds, uncategorizedMemberIds, getName, type } = params;
+    const onLinkClick = (event: ReactMouseEvent) => {
+      event.preventDefault();
+      event.stopPropagation();
+      usersEffectiveRightsDetailsDialogRef.current.open({
+        userEffectiveRight,
+        type,
+        user,
+      });
+    };
+
+    if (uncategorizedMemberIds.length > 0) {
+      return (
+        <Link
+          tabIndex={0}
+          href={'#'}
+          // eslint-disable-next-line react/jsx-no-bind
+          onClick={onLinkClick}
+        >
+          {t`View all`}
+        </Link>
+      );
+    }
+    if (setIds.length > 2) {
+      return (
+        <Link
+          tabIndex={0}
+          href={'#'}
+          // eslint-disable-next-line react/jsx-no-bind
+          onClick={onLinkClick}
+        >
+          {t('View {{numSets}} sets', { numSets: setIds.length })}
+        </Link>
+      );
+    }
+
+    return (
+      <>
+        {setIds.map(setId => (
+          <Link
+            key={setId}
+            href={'#'}
+            // eslint-disable-next-line react/jsx-no-bind
+            onClick={onLinkClick}
+          >
+            {getName(setId) ?? setId}
+          </Link>
+        ))}
+      </>
+    );
+  }, [t, user]);
+
+  const renderCaseTypeSetsCell = useCallback(({ row }: TableRowParams<UserEffectiveRight>) => {
+    return renderSetCell({
+      setIds: row.case_type_set_ids,
+      uncategorizedMemberIds: row.uncategorized_case_type_ids,
+      getName: (caseTypeId: string) => caseTypeSetNameFactory.getName(caseTypeSetsMapQuery.map.get(caseTypeId)),
+      userEffectiveRight: row,
+      type: 'caseTypeSets',
+    });
+  }, [caseTypeSetNameFactory, caseTypeSetsMapQuery.map, renderSetCell]);
+
+  const renderReadCaseSetsCell = useCallback(({ row }: TableRowParams<UserEffectiveRight>) => {
+    return renderSetCell({
+      setIds: row.read_col_set_ids,
+      uncategorizedMemberIds: row.uncategorized_read_col_ids,
+      getName: (colId: string) => colSetMapQuery.map.get(colId).name,
+      userEffectiveRight: row,
+      type: 'readColSets',
+    });
+  }, [colSetMapQuery.map, renderSetCell]);
+
+  const renderWriteCaseSetsCell = useCallback(({ row }: TableRowParams<UserEffectiveRight>) => {
+    return renderSetCell({
+      setIds: row.write_col_set_ids,
+      uncategorizedMemberIds: row.uncategorized_write_col_ids,
+      getName: (colId: string) => colSetMapQuery.map.get(colId)?.name,
+      userEffectiveRight: row,
+      type: 'writeColSets',
+    });
+  }, [colSetMapQuery.map, renderSetCell]);
+
+  const tableColumns = useMemo<TableColumn<UserEffectiveRight>[]>(() => {
+    return [
+      TableUtil.createReadableIndexColumn(),
+      TableUtil.createOptionsColumn({ id: 'data_collection_id', name: t`Data collection`, options: dataCollectionOptionsQuery.options }),
+      {
+        type: 'text',
+        id: 'case_type_set_ids',
+        headerName: t`Case type sets`,
+        isInitiallyVisible: true,
+        renderCell: renderCaseTypeSetsCell,
+        widthFlex: 1,
+        hideInFilter: true,
+      },
+      {
+        type: 'text',
+        id: 'read_col_set_ids',
+        headerName: t`Read column sets`,
+        isInitiallyVisible: true,
+        renderCell: renderReadCaseSetsCell,
+        widthFlex: 1,
+        hideInFilter: true,
+      },
+      {
+        type: 'text',
+        id: 'write_col_set_ids',
+        headerName: t`Write column sets`,
+        isInitiallyVisible: true,
+        renderCell: renderWriteCaseSetsCell,
+        widthFlex: 1,
+        hideInFilter: true,
+      },
+
+      TableUtil.createBooleanColumn<UserEffectiveRight>({ id: 'add_case', name: t`Add case` }),
+      TableUtil.createBooleanColumn<UserEffectiveRight>({ id: 'remove_case', name: t`Remove case` }),
+      TableUtil.createBooleanColumn<UserEffectiveRight>({ id: 'add_case_set', name: t`Add case set` }),
+      TableUtil.createBooleanColumn<UserEffectiveRight>({ id: 'remove_case_set', name: t`Remove case set` }),
+      TableUtil.createBooleanColumn<UserEffectiveRight>({ id: 'read_case_set', name: t`Read case set` }),
+      TableUtil.createBooleanColumn<UserEffectiveRight>({ id: 'write_case_set', name: t`Write case set` }),
+      {
+        type: 'boolean',
+        id: 'has_additional_rights',
+        headerName: t`Addition al rights`,
+        widthFlex: 0.25,
+        isInitiallyVisible: true,
+        valueGetter: (params) => params.row.effective_share_case_rights.length > 0,
+      },
+    ];
+  }, [dataCollectionOptionsQuery.options, renderCaseTypeSetsCell, renderReadCaseSetsCell, renderWriteCaseSetsCell, t]);
+
+  const getRowName = useCallback((row: UserEffectiveRight) => {
+    return dataCollectionMapQuery.map.get(row.data_collection_id)?.name ?? row.data_collection_id;
+  }, [dataCollectionMapQuery.map]);
+
+  const onRowClick = useCallback((params: TableRowParams<UserEffectiveRight>) => {
+    usersEffectiveRightsDetailsDialogRef.current.open({
+      userEffectiveRight: params.row,
+      type: 'caseTypeSets',
+      user,
+    });
+  }, [user]);
+
+  useInitializeTableStore({ store: tableStore, columns: tableColumns, rows: effectiveRights, createFiltersFromColumns: true });
+
+  return (
+    <TableStoreContextProvider store={tableStore}>
+      <PageContainer
+        fullWidth
+        showBreadcrumbs
+        contentActions={(<TableMenu />)}
+        contentHeader={(
+          <TableCaption
+            caption={user ? t('{{userName}} effective rights', { userName: DataUtil.getUserDisplayValue(user, t) }) : t`⌛ Loading...`}
+            component={'h2'}
+            variant={'h2'}
+          />
+        )}
+        testIdAttributes={TestIdUtil.createAttributes('UsersEffectiveRightsAdminPage')}
+        title={t`Users effective rights`}
+      >
+        <Box
+          sx={{
+            position: 'relative',
+            height: '100%',
+          }}
+        >
+          <ResponseHandler
+            inlineSpinner
+            error={userError}
+            isLoading={isUserLoading}
+            loadables={loadables}
+          >
+            <TableSidebarMenu />
+            <Box
+              sx={{
+                width: '100%',
+                height: '100%',
+                paddingLeft: theme.spacing(ConfigManager.instance.config.layout.SIDEBAR_MENU_WIDTH + 1),
+              }}
+            >
+              <Table
+                getRowName={getRowName}
+                onRowClick={onRowClick}
+              />
+            </Box>
+          </ResponseHandler>
+        </Box>
+        <UsersEffectiveRightsDetailsDialog ref={usersEffectiveRightsDetailsDialogRef} />
+      </PageContainer>
+    </TableStoreContextProvider>
+  );
+};

package/src/pages/UserEffectiveRightsAdminPage/index.ts

@@ -0,0 +1 @@
+export * from './UserEffectiveRightsAdminPage';