@kenyaemr/esm-admin-app 5.4.4-pre.98 → 5.4.5-pre.544

package/src/components/facility-setup/type/index.ts

@@ -0,0 +1,61 @@
+export type FacilityRegistryAddress = {
+  country?: string;
+  county_code?: string;
+  county?: string;
+  sub_county_code?: string;
+  sub_county?: string;
+  postal_address?: string;
+  physical_location?: string;
+  town?: string;
+  latitude?: number | null;
+  longitude?: number | null;
+};
+
+export type FacilityRegistryBedOccupancy = {
+  totalBeds?: number;
+  normalBeds?: number;
+  icuBeds?: number;
+  hduBeds?: number;
+  dialysisBeds?: number;
+  numberOfCots?: number;
+};
+
+export type FacilityRegistryRecord = {
+  fr_code: string;
+  fid_code?: string;
+  registration_number?: string;
+  official_name?: string;
+  keph_level?: string;
+  facility_type?: string;
+  facility_ownership?: string;
+  license_status?: string;
+  license_number?: string;
+  license_start_date?: string | null;
+  license_end_date?: string | null;
+  regulatory_body?: string;
+  sha_contract_status?: string;
+  sha_contract_start_date?: string | null;
+  sha_contract_end_date?: string | null;
+  is_hub?: boolean;
+  facility_phone_number?: string;
+  facility_email?: string;
+  facility_administrator_name?: string;
+  facility_administrator_email?: string;
+  facility_administrator_phone?: string;
+  facility_administrator_identifier?: string;
+  address?: FacilityRegistryAddress;
+  regulatory_operational_status?: string;
+  sha_operational_status?: string;
+  bed_occupancy?: FacilityRegistryBedOccupancy;
+  sha_contracted_services?: Array<{ name?: string } | string>;
+  last_synced_at?: string;
+  last_sync_status?: 'SUCCESS' | 'FAILURE';
+};
+
+export type FacilityRegistrySyncResult = {
+  success: boolean;
+  fr_code: string;
+  official_name: string;
+  last_synced_at: string;
+  last_sync_status: 'SUCCESS' | 'FAILURE';
+};

package/src/components/facility-setup/useFacilityRegistry.ts

@@ -0,0 +1,29 @@
+import useSWR from 'swr';
+import { openmrsFetch, restBaseUrl, type FetchResponse } from '@openmrs/esm-framework';
+import { FacilityRegistryRecord, FacilityRegistrySyncResult } from './type';
+import { facilityRegistryUrl } from './constant';
+
+export const useFacilityRegistry = () => {
+  const { data, error, isLoading, mutate } = useSWR<FetchResponse<FacilityRegistryRecord>>(
+    facilityRegistryUrl,
+    openmrsFetch,
+    {
+      revalidateOnFocus: false,
+    },
+  );
+
+  const notYetSynced = error?.response?.status === 404;
+
+  return {
+    facility: data?.data,
+    isLoading,
+    error: notYetSynced ? null : error,
+    notYetSynced,
+    mutate,
+  };
+};
+
+export const syncFacilityRegistry = async (): Promise<FacilityRegistrySyncResult> => {
+  const response = await openmrsFetch<FacilityRegistrySyncResult>(facilityRegistryUrl + '/sync', { method: 'POST' });
+  return response.data;
+};

package/src/components/global-property/dashboard/global-property-dashboard.component.tsx

@@ -0,0 +1,23 @@
+import React from 'react';
+import { PageHeader, FacilityPictogram } from '@openmrs/esm-framework';
+import { useTranslation } from 'react-i18next';
+
+import GlobalPropertyTable from '../table/global-property-table.component';
+import styles from './global-property-dashboard.scss';
+
+const GlobalPropertyDashboard: React.FC = () => {
+  const { t } = useTranslation();
+
+  return (
+    <div>
+      <PageHeader
+        className={styles.pageHeader}
+        title={t('globalProperty', 'Global Property')}
+        illustration={<FacilityPictogram />}
+      />
+      <GlobalPropertyTable />
+    </div>
+  );
+};
+
+export default GlobalPropertyDashboard;

package/src/components/global-property/dashboard/global-property-dashboard.scss

