@ampath/esm-dha-workflow-app 4.0.0-next.33 → 4.0.0-next.331

package/src/shared/services/billing.resource.ts

@@ -0,0 +1,75 @@
+import { openmrsFetch, restBaseUrl } from '@openmrs/esm-framework';
+import { type CreateBillDto, type BillableService, type PaymentMode, type CashPoint } from '../types';
+import { getHieBaseUrl } from '../utils/get-base-url';
+import { postJson } from '../../registry/registry.resource';
+import dayjs from 'dayjs';
+
+export async function fetchPaymentModes(): Promise<PaymentMode[]> {
+  const paymentModeUrl = `${restBaseUrl}/billing/paymentMode`;
+  const resp = await openmrsFetch(paymentModeUrl);
+  const data = await resp.json();
+  return data.results ?? [];
+}
+
+export async function fetchBillableServices(): Promise<BillableService[]> {
+  const v = 'full';
+  const billableServiceUrl = `${restBaseUrl}/billing/billableService`;
+  const resp = await openmrsFetch(`${billableServiceUrl}?v=${v}`);
+  const data = await resp.json();
+  return data.results ?? [];
+}
+
+export async function createBill(createBillDto: CreateBillDto) {
+  const createBillUrl = `${restBaseUrl}/billing/bill`;
+  const response = await openmrsFetch(createBillUrl, {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json',
+    },
+    body: JSON.stringify(createBillDto),
+  });
+  return response.data;
+}
+
+type PendingPatientBill = {
+  uuid: string;
+  dateCreated: string;
+  lineItems: any[];
+};
+
+export async function fetchCurrentDayPendingPatientBills(patientUuid: string): Promise<PendingPatientBill[]> {
+  const v = 'custom:(uuid,lineItems,cashPoint,dateCreated)';
+  const billUrl = `${restBaseUrl}/billing/bill?patientUuid=${patientUuid}&status=PENDING&v=${v}`;
+  const resp = await openmrsFetch(billUrl);
+  const data = await resp.json();
+  const results = data?.results ?? [];
+  const today = dayjs().startOf('day');
+
+  return results.filter((bill) => dayjs(bill?.dateCreated).startOf('day').isSame(today));
+}
+
+export async function updateBill(billUuid: string, payload: { lineItems: any[] }) {
+  const updateBillUrl = `${restBaseUrl}/billing/bill/${billUuid}`;
+  const response = await openmrsFetch(updateBillUrl, {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json',
+    },
+    body: JSON.stringify(payload),
+  });
+  return response.data;
+}
+
+export async function fetchCashPoints(): Promise<CashPoint[]> {
+  const v = 'full';
+  const cashPointUrl = `${restBaseUrl}/billing/cashPoint?v=${v}`;
+  const resp = await openmrsFetch(cashPointUrl);
+  const data = await resp.json();
+  return data.results ?? [];
+}
+
+export const createOrderBillInHie = async (payload) => {
+    const hieBaseUrl = await getHieBaseUrl();
+    const url = `${hieBaseUrl}/bill-order`;
+    return postJson<{ bill_uuid: string }>(url, payload);
+}

package/src/shared/services/claims.resource.ts

