@openmrs/esm-bed-management-app 7.0.3-pre.94

package/src/bed-administration/bed-administration-table.scss

@@ -0,0 +1,112 @@
+@use '@carbon/colors';
+@use '@carbon/layout';
+@use '@carbon/type';
+
+.widgetCard {
+  border: 1px solid colors.$gray-20;
+  margin: layout.$spacing-06;
+
+  :global(.cds--modal-content) {
+    margin-bottom: unset;
+  }
+
+  @media (min-width: 66rem) {
+    :global(.cds--modal-container) {
+      max-height: 100%;
+      width: 60%;
+    }
+  }
+
+  @media (min-width: 42rem) {
+    :global(.cds--modal-container) {
+      max-height: 100%;
+    }
+  }
+}
+
+.flexContainer {
+  display: flex;
+  justify-content: space-between;
+  padding: 0 layout.$spacing-05;
+  margin-top: layout.$spacing-07;
+  margin-left: layout.$spacing-03;
+}
+
+.filterContainer {
+  flex: 1;
+
+  :global(.cds--dropdown__wrapper--inline) {
+    gap: 0;
+  }
+
+  :global(.cds--list-box__menu-icon) {
+    height: layout.$spacing-05;
+  }
+}
+
+.backgroundDataFetchingIndicator {
+  align-items: center;
+  display: flex;
+  justify-content: end;
+}
+
+.tileContainer {
+  background-color: colors.$white-0;
+  border-top: 1px solid colors.$gray-20;
+  padding: layout.$spacing-09 0;
+}
+
+.tile {
+  margin: auto;
+  width: fit-content;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+}
+
+.tileContent {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+}
+
+.content {
+  @include type.type-style('heading-compact-02');
+  color: colors.$gray-70;
+  margin-bottom: layout.$spacing-03;
+}
+
+.helper {
+  @include type.type-style('body-compact-01');
+  color: colors.$gray-70;
+}
+
+.separator {
+  @include type.type-style('body-compact-02');
+  color: colors.$gray-70;
+  width: 80%;
+  margin: layout.$spacing-06 auto;
+  overflow: hidden;
+  text-align: center;
+
+  &::before,
+  &::after {
+    background-color: colors.$gray-40;
+    content: '';
+    display: inline-block;
+    height: 1px;
+    position: relative;
+    vertical-align: middle;
+    width: 50%;
+  }
+
+  &::before {
+    right: layout.$spacing-03;
+    margin-left: -50%;
+  }
+
+  &::after {
+    left: layout.$spacing-03;
+    margin-right: -50%;
+  }
+}

package/src/bed-administration/bed-administration-types.ts

@@ -0,0 +1,20 @@
+export interface BedAdministrationData {
+  bedId: string;
+  description: string;
+  bedRow: string;
+  bedColumn: string;
+  location: {
+    display: string;
+    uuid: string;
+  };
+  occupancyStatus: string;
+  bedType: string;
+}
+export interface BedTypeDataAdministration {
+  name: string;
+  displayName: string;
+  description: string;
+}
+export interface BedTagDataAdministration {
+  name: string;
+}

package/src/bed-administration/bed-administration.resource.ts

@@ -0,0 +1,57 @@
+import { useMemo } from 'react';
+import useSWR from 'swr';
+import { type FetchResponse, openmrsFetch } from '@openmrs/esm-framework';
+import { type BedPostPayload } from '../types';
+
+interface BedForm {
+  bedNumber: string;
+  bedType: string;
+  row: number;
+  column: number;
+  status: string;
+  locationUuid: string;
+}
+
+export async function saveBed({ bedPayload }: { bedPayload: BedPostPayload }): Promise<FetchResponse<BedForm>> {
+  const response: FetchResponse = await openmrsFetch(`/ws/rest/v1/bed`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: bedPayload,
+  });
+  return response;
+}
+
+export function useBedType() {
+  const locationsUrl = `/ws/rest/v1/bedtype`;
+  const { data, error, isLoading } = useSWR<{ data }>(locationsUrl, openmrsFetch);
+
+  const bedTypes = useMemo(() => {
+    const rawData = data?.data?.results ?? [];
+    const uniqueBedTypes = [];
+
+    rawData.forEach((response) => {
+      if (!uniqueBedTypes.some((bedType) => bedType.name === response.name)) {
+        uniqueBedTypes.push(response);
+      }
+    });
+
+    return uniqueBedTypes;
+  }, [data?.data?.results]);
+
+  return { bedTypes: bedTypes ? bedTypes : [], isLoading, error };
+}
+
+export async function editBed({
+  bedPayload,
+  bedId,
+}: {
+  bedPayload: BedPostPayload;
+  bedId: string;
+}): Promise<FetchResponse<BedForm>> {
+  const response: FetchResponse = await openmrsFetch(`/ws/rest/v1/bed/${bedId}`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: bedPayload,
+  });
+  return response;
+}

