@ampath/esm-dha-workflow-app 4.0.0-next.44 → 4.0.0-next.445

package/src/billing/dashboard/v2/facility-bills/preauths-datatables/pending-preauths.component.tsx

@@ -0,0 +1,132 @@
+import React, { useMemo, useState } from "react";
+import {
+    Button,
+    DataTable,
+    DataTableRow,
+    InlineLoading,
+    Pagination,
+    Table,
+    TableBody,
+    TableCell,
+    TableHead,
+    TableHeader,
+    TableRow,
+} from '@carbon/react';
+import { usePagination } from '@openmrs/esm-framework';
+import { useFacilityPreauths } from "../../../../billing-claims.resource";
+
+interface PendingPreauthsProps {
+    locationUuid: string,
+    billingDate: string
+}
+const PendingPreauths: React.FC<PendingPreauthsProps> = ({ locationUuid, billingDate }) => {
+    const { facilityPreauths, isLoading, error } = useFacilityPreauths(locationUuid, billingDate);
+    const rows = facilityPreauths ?? [];
+
+    const tableRows = useMemo(
+        () =>
+            rows.map((preauth) => ({
+                id: preauth.order_no,
+                orderNo: preauth.order_no,
+                patientName: preauth.patient_name,
+                crNumber: preauth.cr_no,
+                interventionCode: preauth.intervention_code,
+                status: preauth.status,
+                billDate: preauth.bill_date,
+                consentToken: preauth.consent_token ?? 'None',
+                normalPreauth: preauth.normal_preauth ? 'Yes' : 'No',
+                electivePreauth: preauth.elective_preauth ? 'Yes' : 'No',
+            })),
+        [rows],
+    );
+
+    const [currentPageSize, setPageSize] = useState(10);
+    const pageSizes = [10, 20, 30];
+    const { goTo, results: paginatedRows, currentPage } = usePagination(tableRows, currentPageSize);
+
+    const headers = [
+        { key: 'orderNo', id: 'orderNo', header: 'Order #' },
+        { key: 'patientName', id: 'patientName', header: 'Patient' },
+        { key: 'crNumber', id: 'crNumber', header: 'CR number' },
+        { key: 'interventionCode', id: 'interventionCode', header: 'Intervention' },
+        { key: 'status', id: 'status', header: 'Status' },
+        { key: 'billDate', id: 'billDate', header: 'Bill date' },
+        { key: 'consentToken', id: 'consentToken', header: 'Consent token' },
+        { key: 'normalPreauth', id: 'normalPreauth', header: 'Normal preauth' },
+        { key: 'electivePreauth', id: 'electivePreauth', header: 'Elective preauth' },
+        { key: 'action', id: 'action', header: 'Action' },
+    ];
+
+    if (isLoading) {
+        return <InlineLoading description="Loading pending preauthorisations" />;
+    }
+
+    if (error) {
+        return <div>Failed to load pending preauthorisations.</div>;
+    }
+
+    if (!rows.length) {
+        return <div>No pending preauthorisations found.</div>;
+    }
+
+    function handleAddPreauth(_row: DataTableRow<any[]>): void {
+        // Prefer the Preauthorizations tab raise queue (PreauthList).
+    }
+
+    return (
+        <>
+            <DataTable rows={paginatedRows} headers={headers}>
+                {({ rows, headers, getTableProps, getHeaderProps, getRowProps, getCellProps }) => (
+                    <Table size="sm" useZebraStyles aria-label="pending preauthorisations" {...getTableProps()}>
+                        <TableHead>
+                            <TableRow>
+                                {headers.map((header) => (
+                                    <TableHeader key={header.key} {...getHeaderProps({ header })}>
+                                        {header.header}
+                                    </TableHeader>
+                                ))}
+                            </TableRow>
+                        </TableHead>
+                        <TableBody>
+                            {rows.map((row) => (
+                                <TableRow key={row.id} {...getRowProps({ row })}>
+                                    {row.cells.map((cell) => {
+                                        if (cell.info.header === 'action') {
+                                            return (
+                                                <TableCell key={cell.id} {...getCellProps({ cell })}>
+                                                    <Button kind="primary" size="sm" onClick={() => handleAddPreauth(row)}>
+                                                        Add preauth
+                                                    </Button>
+                                                </TableCell>
+                                            );
+                                        }
+
+                                        return (
+                                            <TableCell key={cell.id} {...getCellProps({ cell })}>
+                                                {cell.value}
+                                            </TableCell>
+                                        );
+                                    })}
+                                </TableRow>
+                            ))}
+                        </TableBody>
+                    </Table>
+                )}
+            </DataTable>
+            <Pagination
+                backwardText="Previous page"
+                forwardText="Next page"
+                page={currentPage}
+                pageSize={currentPageSize}
+                pageSizes={pageSizes}
+                totalItems={tableRows.length}
+                onChange={({ page, pageSize }) => {
+                    if (pageSize !== currentPageSize) setPageSize(pageSize);
+                    if (page !== currentPage) goTo(page);
+                }}
+            />
+        </>
+    );
+}
+
+export default PendingPreauths;