@@ -0,0 +1,47 @@
+import { type Visit } from '@openmrs/esm-framework';
+import { ClaimIntervention, type Intervention, type ServiceType, type VisitType } from '../../claims';
+
+export const getConsentToken = (activeVisit: Visit | null | undefined) => {
+  const consentToken =
+    activeVisit?.attributes?.find((atr) => atr?.attributeType?.uuid === '4962a633-c4f8-474c-857c-5c68c72fbbe3')?.value ??
+    '';
+  return consentToken;
+};
+
+export const getPaymentMode = (activeVisit: Visit) => {
+  const consentToken =
+    activeVisit?.attributes?.find((atr) => atr?.attributeType?.uuid === '8553afa0-bdb9-4d3c-8a98-05fa9350aa85')?.value ??
+    '';
+  return consentToken;
+};
+
+export const getServiceType = (
+  selectedIntervention: Intervention | ClaimIntervention,
+  visitType?: VisitType,
+): ServiceType => {
+  const rawPm =
+    (selectedIntervention as any)?.paymentMechanism ??
+    (selectedIntervention as any)?.intervention_payment_mechanism ??
+    '';
+  const rawAp = (selectedIntervention as any)?.accessPoint ?? '';
+
+  const paymentMechanism = typeof rawPm === 'string' ? rawPm.toUpperCase() : '';
+  const accessPoint = typeof rawAp === 'string' ? rawAp.toUpperCase() : '';
+
+  if (paymentMechanism.trim().toUpperCase() === 'CAPITATION') {
+    return 'CAPITATION';
+  }
+  if (["PER DIEM", "PER_DIEM"].includes(paymentMechanism.trim().toUpperCase())) {
+    return 'INPATIENT';
+  }
+  if (accessPoint.trim().toUpperCase() === 'IP') {
+    return 'INPATIENT';
+  }
+  if (accessPoint.trim().toUpperCase() === 'OP') {
+    return 'OUTPATIENT';
+  }
+  if (accessPoint.trim().toUpperCase() === 'OP AND IP') {
+    return visitType;
+  }
+  return visitType;
+};

package/src/shared/services/client-payment-mode.resource.ts

@@ -0,0 +1,27 @@
+import { type HieClientPaymentMode, type CreateClientPaymentModeDto } from '../types';
+import { getHieBaseUrl } from '../utils/get-base-url';
+
+export async function createClientPaymentMode(
+  createClientPaymentModeDto: CreateClientPaymentModeDto,
+): Promise<HieClientPaymentMode> {
+  const hieBaseUrl = await getHieBaseUrl();
+  const url = `${hieBaseUrl}/client-payment-mode`;
+  const response = await fetch(url, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify(createClientPaymentModeDto),
+  });
+
+  const data = response.json();
+  return data;
+}
+
+export async function fetchClientPaymentMode(clientId: string): Promise<HieClientPaymentMode> {
+  const hieBaseUrl = await getHieBaseUrl();
+  const url = `${hieBaseUrl}/client-payment-mode?clientId=${clientId}`;
+  const response = await fetch(url);
+  const data = response.json();
+  return data;
+}

package/src/shared/services/client-payment.resource.ts

@@ -0,0 +1,17 @@
+import { type HieBillPayment } from '../types';
+import { getHieBaseUrl } from '../utils/get-base-url';
+
+export async function createClientPayment(createClientBillPaymentDto: HieBillPayment): Promise<HieBillPayment> {
+  const hieBaseUrl = await getHieBaseUrl();
+  const url = `${hieBaseUrl}/payment`;
+  const response = await fetch(url, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify(createClientBillPaymentDto),
+  });
+
+  const data = response.json();
+  return data;
+}

package/src/shared/services/consultation-clearance.resource.ts