package/src/bed-administration/edit-bed-form.component.tsx

@@ -0,0 +1,89 @@
+import React, { useCallback } from 'react';
+import { useTranslation } from 'react-i18next';
+import { showToast, showNotification } from '@openmrs/esm-framework';
+
+import type { BedFormData } from '../types';
+import { useBedType, editBed } from './bed-administration.resource';
+import BedAdministrationForm from './bed-administration-form.component';
+import { type BedAdministrationData } from './bed-administration-types';
+import { useLocationsWithAdmissionTag } from '../summary/summary.resource';
+
+interface EditBedFormProps {
+  showModal: boolean;
+  onModalChange: (showModal: boolean) => void;
+  editData: BedFormData;
+  mutate: () => any;
+}
+
+const EditBedForm: React.FC<EditBedFormProps> = ({ showModal, onModalChange, editData, mutate }) => {
+  const { t } = useTranslation();
+  const { data: admissionLocations } = useLocationsWithAdmissionTag();
+
+  const headerTitle = t('editBed', 'Edit bed');
+  const occupancyStatuses = ['Available', 'Occupied'];
+  const { bedTypes } = useBedType();
+  const availableBedTypes = bedTypes ? bedTypes : [];
+  const handleCreateQuestion = useCallback(
+    (formData: BedAdministrationData) => {
+      const bedUuid = editData.uuid;
+      const {
+        bedId = editData.bedNumber,
+        description = editData.description,
+        occupancyStatus = editData.status,
+        bedRow = editData.row.toString(),
+        bedColumn = editData.column.toString(),
+        location: { uuid: bedLocation = editData.location.uuid },
+        bedType = editData.bedType.name,
+      } = formData;
+      const bedPayload = {
+        bedNumber: bedId,
+        bedType,
+        description,
+        status: occupancyStatus.toUpperCase(),
+        row: parseInt(bedRow),
+        column: parseInt(bedColumn),
+        locationUuid: bedLocation,
+      };
+      editBed({ bedPayload, bedId: bedUuid })
+        .then(() => {
+          showToast({
+            title: t('formSaved', 'Bed saved'),
+            kind: 'success',
+            critical: true,
+            description: bedPayload.bedNumber + ' ' + t('saveSuccessMessage', 'was saved successfully.'),
+          });
+
+          mutate();
+          onModalChange(false);
+        })
+        .catch((error) => {
+          showNotification({
+            title: t('errorCreatingForm', 'Error creating bed'),
+            kind: 'error',
+            critical: true,
+            description: error?.message,
+          });
+          onModalChange(false);
+        });
+      onModalChange(false);
+    },
+    [onModalChange, mutate, editData, t],
+  );
+
+  return (
+    <>
+      <BedAdministrationForm
+        onModalChange={onModalChange}
+        allLocations={admissionLocations}
+        availableBedTypes={availableBedTypes}
+        showModal={showModal}
+        handleCreateQuestion={handleCreateQuestion}
+        headerTitle={headerTitle}
+        occupancyStatuses={occupancyStatuses}
+        initialData={editData}
+      />
+    </>
+  );
+};
+
+export default EditBedForm;

package/src/bed-administration/new-bed-form.component.tsx