@@ -0,0 +1,6 @@
+@use '@carbon/layout';
+@use '@carbon/colors';
+
+.pageHeader {
+  border-bottom: 1px solid colors.$gray-10;
+}

package/src/components/global-property/hooks/useGlobalProperty.ts

@@ -0,0 +1,64 @@
+import { openmrsFetch, restBaseUrl, useOpenmrsPagination } from '@openmrs/esm-framework';
+
+import { type SystemSettings } from '../../../types';
+
+export type GlobalPropertyPayload = {
+  property: string;
+  value: string;
+  description?: string | null;
+  datatypeClassname?: string | null;
+  datatypeConfig?: string | null;
+  preferredHandlerClassname?: string | null;
+  handlerConfig?: string | null;
+};
+
+export async function saveOrUpdateGlobalProperty(payload: GlobalPropertyPayload, uuid?: string): Promise<void> {
+  const url = uuid ? `${restBaseUrl}/systemsetting/${uuid}` : `${restBaseUrl}/systemsetting`;
+  const body: Record<string, unknown> = {
+    property: payload.property,
+    value: payload.value,
+  };
+  if (payload.description) {
+    body.description = payload.description;
+  }
+  if (payload.datatypeClassname) {
+    body.datatypeClassname = payload.datatypeClassname;
+  }
+  if (payload.datatypeConfig) {
+    body.datatypeConfig = payload.datatypeConfig;
+  }
+  if (payload.preferredHandlerClassname) {
+    body.preferredHandlerClassname = payload.preferredHandlerClassname;
+  }
+  if (payload.handlerConfig != null) {
+    body.handlerConfig = payload.handlerConfig;
+  }
+
+  const response = await openmrsFetch(url, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(body),
+  });
+
+  if (!response.ok) {
+    const errorData = await response.json().catch(() => ({}));
+    throw new Error(errorData?.error?.message ?? 'Failed to save global property');
+  }
+}
+
+export async function deleteGlobalProperty(uuid: string): Promise<void> {
+  const response = await openmrsFetch(`${restBaseUrl}/systemsetting/${uuid}?purge=true`, {
+    method: 'DELETE',
+  });
+  if (!response.ok) {
+    const errorData = await response.json().catch(() => ({}));
+    throw new Error(errorData?.error?.message ?? 'Failed to delete global property');
+  }
+}
+
+export function useGlobalProperties(pageSize: number = 10, searchTerm?: string) {
+  const searchQuery = searchTerm ? `&q=${encodeURIComponent(searchTerm)}` : '';
+  const baseUrl = `${restBaseUrl}/systemsetting?v=default`;
+  const url = searchTerm ? `${baseUrl}${searchQuery}` : baseUrl;
+  return useOpenmrsPagination<SystemSettings>(url, pageSize);
+}

package/src/components/global-property/hooks/useLogoUpload.ts

@@ -0,0 +1,28 @@
+import { openmrsFetch, restBaseUrl } from '@openmrs/esm-framework';
+
+export const ALLOWED_LOGO_TYPES = ['image/jpeg', 'image/png', 'image/gif', 'image/bmp', 'image/webp'];
+export const MAX_LOGO_SIZE_BYTES = 2 * 1024 * 1024; // 2 MB
+
+export type LogoTarget = 'prescription' | 'receipt';
+
+export type UploadLogoResponse = {
+  savedPath: string;
+  message: string;
+};
+
+export async function uploadLogo(file: File, target: LogoTarget = 'prescription'): Promise<UploadLogoResponse> {
+  const formData = new FormData();
+  formData.append('file', file);
+
+  const response = await openmrsFetch(`${restBaseUrl}/palladiumemr/logo?target=${target}`, {
+    method: 'POST',
+    body: formData,
+  });
+
+  if (!response.ok) {
+    const errorData = await response.json().catch(() => ({}));
+    throw new Error(errorData?.error ?? errorData?.error?.message ?? 'Failed to upload image');
+  }
+
+  return response.json();
+}

package/src/components/global-property/index.ts