@@ -0,0 +1,210 @@
+/**
+ * Consultation clearance — links the triage queue to accounts.
+ *
+ * When a visit starts and the patient joins the triage/walk-in queue, a
+ * consultation bill is raised here. The patient sits in the queue "Awaiting
+ * clearance" until the fee is settled (cash) — or is auto-cleared when exempt.
+ * Once cleared, they can be called from the queue.
+ *
+ * DEMO STUB: an in-memory store shared across the registry and billing screens.
+ * Replace createConsultationClearance with the real bill-creation call and the
+ * getters with your billing/queue read endpoints.
+ */
+
+export type ClearanceStatus = 'AWAITING_PAYMENT' | 'CLEARED';
+
+export interface ConsultationClearance {
+  id: string;
+  patientName: string;
+  crNumber: string;
+  locationUuid: string;
+  queue: string; // triage / walk-in room
+  visitType: string;
+  payer: string; // Cash | Exempt | SHA | <insurer>
+  amount: number;
+  status: ClearanceStatus;
+  createdAt: string;
+}
+
+/** Standard consultation fee (demo). Replace with the billable-service price. */
+export const CONSULTATION_FEE = 1500;
+
+// DEMO persistence: kept in localStorage so records survive the full-page
+// redirect from registration to the triage queue / accounting screens.
+const STORAGE_KEY = 'dha_consultation_clearance';
+
+function load(): ConsultationClearance[] {
+  if (typeof window === 'undefined') {
+    return [];
+  }
+  try {
+    return JSON.parse(window.localStorage.getItem(STORAGE_KEY) ?? '[]') as ConsultationClearance[];
+  } catch {
+    return [];
+  }
+}
+
+function save(records: ConsultationClearance[]): void {
+  if (typeof window === 'undefined') {
+    return;
+  }
+  try {
+    window.localStorage.setItem(STORAGE_KEY, JSON.stringify(records));
+  } catch {
+    /* ignore */
+  }
+}
+
+const wait = (ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms));
+
+export interface CreateClearanceInput {
+  patientName: string;
+  crNumber: string;
+  locationUuid: string;
+  queue: string;
+  visitType: string;
+  payer: string;
+  exempt: boolean;
+  /** Already settled (e.g. a prepaid return visit) — clears without a new fee. */
+  preCleared?: boolean;
+  amountOverride?: number;
+}
+
+/** Raise the consultation bill when the visit starts. Exempt/prepaid patients clear immediately. */
+export function createConsultationClearance(input: CreateClearanceInput): ConsultationClearance {
+  const cleared = input.exempt || input.preCleared;
+  const record: ConsultationClearance = {
+    id: `cc-${Date.now()}-${Math.floor(Math.random() * 1000)}`,
+    patientName: input.patientName,
+    crNumber: input.crNumber,
+    locationUuid: input.locationUuid,
+    queue: input.queue,
+    visitType: input.visitType,
+    payer: input.payer,
+    amount: input.preCleared ? input.amountOverride ?? 0 : input.exempt ? 0 : CONSULTATION_FEE,
+    status: cleared ? 'CLEARED' : 'AWAITING_PAYMENT',
+    createdAt: new Date().toISOString(),
+  };
+  save([record, ...load()]);
+  return record;
+}
+
+/* ---- Prepaid / scheduled services (paid today, delivered on a return visit) ---- */
+
+export type PrepaidStatus = 'OPEN' | 'FULFILLED';
+
+export interface PrepaidService {
+  id: string;
+  crNumber: string;
+  patientName: string;
+  locationUuid: string;
+  service: string;
+  amount: number;
+  payer: string;
+  paidOn: string;
+  dueDate: string;
+  status: PrepaidStatus;
+}
+
+const PREPAID_KEY = 'dha_prepaid_services';
+
+function loadPrepaid(): PrepaidService[] {
+  if (typeof window === 'undefined') {
+    return [];
+  }
+  try {
+    return JSON.parse(window.localStorage.getItem(PREPAID_KEY) ?? '[]') as PrepaidService[];
+  } catch {
+    return [];
+  }
+}
+
+function savePrepaid(records: PrepaidService[]): void {
+  if (typeof window === 'undefined') {
+    return;
+  }
+  try {
+    window.localStorage.setItem(PREPAID_KEY, JSON.stringify(records));
+  } catch {
+    /* ignore */
+  }
+}
+
+export interface AddPrepaidInput {
+  crNumber: string;
+  patientName: string;
+  locationUuid: string;
+  service: string;
+  amount: number;
+  payer: string;
+  dueDate: string;
+}
+
+/** Record a service paid for today but delivered on a later visit. */
+export function addPrepaidService(input: AddPrepaidInput): PrepaidService {
+  const record: PrepaidService = {
+    id: `pp-${Date.now()}-${Math.floor(Math.random() * 1000)}`,
+    crNumber: input.crNumber,
+    patientName: input.patientName,
+    locationUuid: input.locationUuid,
+    service: input.service,
+    amount: input.amount,
+    payer: input.payer,
+    paidOn: new Date().toISOString(),
+    dueDate: input.dueDate,
+    status: 'OPEN',
+  };
+  savePrepaid([record, ...loadPrepaid()]);
+  return record;
+}
+
+export async function getPrepaidServices(status?: PrepaidStatus, locationUuid?: string): Promise<PrepaidService[]> {
+  await wait(200);
+  return loadPrepaid()
+    .filter((p) => (!status || p.status === status) && (!locationUuid || p.locationUuid === locationUuid))
+    .sort((a, b) => (a.dueDate < b.dueDate ? -1 : 1));
+}
+
+/** Find an open prepaid service for a patient (consumed on their return visit). */
+export function findOpenPrepaidService(crNumber: string): PrepaidService | undefined {
+  return loadPrepaid().find((p) => p.crNumber === crNumber && p.status === 'OPEN');
+}
+
+/** Mark a prepaid service delivered — done when the return visit starts. */
+export function fulfillPrepaidService(id: string): void {
+  savePrepaid(loadPrepaid().map((p) => (p.id === id ? { ...p, status: 'FULFILLED' } : p)));
+}
+
+export async function getConsultationClearances(
+  status?: ClearanceStatus,
+  locationUuid?: string,
+): Promise<ConsultationClearance[]> {
+  await wait(250);
+  return load()
+    .filter((r) => (!status || r.status === status) && (!locationUuid || r.locationUuid === locationUuid))
+    .sort((a, b) => (a.createdAt < b.createdAt ? 1 : -1));
+}
+
+export async function getClearanceCounts(
+  locationUuid?: string,
+  date?: string,
+): Promise<{ awaiting: number }> {
+  await wait(50);
+  // Filter by date (createdAt) so the tab counts match the date-filtered tables.
+  const scoped = load().filter(
+    (r) =>
+      (!locationUuid || r.locationUuid === locationUuid) &&
+      (!date || new Date(r.createdAt).toLocaleDateString('en-CA') === date),
+  );
+  // Awaiting payment is the CASH queue (SHA is cleared under Pending clearance),
+  // so the count must exclude SHA payers to match the rows shown in the table.
+  return {
+    awaiting: scoped.filter((r) => r.status === 'AWAITING_PAYMENT' && !/sha|shif/i.test(r.payer)).length,
+  };
+}
+
+/** Mark the consultation fee paid — releases the patient to be seen at the queue. */
+export async function clearConsultation(id: string): Promise<void> {
+  await wait(300);
+  save(load().map((r) => (r.id === id ? { ...r, status: 'CLEARED' } : r)));
+}