@@ -0,0 +1,96 @@
+import React, { useCallback } from 'react';
+import { useTranslation } from 'react-i18next';
+import { showToast, showNotification } from '@openmrs/esm-framework';
+
+import type { BedFormData } from '../types';
+import { useBedType, saveBed } from './bed-administration.resource';
+import BedAdministrationForm from './bed-administration-form.component';
+import { useLocationsWithAdmissionTag } from '../summary/summary.resource';
+import { type BedAdministrationData } from './bed-administration-types';
+
+interface NewBedFormProps {
+  showModal: boolean;
+  onModalChange: (showModal: boolean) => void;
+  mutate: () => any;
+}
+
+const NewBedForm: React.FC<NewBedFormProps> = ({ showModal, onModalChange, mutate }) => {
+  const { t } = useTranslation();
+  const { data: admissionLocations } = useLocationsWithAdmissionTag();
+  const headerTitle = t('createNewBed', 'Create a new bed');
+  const occupancyStatuses = ['Available', 'Occupied'];
+  const { bedTypes } = useBedType();
+  const availableBedTypes = bedTypes ? bedTypes : [];
+
+  const initialData: BedFormData = {
+    id: 0,
+    uuid: '',
+    bedNumber: '',
+    status: null,
+    description: '',
+    row: 0,
+    column: 0,
+    location: {
+      display: '',
+      uuid: '',
+    },
+    bedType: null,
+  };
+
+  const handleCreateQuestion = useCallback(
+    (formData: BedAdministrationData) => {
+      const { bedId, description, occupancyStatus, bedRow, bedColumn, location, bedType } = formData;
+
+      const bedObject = {
+        bedNumber: bedId,
+        bedType,
+        description,
+        status: occupancyStatus.toUpperCase(),
+        row: parseInt(bedRow.toString()),
+        column: parseInt(bedColumn.toString()),
+        locationUuid: location.uuid,
+      };
+
+      saveBed({ bedPayload: bedObject })
+        .then(() => {
+          showToast({
+            title: t('formCreated', 'New bed created'),
+            kind: 'success',
+            critical: true,
+            description: `Bed ${bedId} was created successfully.`,
+          });
+
+          mutate();
+          onModalChange(false);
+        })
+        .catch((error) => {
+          showNotification({
+            title: t('errorCreatingForm', 'Error creating bed'),
+            kind: 'error',
+            critical: true,
+            description: error?.message,
+          });
+          onModalChange(false);
+        });
+      onModalChange(false);
+    },
+    [onModalChange, mutate, t],
+  );
+
+  return (
+    <>
+      <BedAdministrationForm
+        onModalChange={onModalChange}
+        allLocations={admissionLocations}
+        availableBedTypes={availableBedTypes}
+        showModal={showModal}
+        handleCreateQuestion={handleCreateQuestion}
+        headerTitle={headerTitle}
+        occupancyStatuses={occupancyStatuses}
+        initialData={initialData}
+      />
+    </>
+  );
+};
+
+export default NewBedForm;

package/src/bed-tag/bed-tag-administration-table.component.tsx