package/src/billing/dashboard/v2/facility-bills/preauths-datatables/preauth-preview-table.component.tsx

@@ -0,0 +1,267 @@
+import React, { useCallback, useMemo, useState } from 'react';
+import {
+  Button,
+  DataTable,
+  InlineLoading,
+  Pagination,
+  Table,
+  TableBody,
+  TableCell,
+  TableHead,
+  TableHeader,
+  TableRow,
+  Tag,
+} from '@carbon/react';
+import { Renew } from '@carbon/react/icons';
+import { showSnackbar, usePagination } from '@openmrs/esm-framework';
+import {
+  isAwaitingDoctorApproval,
+  isPreauthNeedsClarification,
+  resendPreauthDoctorConsent,
+  type PreauthPreviewRow,
+} from '../../../../../claims/claims.resource';
+import { statusMeta } from '../claim-status';
+
+interface PreauthPreviewTableProps {
+  rows: PreauthPreviewRow[];
+  locationUuid: string;
+  loading?: boolean;
+  onRefresh: () => void;
+}
+
+const PreauthPreviewTable: React.FC<PreauthPreviewTableProps> = ({
+  rows,
+  locationUuid,
+  loading,
+  onRefresh,
+}) => {
+  const [resendingId, setResendingId] = useState<string | null>(null);
+  const [currentPageSize, setPageSize] = useState(10);
+  const pageSizes = [10, 20, 30];
+
+  const tableRows = useMemo(
+    () =>
+      rows.map((r) => ({
+        id: r.id,
+        patient: r.memberName || '—',
+        memberId: r.memberIdentifier || '—',
+        intervention: r.interventionCode
+          ? `${r.interventionCode}${r.interventionName ? ` · ${r.interventionName}` : ''}`
+          : '—',
+        preauthType: r.preauthType || '—',
+        status: r.status || '—',
+        doctor: r.doctorName || '—',
+        token: r.preauthToken || r.consentToken || '—',
+        serviceStart: r.serviceStart
+          ? r.serviceStart.replace('T', ' ').slice(0, 19)
+          : '—',
+        notes: r.notes || '',
+        raw: r,
+      })),
+    [rows],
+  );
+
+  const { goTo, results: paginatedRows, currentPage } = usePagination(tableRows, currentPageSize);
+
+  const headers = [
+    { key: 'patient', header: 'Patient' },
+    { key: 'memberId', header: 'Member ID' },
+    { key: 'intervention', header: 'Intervention' },
+    { key: 'preauthType', header: 'Type' },
+    { key: 'status', header: 'Status' },
+    { key: 'notes', header: 'Notes' },
+    { key: 'doctor', header: 'Doctor' },
+    { key: 'token', header: 'Preauth token' },
+    { key: 'serviceStart', header: 'Service start' },
+    { key: 'action', header: 'Action' },
+  ];
+
+  const handleResend = useCallback(
+    async (row: PreauthPreviewRow) => {
+      if (!row.practitionerRegistrationNumber) {
+        showSnackbar({
+          kind: 'error',
+          title: 'Missing doctor registration',
+          subtitle: 'No practitioner registration number on this preauth doctor profile.',
+        });
+        return;
+      }
+      if (!row.interventionCode) {
+        showSnackbar({
+          kind: 'error',
+          title: 'Missing intervention',
+          subtitle: 'Cannot resend doctor consent without an intervention code.',
+        });
+        return;
+      }
+      setResendingId(row.id);
+      try {
+        await resendPreauthDoctorConsent({
+          practitionerRegistrationNumber: row.practitionerRegistrationNumber,
+          consentToken: row.consentToken,
+          interventionCode: row.interventionCode,
+          locationUuid,
+        });
+        showSnackbar({
+          kind: 'success',
+          title: 'Doctor consent resent',
+          subtitle: 'The doctor should receive another SMS approval request.',
+        });
+        onRefresh();
+      } catch (e) {
+        showSnackbar({
+          kind: 'error',
+          title: 'Resend failed',
+          subtitle: String(e ?? 'Could not resend doctor consent'),
+        });
+      } finally {
+        setResendingId(null);
+      }
+    },
+    [locationUuid, onRefresh],
+  );
+
+  if (loading) {
+    return <InlineLoading description="Loading preauthorisations…" />;
+  }
+
+  if (!rows.length) {
+    return <div>No preauthorisations in this status for the selected date.</div>;
+  }
+
+  return (
+    <>
+      <div style={{ display: 'flex', justifyContent: 'flex-end', marginBottom: '0.5rem' }}>
+        <Button kind="ghost" size="sm" renderIcon={Renew} onClick={onRefresh}>
+          Refresh
+        </Button>
+      </div>
+      <DataTable rows={paginatedRows} headers={headers}>
+        {({ rows: dtRows, headers: dtHeaders, getTableProps, getHeaderProps, getRowProps, getCellProps }) => (
+          <Table size="sm" useZebraStyles aria-label="preauthorisations" {...getTableProps()}>
+            <TableHead>
+              <TableRow>
+                {dtHeaders.map((header) => (
+                  <TableHeader key={header.key} {...getHeaderProps({ header })}>
+                    {header.header}
+                  </TableHeader>
+                ))}
+              </TableRow>
+            </TableHead>
+            <TableBody>
+              {dtRows.map((row) => {
+                const source = tableRows.find((r) => r.id === row.id)?.raw;
+                return (
+                  <TableRow key={row.id} {...getRowProps({ row })}>
+                    {row.cells.map((cell) => {
+                      if (cell.info.header === 'status') {
+                        const statusValue = String(cell.value);
+                        const meta = statusMeta(statusValue);
+                        return (
+                          <TableCell key={cell.id} {...getCellProps({ cell })}>
+                            <Tag
+                              size="sm"
+                              type={
+                                isAwaitingDoctorApproval(source)
+                                  ? 'magenta'
+                                  : isPreauthNeedsClarification(statusValue)
+                                    ? 'magenta'
+                                    : String(cell.value).includes('FINAL')
+                                      ? 'green'
+                                      : meta.tag
+                              }
+                              title={statusValue}
+                            >
+                              {isPreauthNeedsClarification(statusValue)
+                                ? 'Needs clarification'
+                                : statusValue}
+                            </Tag>
+                          </TableCell>
+                        );
+                      }
+                      if (cell.info.header === 'notes') {
+                        const note = String(cell.value || '').trim();
+                        return (
+                          <TableCell key={cell.id} {...getCellProps({ cell })}>
+                            {note ? (
+                              <span
+                                style={{
+                                  display: 'block',
+                                  maxWidth: '22rem',
+                                  whiteSpace: 'pre-wrap',
+                                  wordBreak: 'break-word',
+                                  fontSize: '0.75rem',
+                                  lineHeight: 1.3,
+                                }}
+                                title={note}
+                              >
+                                {note}
+                              </span>
+                            ) : (
+                              '—'
+                            )}
+                          </TableCell>
+                        );
+                      }
+                      if (cell.info.header === 'preauthType') {
+                        return (
+                          <TableCell key={cell.id} {...getCellProps({ cell })}>
+                            <Tag size="sm" type="purple">
+                              {String(cell.value)}
+                            </Tag>
+                          </TableCell>
+                        );
+                      }
+                      if (cell.info.header === 'action') {
+                        const canResend = source && isAwaitingDoctorApproval(source);
+                        return (
+                          <TableCell key={cell.id} {...getCellProps({ cell })}>
+                            {canResend ? (
+                              <Button
+                                kind="tertiary"
+                                size="sm"
+                                disabled={resendingId === source.id}
+                                onClick={() => handleResend(source)}
+                              >
+                                {resendingId === source.id ? (
+                                  <InlineLoading description="Resending…" />
+                                ) : (
+                                  'Resend doctor consent'
+                                )}
+                              </Button>
+                            ) : (
+                              '—'
+                            )}
+                          </TableCell>
+                        );
+                      }
+                      return (
+                        <TableCell key={cell.id} {...getCellProps({ cell })}>
+                          {cell.value}
+                        </TableCell>
+                      );
+                    })}
+                  </TableRow>
+                );
+              })}
+            </TableBody>
+          </Table>
+        )}
+      </DataTable>
+      <Pagination
+        backwardText="Previous page"
+        forwardText="Next page"
+        page={currentPage}
+        pageSize={currentPageSize}
+        pageSizes={pageSizes}
+        totalItems={tableRows.length}
+        onChange={({ page, pageSize }) => {
+          if (pageSize !== currentPageSize) setPageSize(pageSize);
+          if (page !== currentPage) goTo(page);
+        }}
+      />
+    </>
+  );
+};
+
+export default PreauthPreviewTable;