package/src/shared/services/eligibility.resource.ts

@@ -0,0 +1,20 @@
+import { openmrsFetch } from '@openmrs/esm-framework';
+import { type HieClientEligibility, type EligibilityFilterDto } from '../../registry/types';
+import { getHieBaseUrl } from '../utils/get-base-url';
+
+export async function getClientEligibityStatus(
+  eligibilityFilterDto: EligibilityFilterDto,
+): Promise<HieClientEligibility> {
+  const hieBaseUrl = await getHieBaseUrl();
+  const url = `${hieBaseUrl}/eligibility`;
+  const response = await openmrsFetch(url, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify(eligibilityFilterDto),
+  });
+
+  const data = response.json();
+  return data;
+}

package/src/shared/services/encounters.resource.ts

@@ -0,0 +1,33 @@
+import { type Encounter, openmrsFetch, restBaseUrl } from '@openmrs/esm-framework';
+import { type CreateOrderEncounterDto } from '../types';
+import { Order } from '@openmrs/esm-patient-common-lib';
+
+export async function fetchPatientEncountersByType(patientUuid: string, encounterTypeUuid: string) {
+  const res = await openmrsFetch(
+    `${restBaseUrl}/encounter?patient=${patientUuid}&encounterType=${encounterTypeUuid}&v=full`,
+  );
+
+  return res.data.results ?? [];
+}
+export async function getPatientEncounters(patientUuid: string) {
+  const res = await openmrsFetch(`${restBaseUrl}/encounter?patient=${patientUuid}&v=full`);
+
+  return res.data.results ?? [];
+}
+export async function createOrderEncounter(createOrderEncounterDto: CreateOrderEncounterDto): Promise<Encounter> {
+  const encounterUrl = `${restBaseUrl}/encounter`;
+  const response = await openmrsFetch(encounterUrl, {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json',
+    },
+    body: JSON.stringify(createOrderEncounterDto),
+  });
+  return response.data;
+}
+
+export async function getOrder(uuid: string): Promise<Order> {
+  const url = `${restBaseUrl}/order/${uuid}`;
+  const response = await openmrsFetch(url);
+  return response.data;
+}