@@ -0,0 +1,192 @@
+import React, { useMemo, useState } from 'react';
+import { useTranslation } from 'react-i18next';
+import {
+  Button,
+  DataTable,
+  DataTableSkeleton,
+  InlineLoading,
+  Pagination,
+  Table,
+  TableBody,
+  TableCell,
+  TableContainer,
+  TableHead,
+  TableHeader,
+  TableRow,
+  Tile,
+} from '@carbon/react';
+import { Add, Edit } from '@carbon/react/icons';
+import { ErrorState, isDesktop as desktopLayout, useLayoutType } from '@openmrs/esm-framework';
+import type { BedTagData } from '../types';
+import { useBedTag } from '../summary/summary.resource';
+import Header from '../header/header.component';
+import styles from '../bed-administration/bed-administration-table.scss';
+import { CardHeader } from '../card-header/card-header.component';
+import BedTagForm from './new-tag-form.component';
+import EditBedTagForm from './edit-tag-form.component';
+
+const BedTagAdministrationTable: React.FC = () => {
+  const { t } = useTranslation();
+  const headerTitle = t('bedTag', 'Bed Tag');
+  const layout = useLayoutType();
+  const isTablet = layout === 'tablet';
+  const responsiveSize = isTablet ? 'lg' : 'sm';
+  const isDesktop = desktopLayout(layout);
+  const [isBedDataLoading] = useState(false);
+  const [showBedTagsModal, setAddBedTagsModal] = useState(false);
+  const [showEditBedModal, setShowEditBedModal] = useState(false);
+  const [editData, setEditData] = useState<BedTagData>();
+  const [currentPage, setCurrentPage] = useState(1);
+  const { bedTypeData, isError, loading, validate, mutate } = useBedTag();
+  const [pageSize, setPageSize] = useState(10);
+
+  const tableHeaders = [
+    {
+      header: t('ids', 'Id'),
+      key: 'ids',
+    },
+    {
+      header: t('name', 'Name'),
+      key: 'name',
+    },
+    {
+      header: t('actions', 'Actions'),
+      key: 'actions',
+    },
+  ];
+
+  const tableRows = useMemo(() => {
+    return bedTypeData?.map((entry) => ({
+      id: entry.uuid,
+      ids: entry.id,
+      name: entry?.name,
+      actions: (
+        <>
+          <Button
+            enterDelayMs={300}
+            renderIcon={Edit}
+            onClick={(e) => {
+              e.preventDefault();
+              setEditData(entry);
+              setShowEditBedModal(true);
+              setAddBedTagsModal(false);
+            }}
+            kind={'ghost'}
+            iconDescription={t('editBedTag', 'Edit Bed Tag')}
+            hasIconOnly
+            size={responsiveSize}
+            tooltipAlignment="start"
+          />
+        </>
+      ),
+    }));
+  }, [responsiveSize, bedTypeData, t]);
+
+  if (isBedDataLoading || loading) {
+    return (
+      <>
+        <Header route="Bed Tag" />
+        <div className={styles.widgetCard}>
+          <DataTableSkeleton role="progressbar" compact={isDesktop} zebra />
+        </div>
+      </>
+    );
+  }
+
+  if (isError) {
+    return (
+      <>
+        <Header route="Bed Tag" />
+        <div className={styles.widgetCard}>
+          <ErrorState error={isError} headerTitle={headerTitle} />
+        </div>
+      </>
+    );
+  }
+
+  return (
+    <>
+      <Header route="Bed Tag" />
+
+      <div className={styles.widgetCard}>
+        {showBedTagsModal ? (
+          <BedTagForm onModalChange={setAddBedTagsModal} showModal={showBedTagsModal} mutate={mutate} />
+        ) : null}
+        {showEditBedModal ? (
+          <EditBedTagForm
+            onModalChange={setShowEditBedModal}
+            showModal={showEditBedModal}
+            editData={editData}
+            mutate={mutate}
+          />
+        ) : null}
+        <CardHeader title={headerTitle}>
+          <span className={styles.backgroundDataFetchingIndicator}>
+            <span>{validate ? <InlineLoading /> : null}</span>
+          </span>
+          {bedTypeData?.length ? (
+            <Button
+              kind="ghost"
+              renderIcon={(props) => <Add size={16} {...props} />}
+              onClick={() => setAddBedTagsModal(true)}>
+              {t('addBedTag', 'Add Bed Tag')}
+            </Button>
+          ) : null}
+        </CardHeader>
+        <DataTable rows={tableRows} headers={tableHeaders} isSortable size={isTablet ? 'lg' : 'sm'} useZebraStyles>
+          {({ rows, headers, getTableProps }) => (
+            <TableContainer>
+              <Table {...getTableProps()}>
+                <TableHead>
+                  <TableRow>
+                    {headers.map((header) => (
+                      <TableHeader>{header.header?.content ?? header.header}</TableHeader>
+                    ))}
+                  </TableRow>
+                </TableHead>
+                <TableBody>
+                  {rows.map((row) => (
+                    <TableRow key={row.id}>
+                      {row.cells.map((cell) => (
+                        <TableCell key={cell.id}>{cell.value?.content ?? cell.value}</TableCell>
+                      ))}
+                    </TableRow>
+                  ))}
+                </TableBody>
+              </Table>
+              {rows.length === 0 ? (
+                <div className={styles.tileContainer}>
+                  <Tile className={styles.tile}>
+                    <div className={styles.tileContent}>
+                      <p className={styles.content}>{t('No data', 'No data to display')}</p>
+                      <p className={styles.helper}>{t('checkFilters', 'Check the filters above')}</p>
+                    </div>
+                    <p className={styles.separator}>{t('or', 'or')}</p>
+                    <Button
+                      kind="ghost"
+                      size="sm"
+                      renderIcon={(props) => <Add size={16} {...props} />}
+                      onClick={() => setAddBedTagsModal(true)}>
+                      {t('bedTag', 'Add Bed Tag')}
+                    </Button>
+                  </Tile>
+                </div>
+              ) : null}
+              <Pagination
+                page={currentPage}
+                pageSize={pageSize}
+                pageSizes={[10, 20, 30, 40, 50]}
+                totalItems={bedTypeData.length}
+                onChange={({ page, pageSize }) => {
+                  setCurrentPage(page);
+                  setPageSize(pageSize);
+                }}
+              />
+            </TableContainer>
+          )}
+        </DataTable>
+      </div>
+    </>
+  );
+};
+export default BedTagAdministrationTable;