@@ -0,0 +1,14 @@
+import { getAsyncLifecycle, getSyncLifecycle } from '@openmrs/esm-framework';
+import { createLeftPanelLink } from '../../left-pannel-link.component';
+import { moduleName } from '../../constants';
+
+// t('globalProperty','Global property')
+export const globalPropertyLink = getSyncLifecycle(
+  createLeftPanelLink({ title: 'globalProperty', name: 'global-property' }),
+  { moduleName, featureName: 'global-property' },
+);
+
+export const globalPropertyDashboard = getAsyncLifecycle(
+  () => import('./dashboard/global-property-dashboard.component'),
+  { moduleName, featureName: 'global-property' },
+);

package/src/components/global-property/modal/delete-global-property-modal.component.tsx

@@ -0,0 +1,71 @@
+import React, { useState } from 'react';
+import { Button, InlineLoading } from '@carbon/react';
+import { showSnackbar } from '@openmrs/esm-framework';
+import { useTranslation } from 'react-i18next';
+
+import { deleteGlobalProperty } from '../hooks/useGlobalProperty';
+
+interface DeleteGlobalPropertyModalProps {
+  close: () => void;
+  property: string;
+  uuid: string;
+  onDeleted: () => void;
+}
+
+const DeleteGlobalPropertyModal: React.FC<DeleteGlobalPropertyModalProps> = ({ close, property, uuid, onDeleted }) => {
+  const { t } = useTranslation();
+  const [isDeleting, setIsDeleting] = useState(false);
+
+  const handleDelete = async () => {
+    setIsDeleting(true);
+    try {
+      await deleteGlobalProperty(uuid);
+      showSnackbar({
+        isLowContrast: true,
+        kind: 'success',
+        title: t('gpDeleted', 'Global property deleted'),
+        subtitle: t('gpDeletedSubtitle', '{{property}} was deleted successfully.', { property }),
+      });
+      onDeleted();
+      close();
+    } catch (error) {
+      showSnackbar({
+        kind: 'error',
+        title: t('gpDeleteError', 'Error deleting global property'),
+        subtitle: error?.message,
+      });
+    } finally {
+      setIsDeleting(false);
+    }
+  };
+
+  return (
+    <>
+      <div className="cds--modal-header">
+        <h3 className="cds--modal-header__heading">{t('deleteGlobalProperty', 'Delete global property')}</h3>
+      </div>
+      <div className="cds--modal-content">
+        <p>
+          {t(
+            'deleteGlobalPropertyConfirmation',
+            'Are you sure you want to delete the global property "{{property}}"?',
+            {
+              property,
+            },
+          )}
+        </p>
+        <p>{t('deleteGlobalPropertyWarning', 'This action cannot be undone.')}</p>
+      </div>
+      <div className="cds--modal-footer">
+        <Button kind="secondary" onClick={close} disabled={isDeleting}>
+          {t('cancel', 'Cancel')}
+        </Button>
+        <Button kind="danger" onClick={handleDelete} disabled={isDeleting}>
+          {isDeleting ? <InlineLoading description={t('deleting', 'Deleting...')} /> : t('delete', 'Delete')}
+        </Button>
+      </div>
+    </>
+  );
+};
+
+export default DeleteGlobalPropertyModal;

package/src/components/global-property/modal/delete-global-property-modal.test.tsx