package/src/shared/services/location.resource.ts

@@ -0,0 +1,9 @@
+import { type Location, openmrsFetch, restBaseUrl } from '@openmrs/esm-framework';
+
+export async function getLocationByUuid(locationUuid: string): Promise<Location> {
+  const locationBaseUrl = `${restBaseUrl}/location`;
+  const locationUrl = `${locationBaseUrl}/${locationUuid}`;
+  const resp = await openmrsFetch(locationUrl);
+  const data = await resp.json();
+  return data ?? null;
+}

package/src/shared/types/index.ts

@@ -0,0 +1,156 @@
+import { type Location } from '@openmrs/esm-framework';
+
+export type BillableService = {
+  uuid: string;
+  name?: string;
+  display?: string;
+  shortName: string;
+  serviceStatus: 'ENABLED' | 'DISABLED';
+  serviceType: ServiceType | null;
+  servicePrices: ServicePrice[];
+  resourceVersion: string;
+};
+
+export type ServiceType = {
+  display: string;
+  resourceVersion: string;
+};
+
+export type ServicePrice = {
+  uuid: string;
+  name: string;
+  price: number;
+  item: string;
+  paymentMode: PaymentMode;
+  billableService: BillableService;
+  resourceVersion: string;
+};
+
+export type PaymentMode = {
+  uuid: string;
+  name: string;
+  description: string | null;
+  retired: boolean;
+  retireReason: string;
+  attributeTypes: unknown[];
+  sortOrder: number | null;
+  resourceVersion: string;
+};
+
+export type PayableBillableService = ServicePrice & {
+  billableService: BillableService;
+};
+
+export type PaymentStatus = 'PENDING' | 'PAID' | 'FAILED' | 'CANCELLED';
+
+export type LineItem = {
+  uuid?: string;
+  billableService: string;
+  quantity: number;
+  price: number;
+  priceName: string;
+  priceUuid: string;
+  lineItemOrder: number;
+  status: PaymentStatus;
+  voided?: boolean;
+  voidedReason?: string;
+};
+
+export type CreateBillDto = {
+  lineItems: LineItem[];
+  cashPoint: string;
+  patient: string;
+  visit: string;
+  status: PaymentStatus;
+  payments: any[];
+};
+
+export type CashPoint = {
+  uuid: string;
+  name: string;
+  description: string;
+  retired: boolean;
+  location: Location;
+};
+
+export type CreateClientPaymentModeDto = {
+  clientId: string;
+  paymentModeUuid: string;
+};
+export type HieClientPaymentMode = {
+  client_id: string;
+  payment_mode_uuid: string;
+};
+
+export type HieBillPayment = {
+  billUuid: string;
+  paymentUuid: string;
+  referenceNo: string;
+};
+
+export type ServiceQueueDailyReport = {
+  queue_room_name: string;
+  patients: number;
+};
+
+export type ServiceQueueDailyReportResp = {
+  schemas: any;
+  sqlQuery: string;
+  size: number;
+  result: ServiceQueueDailyReport[];
+};
+
+export type ServiceQueueReportPatientList = {
+  queue_entry_id: number;
+  patient_id: number;
+  queue_id: number;
+  queue_room_name: string;
+  queue_room_id: number;
+  service_name: string;
+  patient_uuid: string;
+  uuid: string;
+  person_id: number;
+  gender: string;
+  birthdate: string;
+  age: number;
+  person_name: string;
+  identifiers: string;
+  phone_number: string;
+  served_status: string;
+  current_queue_room: string;
+};
+
+export type ServiceQueueDailyPatientListReportResp = {
+  schemas: any;
+  sqlQuery: string;
+  size: number;
+  results: {
+    results: ServiceQueueReportPatientList[];
+  };
+};
+
+export type OrderAction = 'NEW';
+export type OrderUrgency = 'ROUTINE';
+export type Order = {
+  action: OrderAction;
+  type: string;
+  patient: string;
+  careSetting: string;
+  orderer: string;
+  concept: string;
+  urgency: OrderUrgency;
+  orderType?: { uuid: string };
+  encounter?: string;
+  accessionNumber?: string;
+  scheduledDate?: null;
+};
+
+export type CreateOrderEncounterDto = {
+  patient: string;
+  location: string;
+  encounterType: string;
+  visit: string;
+  obs: any[];
+  orders: Order[];
+  encounterDatetime?: string;
+};