package/src/bed-tag/bed-tags-admin-form.component.tsx

@@ -0,0 +1,127 @@
+import React, { useState } from 'react';
+import { z } from 'zod';
+import { useForm, Controller } from 'react-hook-form';
+import { zodResolver } from '@hookform/resolvers/zod';
+import {
+  Button,
+  ComposedModal,
+  Form,
+  FormGroup,
+  ModalBody,
+  ModalFooter,
+  ModalHeader,
+  Stack,
+  TextInput,
+  InlineNotification,
+} from '@carbon/react';
+import { useTranslation } from 'react-i18next';
+import { type Location } from '@openmrs/esm-framework';
+import type { BedTagData } from '../types';
+
+const BedTagAdministrationSchema = z.object({
+  name: z.string().max(255),
+});
+
+interface BedTagAdministrationFormProps {
+  showModal: boolean;
+  onModalChange: (showModal: boolean) => void;
+  availableBedTypes: Array<BedTagData>;
+  allLocations: Location[];
+  handleCreateQuestion?: (formData: BedTagData) => void;
+  handleDeleteBedTag?: () => void;
+  headerTitle: string;
+  initialData: BedTagData;
+}
+
+interface ErrorType {
+  message: string;
+}
+
+const BedTagsAdministrationForm: React.FC<BedTagAdministrationFormProps> = ({
+  showModal,
+  onModalChange,
+  handleCreateQuestion,
+  headerTitle,
+  initialData,
+}) => {
+  const { t } = useTranslation();
+
+  const [showErrorNotification, setShowErrorNotification] = useState(false);
+  const [formStateError, setFormStateError] = useState('');
+
+  const {
+    handleSubmit,
+    control,
+    formState: { isDirty },
+  } = useForm<BedTagData>({
+    mode: 'all',
+    resolver: zodResolver(BedTagAdministrationSchema),
+    defaultValues: {
+      name: initialData.name || '',
+    },
+  });
+
+  const onSubmit = (formData: BedTagData) => {
+    const result = BedTagAdministrationSchema.safeParse(formData);
+    if (result.success) {
+      setShowErrorNotification(false);
+      handleCreateQuestion(formData);
+    }
+  };
+
+  const onError = (error: { [key: string]: ErrorType }) => {
+    setFormStateError(Object.entries(error)[0][1].message);
+    setShowErrorNotification(true);
+  };
+
+  return (
+    <ComposedModal open={showModal} onClose={() => onModalChange(false)} preventCloseOnClickOutside>
+      <ModalHeader title={headerTitle} />
+      <Form onSubmit={handleSubmit(onSubmit, onError)}>
+        <ModalBody hasScrollingContent>
+          <Stack gap={3}>
+            <FormGroup legendText={''}>
+              <Controller
+                name="name"
+                control={control}
+                render={({ field, fieldState }) => (
+                  <>
+                    <TextInput
+                      id="bedTag"
+                      labelText={t('bedTag', 'Bed Tag Name')}
+                      placeholder={t('bedTagPlaceholder', '')}
+                      invalidText={fieldState.error?.message}
+                      {...field}
+                    />
+                  </>
+                )}
+              />
+            </FormGroup>
+
+            {showErrorNotification && (
+              <InlineNotification
+                lowContrast
+                title={t('error', 'Error')}
+                style={{ minWidth: '100%', margin: '0', padding: '0' }}
+                role="alert"
+                kind="error"
+                subtitle={t('pleaseFillField', formStateError) + '.'}
+                onClose={() => setShowErrorNotification(false)}
+              />
+            )}
+          </Stack>
+        </ModalBody>
+        <ModalFooter>
+          <Button onClick={() => onModalChange(false)} kind="secondary">
+            {t('cancel', 'Cancel')}
+          </Button>
+          <Button disabled={!isDirty} type="submit">
+            <span>{t('save', 'Save')}</span>
+          </Button>
+        </ModalFooter>
+      </Form>
+    </ComposedModal>
+  );
+};
+
+export default BedTagsAdministrationForm;