@@ -0,0 +1,131 @@
+import React from 'react';
+import { render, screen, fireEvent, waitFor, act } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import { vi, describe, it, expect, beforeEach } from 'vitest';
+import DeleteGlobalPropertyModal from './delete-global-property-modal.component';
+
+const mockShowSnackbar = vi.fn();
+const mockDeleteGlobalProperty = vi.fn();
+
+vi.mock('react-i18next', () => ({
+  useTranslation: () => ({ t: (_key: string, fallback: string, opts?: Record<string, unknown>) => fallback }),
+}));
+
+vi.mock('@openmrs/esm-framework', () => ({
+  showSnackbar: (...args: unknown[]) => mockShowSnackbar(...args),
+}));
+
+vi.mock('../hooks/useGlobalProperty', () => ({
+  deleteGlobalProperty: (...args: unknown[]) => mockDeleteGlobalProperty(...args),
+}));
+
+describe('DeleteGlobalPropertyModal', () => {
+  const defaultProps = {
+    close: vi.fn(),
+    property: 'setting.example',
+    uuid: 'uuid-abc',
+    onDeleted: vi.fn(),
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('displays the modal heading', () => {
+    render(<DeleteGlobalPropertyModal {...defaultProps} />);
+    expect(screen.getByText('Delete global property')).toBeInTheDocument();
+  });
+
+  it('shows the property name in the confirmation message', () => {
+    render(<DeleteGlobalPropertyModal {...defaultProps} />);
+    expect(screen.getByText('Are you sure you want to delete the global property "{{property}}"?')).toBeInTheDocument();
+  });
+
+  it('shows a warning that the action cannot be undone', () => {
+    render(<DeleteGlobalPropertyModal {...defaultProps} />);
+    expect(screen.getByText('This action cannot be undone.')).toBeInTheDocument();
+  });
+
+  it('calls close when the Cancel button is clicked', () => {
+    render(<DeleteGlobalPropertyModal {...defaultProps} />);
+    fireEvent.click(screen.getByText('Cancel'));
+    expect(defaultProps.close).toHaveBeenCalledTimes(1);
+  });
+
+  it('does not call onDeleted when Cancel is clicked', () => {
+    render(<DeleteGlobalPropertyModal {...defaultProps} />);
+    fireEvent.click(screen.getByText('Cancel'));
+    expect(defaultProps.onDeleted).not.toHaveBeenCalled();
+  });
+
+  it('calls deleteGlobalProperty with the correct uuid when Delete is clicked', async () => {
+    mockDeleteGlobalProperty.mockResolvedValue(undefined);
+    render(<DeleteGlobalPropertyModal {...defaultProps} />);
+    fireEvent.click(screen.getByText('Delete'));
+    await waitFor(() => {
+      expect(mockDeleteGlobalProperty).toHaveBeenCalledWith('uuid-abc');
+    });
+  });
+
+  it('shows a success snackbar and closes the modal after successful deletion', async () => {
+    mockDeleteGlobalProperty.mockResolvedValue(undefined);
+    render(<DeleteGlobalPropertyModal {...defaultProps} />);
+    fireEvent.click(screen.getByText('Delete'));
+    await waitFor(() => {
+      expect(mockShowSnackbar).toHaveBeenCalledWith(expect.objectContaining({ kind: 'success' }));
+      expect(defaultProps.onDeleted).toHaveBeenCalledTimes(1);
+      expect(defaultProps.close).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  it('shows an error snackbar when deletion fails', async () => {
+    mockDeleteGlobalProperty.mockRejectedValue(new Error('Server error'));
+    render(<DeleteGlobalPropertyModal {...defaultProps} />);
+    fireEvent.click(screen.getByText('Delete'));
+    await waitFor(() => {
+      expect(mockShowSnackbar).toHaveBeenCalledWith(expect.objectContaining({ kind: 'error' }));
+      expect(defaultProps.close).not.toHaveBeenCalled();
+      expect(defaultProps.onDeleted).not.toHaveBeenCalled();
+    });
+  });
+
+  it('disables both buttons while deletion is in progress', async () => {
+    let resolveDelete: () => void;
+    mockDeleteGlobalProperty.mockReturnValue(
+      new Promise<void>((res) => {
+        resolveDelete = res;
+      }),
+    );
+    render(<DeleteGlobalPropertyModal {...defaultProps} />);
+
+    fireEvent.click(screen.getByText('Delete'));
+
+    await waitFor(() => {
+      expect(screen.getByText('Cancel')).toBeDisabled();
+    });
+
+    await act(async () => {
+      resolveDelete!();
+    });
+  });
+
+  it('shows a loading indicator while deletion is in progress', async () => {
+    let resolveDelete: () => void;
+    mockDeleteGlobalProperty.mockReturnValue(
+      new Promise<void>((res) => {
+        resolveDelete = res;
+      }),
+    );
+    render(<DeleteGlobalPropertyModal {...defaultProps} />);
+
+    fireEvent.click(screen.getByText('Delete'));
+
+    await waitFor(() => {
+      expect(screen.getByText('Deleting...')).toBeInTheDocument();
+    });
+
+    await act(async () => {
+      resolveDelete!();
+    });
+  });
+});

package/src/components/global-property/table/global-property-table.component.tsx

@@ -0,0 +1,241 @@
+import React, { useCallback, useMemo, useState } from 'react';
+import {
+  Button,
+  DataTable,
+  OverflowMenu,
+  OverflowMenuItem,
+  Pagination,
+  Table,
+  TableBody,
+  TableCell,
+  TableContainer,
+  TableHead,
+  TableHeader,
+  TableRow,
+  TableToolbar,
+  TableToolbarContent,
+  TableToolbarSearch,
+  Tag,
+  type DataTableHeader,
+} from '@carbon/react';
+import { Add, Upload } from '@carbon/react/icons';
+import { useTranslation } from 'react-i18next';
+import { ErrorCard, launchWorkspace2, showModal, useDebounce, usePaginationInfo } from '@openmrs/esm-framework';
+
+import { useGlobalProperties } from '../hooks/useGlobalProperty';
+import styles from './global-property-table.scss';
+
+const DEFAULT_PAGE_SIZE = 10;
+const PAGE_SIZE_OPTIONS = [10, 20, 50, 100];
+
+type GlobalPropertyRow = {
+  id: string;
+  property: string;
+  value: string;
+};
+
+const GlobalPropertyTable: React.FC = () => {
+  const { t } = useTranslation();
+
+  const [pageSize, setPageSize] = useState(DEFAULT_PAGE_SIZE);
+  const [searchTerm, setSearchTerm] = useState('');
+  const debouncedSearchTerm = useDebounce(searchTerm, 300);
+
+  const {
+    data: globalProperties = [],
+    error,
+    goTo,
+    currentPage,
+    totalCount,
+    mutate,
+  } = useGlobalProperties(pageSize, debouncedSearchTerm);
+
+  const { pageSizes } = usePaginationInfo(DEFAULT_PAGE_SIZE, totalCount, currentPage, globalProperties.length);
+
+  const headers: Array<DataTableHeader> = useMemo(
+    () => [
+      { key: 'property', header: t('property', 'Property') },
+      { key: 'value', header: t('value', 'Value') },
+    ],
+    [t],
+  );
+
+  const tableRows: Array<GlobalPropertyRow> = useMemo(
+    () =>
+      globalProperties.map((gp, idx) => ({
+        id: gp?.uuid ?? `gp-${idx}`,
+        property: gp?.property ?? '',
+        value: gp?.value ?? '',
+      })),
+    [globalProperties],
+  );
+
+  const handleSearchChange = useCallback(
+    (event: React.ChangeEvent<HTMLInputElement> | '', value?: string) => {
+      const searchValue = typeof event === 'string' ? value ?? '' : event.target.value;
+      setSearchTerm(searchValue);
+      if (currentPage !== 1) {
+        goTo(1);
+      }
+    },
+    [currentPage, goTo],
+  );
+
+  const handlePaginationChange = useCallback(
+    ({ page, pageSize: newSize }: { page: number; pageSize: number }) => {
+      if (newSize !== pageSize) {
+        setPageSize(newSize);
+      }
+      goTo(page);
+    },
+    [pageSize, goTo],
+  );
+
+  const openWorkspace = useCallback(
+    (systemSetting?: (typeof globalProperties)[number]) => {
+      launchWorkspace2('global-property-workspace', {
+        systemSetting,
+        mutateGlobalProperty: mutate,
+      });
+    },
+    [globalProperties, mutate],
+  );
+
+  const openUploadImageWorkspace = useCallback(() => {
+    launchWorkspace2('upload-logo-workspace', {
+      mutateGlobalProperty: mutate,
+    });
+  }, [mutate]);
+
+  const handleEdit = useCallback(
+    (row: GlobalPropertyRow) => {
+      const systemSetting = globalProperties.find((gp) => gp.uuid === row.id);
+      openWorkspace(systemSetting);
+    },
+    [globalProperties, openWorkspace],
+  );
+
+  const handleDelete = useCallback(
+    (row: GlobalPropertyRow) => {
+      const dispose = showModal('delete-global-property-modal', {
+        close: () => dispose(),
+        property: row.property,
+        uuid: row.id,
+        onDeleted: () => mutate(),
+      });
+    },
+    [mutate],
+  );
+
+  if (error) {
+    return (
+      <div className={styles.dataTableContainer}>
+        <ErrorCard error={error} headerTitle={t('globalPropertyError', 'Global property')} />
+      </div>
+    );
+  }
+
+  return (
+    <div className={styles.container}>
+      <DataTable size="sm" rows={tableRows} headers={headers} isSortable useZebraStyles>
+        {({
+          rows,
+          headers,
+          getHeaderProps,
+          getRowProps,
+          getBatchActionProps,
+          getToolbarProps,
+          getTableProps,
+          getTableContainerProps,
+        }) => {
+          const batchActionProps = getBatchActionProps();
+
+          return (
+            <TableContainer
+              title={t('globalProperty', 'Global Property')}
+              description={t(
+                'globalPropertyDescription',
+                'A list of all global properties for the system. Filter by search term to find specific properties.',
+              )}
+              {...getTableContainerProps()}>
+              <TableToolbar {...getToolbarProps()}>
+                <TableToolbarContent aria-hidden={batchActionProps.shouldShowBatchActions}>
+                  <TableToolbarSearch
+                    persistent
+                    onChange={handleSearchChange}
+                    placeholder={t('searchForGlobalProperties', 'Search for global properties')}
+                  />
+                  <Button renderIcon={Add} onClick={() => openWorkspace()} size="sm" kind="primary">
+                    {t('addGlobalProperty', 'Add global property')}
+                  </Button>
+                  <Button renderIcon={Upload} onClick={openUploadImageWorkspace} size="sm" kind="tertiary">
+                    {t('uploadImage', 'Upload image')}
+                  </Button>
+                </TableToolbarContent>
+              </TableToolbar>
+
+              <Table {...getTableProps()} aria-label="Global properties">
+                <TableHead>
+                  <TableRow>
+                    {headers.map((header) => (
+                      <TableHeader {...getHeaderProps({ header })}>{header.header}</TableHeader>
+                    ))}
+                    <TableHeader aria-label={t('rowActions', 'Row actions')} />
+                  </TableRow>
+                </TableHead>
+
+                <TableBody>
+                  {rows.map((row, index) => {
+                    return (
+                      <React.Fragment key={row.id}>
+                        <TableRow {...getRowProps({ row })}>
+                          {row.cells.map((cell) => {
+                            if (cell.info.header === 'status') {
+                              return (
+                                <TableCell key={cell.id}>
+                                  <Tag size="sm">{cell.value}</Tag>
+                                </TableCell>
+                              );
+                            }
+                            return <TableCell key={cell.id}>{cell.value}</TableCell>;
+                          })}
+                          <TableCell className="cds--table-column-menu">
+                            <OverflowMenu flipped aria-label="overflow-menu">
+                              <OverflowMenuItem
+                                onClick={() => handleEdit(tableRows[index])}
+                                itemText={t('edit', 'Edit')}
+                              />
+                              <OverflowMenuItem
+                                isDelete
+                                onClick={() => handleDelete(tableRows[index])}
+                                itemText={t('delete', 'Delete')}
+                              />
+                            </OverflowMenu>
+                          </TableCell>
+                        </TableRow>
+                      </React.Fragment>
+                    );
+                  })}
+                </TableBody>
+              </Table>
+            </TableContainer>
+          );
+        }}
+      </DataTable>
+      <Pagination
+        itemsPerPageText={t('itemsPerPage', 'Items per page:')}
+        forwardText={t('nextPage', 'Next page')}
+        backwardText={t('previousPage', 'Previous page')}
+        itemRangeText={(min, max, total) => t('minMaxItems', '{{min}}-{{max}} of {{total}} items', { min, max, total })}
+        pageRangeText={(_current, total) => t('pageRangeText', 'of {{count}} pages', { count: total })}
+        page={currentPage}
+        pageSize={pageSize}
+        pageSizes={pageSizes?.length > 0 ? pageSizes : PAGE_SIZE_OPTIONS}
+        totalItems={totalCount ?? 0}
+        onChange={handlePaginationChange}
+      />
+    </div>
+  );
+};
+
+export default GlobalPropertyTable;