package/src/shared/ui/aggregate-stat-card/aggregate-stat-card.scss

@@ -0,0 +1,42 @@
+.aggregateStatsCard{
+    display: flex;
+    flex-direction: row;
+    width: 100%;
+    border-radius: 12px;
+    border: 1px solid #d2d2d2;
+    min-height: 100px;
+    padding: 10px 10px;
+    column-gap: 10px;
+    .aggregateStatsCardHeader{
+        display: flex;
+        flex-direction: column;
+        width: 50%;
+        column-gap: 3px;
+    }
+    .stats{
+        display: flex;
+        flex-direction: column;
+        width: 50%;
+        font-size: 14px;
+        row-gap: 5px;
+       .statDetails{
+        display: flex;
+        flex-direction: row;
+        width: 100%;
+        .title{
+           width: 90%;
+        }
+        .count{
+            width: 10%;
+        }
+    }
+    }
+}
+
+.totalCount{
+    color: rgb(15, 98, 254);
+}
+
+.totalCount:hover{
+    cursor: pointer;
+}

package/src/shared/ui/aggregate-stat-card/aggregate-stat-card.tsx

@@ -0,0 +1,42 @@
+import React from 'react';
+import styles from './aggregate-stat-card.scss';
+import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from '@carbon/react';
+
+interface AgregateStatCardProps {
+  title: string;
+  totalCount: number;
+  stats: { title: string; count: number }[];
+  onStatDetailsRequest: () => void;
+}
+
+const AgregateStatCard: React.FC<AgregateStatCardProps> = ({ title, totalCount, stats, onStatDetailsRequest }) => {
+  if (!title) {
+    return <></>;
+  }
+  return (
+    <div className={styles.aggregateStatsCard}>
+      <div className={styles.aggregateStatsCardHeader}>
+        <h5>{title}</h5>
+        <h1 className={styles.totalCount} onClick={onStatDetailsRequest}>
+          {totalCount}
+        </h1>
+      </div>
+      <div className={styles.stats}>
+        {stats.map((val, index) => {
+          return (
+            <>
+              <div className={styles.statDetails}>
+                <div className={styles.title}>{val.title} :</div>
+                <div className={styles.count}>
+                  <strong>{val.count}</strong>
+                </div>
+              </div>
+            </>
+          );
+        })}
+      </div>
+    </div>
+  );
+};
+
+export default AgregateStatCard;