package/src/billing/dashboard/v2/facility-bills/preauths.component.tsx

@@ -0,0 +1,130 @@
+import React, { useCallback, useEffect, useMemo, useState } from 'react';
+import { Tab, TabList, TabPanel, TabPanels, Tabs } from '@carbon/react';
+import { claimVisitToken, useFacilityClaimVisits } from '../../../billing-claims.resource';
+import { fetchPreauthPreviewRowsForTokens, type PreauthPreviewRow } from '../../../../claims/claims.resource';
+import { PREAUTH_BUCKETS, preauthBucketKeyForStatus, type StatusBucket } from './claim-status';
+import PreauthPreviewTable from './preauths-datatables/preauth-preview-table.component';
+import styles from './facility-bills.component.scss';
+
+const defaultBucketKey = (buckets: StatusBucket[]): string =>
+  (buckets.find((b) => b.key === 'pending') ?? buckets[0])?.key ?? '';
+
+interface PreauthsProps {
+  locationUuid: string;
+  billingDate: string;
+}
+
+/**
+ * Preauthorisations tab — lists HIE preauths from GET /pre-auth/preview
+ * (one call per claim-visit consent token for the selected date).
+ * Pending rows that need doctor SMS approval can resend doctor consent.
+ */
+const Preauths: React.FC<PreauthsProps> = ({ locationUuid, billingDate }) => {
+  const [statusFilter, setStatusFilter] = useState<string>(() => defaultBucketKey(PREAUTH_BUCKETS));
+  const [rows, setRows] = useState<PreauthPreviewRow[]>([]);
+  const [loadingPreview, setLoadingPreview] = useState(false);
+
+  const {
+    claimVisits,
+    loading: visitsLoading,
+    reload: reloadVisits,
+  } = useFacilityClaimVisits(locationUuid, billingDate);
+
+  // `force` skips the short cache that stops the several places reading this endpoint from
+  // each paying for the same call. Refresh is someone asking for the current answer, so it
+  // goes to the HIE; the load that happens on its own is content to share.
+  const loadPreviews = useCallback(
+    async (force = false) => {
+      if (!locationUuid) return;
+      const tokens = (claimVisits ?? []).map(claimVisitToken).filter(Boolean);
+      if (!tokens.length) {
+        setRows([]);
+        return;
+      }
+      setLoadingPreview(true);
+      try {
+        const previewRows = await fetchPreauthPreviewRowsForTokens(tokens, locationUuid, { force });
+        setRows(previewRows);
+      } finally {
+        setLoadingPreview(false);
+      }
+    },
+    [claimVisits, locationUuid],
+  );
+
+  useEffect(() => {
+    if (visitsLoading) return;
+    loadPreviews();
+  }, [visitsLoading, loadPreviews]);
+
+  const handleRefresh = useCallback(() => {
+    reloadVisits();
+    loadPreviews(true);
+  }, [reloadVisits, loadPreviews]);
+
+  const counts = useMemo(() => {
+    const map: Record<string, number> = {};
+    for (const bucket of PREAUTH_BUCKETS) {
+      map[bucket.key] = 0;
+    }
+    for (const row of rows) {
+      const key = preauthBucketKeyForStatus(row.status);
+      map[key] = (map[key] ?? 0) + 1;
+    }
+    return map;
+  }, [rows]);
+
+  const filteredRows = useMemo(() => {
+    if (!statusFilter) return rows;
+    return rows.filter((r) => preauthBucketKeyForStatus(r.status) === statusFilter);
+  }, [rows, statusFilter]);
+
+  const statusTabItems: StatusBucket[] = [...PREAUTH_BUCKETS, { key: '', label: 'All', statuses: [] }];
+  const statusTabIndex = Math.max(
+    0,
+    statusTabItems.findIndex((b) => b.key === statusFilter),
+  );
+  const countPill = (key: string) => <span className={styles.pill}>{key ? (counts[key] ?? 0) : rows.length}</span>;
+
+  const loading = visitsLoading || loadingPreview;
+
+  return (
+    // Not `.panel`: the Preauthorizations tab that renders this has already drawn the box,
+    // and a second one around the same table put a border inside a border. No heading or
+    // blurb either — the dashboard tab names this, and its hint says what the two views
+    // are for, including the doctor-consent resend that paragraph used to explain.
+    <div className={styles.subPanel}>
+      <Tabs
+        selectedIndex={statusTabIndex}
+        onChange={({ selectedIndex }) => setStatusFilter(statusTabItems[selectedIndex]?.key ?? '')}
+      >
+        <TabList aria-label="Preauth statuses" className={styles.statusTabs} scrollDebounceWait={200}>
+          {statusTabItems.map((bucket) => (
+            <Tab key={bucket.key || 'all'}>
+              {bucket.label}
+              {countPill(bucket.key)}
+            </Tab>
+          ))}
+        </TabList>
+        <TabPanels>
+          {statusTabItems.map((bucket) => (
+            <TabPanel key={bucket.key || 'all'}>
+              {statusFilter === bucket.key ? (
+                <div className={styles.tableCard}>
+                  <PreauthPreviewTable
+                    rows={filteredRows}
+                    locationUuid={locationUuid}
+                    loading={loading}
+                    onRefresh={handleRefresh}
+                  />
+                </div>
+              ) : null}
+            </TabPanel>
+          ))}
+        </TabPanels>
+      </Tabs>
+    </div>
+  );
+};
+
+export default Preauths;

package/src/billing/dashboard/v2/inpatient-requests/inpatient-requests.component.scss

@@ -0,0 +1,22 @@
+.inpatientRequestsLayout{
+    display: flex;
+    flex-direction: column;
+    width: 100%;
+    padding: 5px 5px;
+    row-gap: 5px;
+    .inpatientRequestsHeader{
+        display: flex;
+        flex-direction: row;
+        width: 100%;
+        padding: 10px 10px;
+    }
+}
+.headerCol{
+    width: 30%;
+}
+.btnContainer{
+    display: flex;
+    flex-direction: row;
+    width: 100%;
+    column-gap: 3px;
+}