Changeset a95bd1b for backend/src

Timestamp:

05/23/26 14:21:13 (4 months ago)

Author:

MBK <marija.karapandzova@…>

Branches:

master

Children:

7e4a5fd

Parents:

0e894d2

Message:

Add functionalities for total sum in billing and generate pdf invoice for a bill

Location:

backend/src/main/java/medora

Files:

• controller/BillingController.java (modified) (5 diffs)
• dto/BillingDetailDTO.java (added)
• dto/BillingItemDTO.java (added)
• repository/BillingRepository.java (modified) (1 diff)
• repository/PerformedLabTestRepository.java (modified) (2 diffs)
• repository/PerformedProcedureRepository.java (modified) (1 diff)
• service/AppointmentService.java (modified) (7 diffs)
• service/BillingService.java (modified) (8 diffs)
• service/LabService.java (modified) (7 diffs)
• service/ProcedureService.java (modified) (5 diffs)
• service/ReferralService.java (modified) (7 diffs)
• util/BillingPDFGenerator.java (added)

backend/src/main/java/medora/controller/BillingController.java

@@ -2 +2 @@
 
 import medora.dto.BillingDTO;
+import medora.dto.BillingDetailDTO;
 import medora.dto.CreateBillingRequest;
 import medora.dto.UpdateBillingRequest;
 import medora.models.domain.Billing;
+import medora.models.enums.PaymentStatus;
 import medora.service.BillingService;
+import medora.util.BillingPDFGenerator;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import org.springframework.http.HttpHeaders;
 import org.springframework.http.HttpStatus;
+import org.springframework.http.MediaType;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.*;
@@ -82 +87 @@
     }
 
+    @GetMapping("/{billId}/detail")
+    public ResponseEntity<?> getBillingDetail(@PathVariable Long billId) {
+        try {
+            logger.info("Fetching detailed billing information for bill ID: {}", billId);
+            BillingDetailDTO detail = billingService.getBillingDetail(billId);
+            return ResponseEntity.ok(detail);
+        } catch (RuntimeException e) {
+            logger.error("Error fetching billing detail: {}", e.getMessage());
+            return ResponseEntity.badRequest()
+                    .body(Map.of("error", e.getMessage()));
+        } catch (Exception e) {
+            logger.error("Unexpected error fetching billing detail: {}", e.getMessage());
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
+                    .body(Map.of("error", "Failed to fetch billing detail: " + e.getMessage()));
+        }
+    }
+
     @GetMapping
     public ResponseEntity<?> getAllBillings() {
@@ -124 +146 @@
     @PatchMapping("/{billId}/payment-status")
     public ResponseEntity<?> updatePaymentStatus(@PathVariable Long billId,
-                                                @RequestBody UpdateBillingRequest request) {
+                                                 @RequestBody UpdateBillingRequest request) {
         try {
             if (request.getPaymentStatus() == null) {
@@ -144 +166 @@
             return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                     .body(Map.of("error", "Failed to update payment status: " + e.getMessage()));
+        }
+    }
+
+    @GetMapping("/{billId}/invoice-pdf")
+    public ResponseEntity<?> downloadInvoicePDF(@PathVariable Long billId) {
+        try {
+            logger.info("Generating PDF invoice for bill ID: {}", billId);
+            BillingDetailDTO billingDetail = billingService.getBillingDetail(billId);
+            byte[] pdfContent = BillingPDFGenerator.generateInvoicePDF(billingDetail);
+
+            HttpHeaders headers = new HttpHeaders();
+            headers.setContentType(MediaType.APPLICATION_PDF);
+            headers.setContentDispositionFormData("attachment", "invoice-" + billId + ".pdf");
+            headers.setContentLength(pdfContent.length);
+
+            return new ResponseEntity<>(pdfContent, headers, HttpStatus.OK);
+        } catch (RuntimeException e) {
+            logger.error("Error generating PDF invoice: {}", e.getMessage());
+            return ResponseEntity.badRequest()
+                    .body(Map.of("error", e.getMessage()));
+        } catch (Exception e) {
+            logger.error("Unexpected error generating PDF invoice: {}", e.getMessage());
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
+                    .body(Map.of("error", "Failed to generate invoice: " + e.getMessage()));
         }
     }
@@ -151 +197 @@
         if (billing.getMedicalRecord() != null && billing.getMedicalRecord().getPatient() != null) {
             patientName = billing.getMedicalRecord().getPatient().getFirstName() + " " +
-                         billing.getMedicalRecord().getPatient().getLastName();
+                    billing.getMedicalRecord().getPatient().getLastName();
         }
         return new BillingDTO(

backend/src/main/java/medora/repository/BillingRepository.java

@@ -79 +79 @@
     """)
     List<Billing> findBillingHistoryForPatient(@Param("patientId") Long patientId);
+
+    // UC020 – Auto billing: Check if billing exists for patient on a specific date
+    @Query(value = """
+        SELECT COUNT(b.bill_id) > 0
+        FROM billing b
+        JOIN medical_records mr ON b.record_id = mr.record_id
+        WHERE mr.patient_id = :patientId
+        AND CAST(b.payment_date AS DATE) = :billDate
+    """, nativeQuery = true)
+    boolean existsBillingForPatientOnDate(@Param("patientId") Long patientId, @Param("billDate") java.time.LocalDate billDate);
+
+    // UC020 – Auto billing: Get billing for patient on a specific date
+    @Query(value = """
+        SELECT b.* FROM billing b
+        JOIN medical_records mr ON b.record_id = mr.record_id
+        WHERE mr.patient_id = :patientId
+        AND CAST(b.payment_date AS DATE) = :billDate
+        LIMIT 1
+    """, nativeQuery = true)
+    Billing findBillingForPatientOnDate(@Param("patientId") Long patientId, @Param("billDate") java.time.LocalDate billDate);
+
+    // UC020 – Auto billing: Calculate total cost for patient on a specific date (using view)
+    @Query(value = """
+        SELECT COALESCE(total_cost, 0::decimal)
+        FROM daily_patient_billing_totals
+        WHERE patient_id = :patientId
+        AND service_date = :serviceDate
+    """, nativeQuery = true)
+    BigDecimal calculateDailyTotalCostForPatient(@Param("patientId") Long patientId, @Param("serviceDate") java.time.LocalDate serviceDate);
+
+    // UC020 – Get procedures for a billing record
+    @Query(value = """
+        SELECT p.procedure_id, p.procedure_type, p.cost
+        FROM billing_procedures bp
+        JOIN procedures p ON bp.procedure_id = p.procedure_id
+        WHERE bp.bill_id = :billId
+    """, nativeQuery = true)
+    java.util.List<Object[]> findProceduresForBilling(@Param("billId") Long billId);
+
+    // UC020 – Get lab tests for a billing record
+    @Query(value = """
+        SELECT l.test_id, l.test_name, l.cost
+        FROM billing_lab_tests blt
+        JOIN lab_tests l ON blt.test_id = l.test_id
+        WHERE blt.bill_id = :billId
+    """, nativeQuery = true)
+    java.util.List<Object[]> findLabTestsForBilling(@Param("billId") Long billId);
 }

backend/src/main/java/medora/repository/PerformedLabTestRepository.java

@@ -4 +4 @@
 import medora.models.domain.PerformedLabTests;
 import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
 
 import java.util.List;
@@ -12 +14 @@
 
     List<PerformedLabTests> findByDoctorDoctorId(Long doctorId);
+
+    // UC020 – Auto billing: Get lab tests for a patient on a specific date
+    @Query("""
+        SELECT plt FROM PerformedLabTests plt
+        WHERE plt.patient.patientId = :patientId
+        AND plt.testDate = :testDate
+    """)
+    List<PerformedLabTests> findByPatientAndDate(@Param("patientId") Long patientId, @Param("testDate") java.time.LocalDate testDate);
 }

backend/src/main/java/medora/repository/PerformedProcedureRepository.java

@@ -45 +45 @@
     """)
     List<PerformedProcedures> findByMedicalRecordId(@Param("recordId") Long recordId);
+
+    // UC020 – Auto billing: Get procedures for a patient on a specific date
+    @Query("""
+        SELECT pp FROM PerformedProcedures pp
+        WHERE pp.patient.patientId = :patientId
+        AND pp.procedureDate = :procedureDate
+    """)
+    List<PerformedProcedures> findByPatientAndDate(@Param("patientId") Long patientId, @Param("procedureDate") java.time.LocalDate procedureDate);
 }

backend/src/main/java/medora/service/AppointmentService.java

@@ -2 +2 @@
 
 import medora.models.domain.Appointment;
+import medora.models.domain.Patient;
 import medora.models.domain.Doctors;
-import medora.models.domain.Patient;
 import medora.models.enums.AppointmentStatus;
 import medora.repository.AppointmentRepository;
+import medora.repository.PatientRepository;
 import medora.repository.DoctorRepository;
-import medora.repository.PatientRepository;
+
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
@@ -79 +81 @@
                 LocalDateTime.of(appointmentDate, appointmentTime);
 
-
+        // Future validation
         if (!appointmentDateTime.isAfter(LocalDateTime.now())) {
             throw new RuntimeException(
@@ -86 +88 @@
         }
 
+        // Doctor slot validation
         boolean doctorBusy =
                 appointmentRepository
@@ -99 +102 @@
         }
 
+        // Duplicate patient validation
         boolean duplicateAppointment =
                 appointmentRepository
@@ -204 +208 @@
     }
 
-
     @Transactional(readOnly = true)
     public Optional<Appointment> getAppointmentById(Long appointmentId) {
@@ -217 +220 @@
     }
 
-    /**
-     * Get appointments for patient
-     */
+
     @Transactional(readOnly = true)
     public List<Appointment> getAppointmentsForPatient(Long patientId) {
@@ -297 +298 @@
         return appointmentRepository.findAll();
     }
+
+
+    public LocalTime findNextAvailableSlot(Long doctorId, LocalDate appointmentDate) {
+        LocalTime[] timeSlots = {
+                LocalTime.of(9, 0),
+                LocalTime.of(10, 0),
+                LocalTime.of(11, 0),
+                LocalTime.of(13, 0),
+                LocalTime.of(14, 0),
+                LocalTime.of(15, 0),
+                LocalTime.of(16, 0)
+        };
+
+        for (LocalTime timeSlot : timeSlots) {
+            boolean isBooked = appointmentRepository
+                    .existsByDoctorDoctorIdAndAppointmentDateAndAppointmentTimeAndStatusNot(
+                            doctorId,
+                            appointmentDate,
+                            timeSlot,
+                            AppointmentStatus.CANCELLED
+                    );
+            if (!isBooked) {
+                return timeSlot;
+            }
+        }
+        return null;
+    }
 }

backend/src/main/java/medora/service/BillingService.java

@@ -1 +1 @@
 package medora.service;
 
-import medora.models.domain.*;
+import medora.models.domain.Billing;
+import medora.models.domain.MedicalRecord;
+import medora.models.domain.Admin;
+import medora.models.domain.BillingLabTests;
+import medora.models.domain.BillingProcedures;
+import medora.models.domain.PerformedProcedures;
+import medora.models.domain.PerformedLabTests;
 import medora.models.enums.PaymentStatus;
-import medora.repository.*;
+import medora.repository.BillingRepository;
+import medora.repository.MedicalRecordRepository;
+import medora.repository.AdminRepository;
+import medora.repository.BillingLabTestsRepository;
+import medora.repository.BillingProceduresRepository;
+import medora.repository.PerformedProcedureRepository;
+import medora.repository.PerformedLabTestRepository;
+import medora.repository.PatientRepository;
+import medora.dto.BillingDetailDTO;
+import medora.dto.BillingItemDTO;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -13 +28 @@
 import java.util.List;
 import java.util.Optional;
+import java.util.ArrayList;
 
 /**
@@ -30 +46 @@
     private final BillingLabTestsRepository billingLabTestsRepository;
     private final BillingProceduresRepository billingProceduresRepository;
+    private final PerformedProcedureRepository performedProcedureRepository;
+    private final PerformedLabTestRepository performedLabTestRepository;
+    private final PatientRepository patientRepository;
 
     public BillingService(BillingRepository billingRepository,
@@ -35 +54 @@
                           AdminRepository adminRepository,
                           BillingLabTestsRepository billingLabTestsRepository,
-                          BillingProceduresRepository billingProceduresRepository) {
+                          BillingProceduresRepository billingProceduresRepository,
+                          PerformedProcedureRepository performedProcedureRepository,
+                          PerformedLabTestRepository performedLabTestRepository,
+                          PatientRepository patientRepository) {
         this.billingRepository = billingRepository;
         this.medicalRecordRepository = medicalRecordRepository;
@@ -41 +63 @@
         this.billingLabTestsRepository = billingLabTestsRepository;
         this.billingProceduresRepository = billingProceduresRepository;
+        this.performedProcedureRepository = performedProcedureRepository;
+        this.performedLabTestRepository = performedLabTestRepository;
+        this.patientRepository = patientRepository;
     }
 
@@ -196 +221 @@
         }
 
-        logger.info("Total billing cost for bill ID {}: procedures={}, lab tests={}", 
+        logger.info("Total billing cost for bill ID {}: procedures={}, lab tests={}",
                 billId, procedureCost, labTestCost);
         return procedureCost.add(labTestCost);
@@ -219 +244 @@
         // This is a placeholder - adjust based on your actual Procedure entity
         logger.info("Adding procedure {} to billing record {}", procedureId, billId);
-        
+
         return null; // Will be implemented with ProcedureRepository injection
     }
@@ -241 +266 @@
         // This is a placeholder - adjust based on your actual LabTests entity
         logger.info("Adding lab test {} to billing record {}", testId, billId);
-        
+
         return null; // Will be implemented with LabTestRepository injection
     }
+
+    /**
+     * UC020 – Auto-generate billing when a procedure or lab test is performed
+     * Creates a billing record if one doesn't exist for the patient on that date
+     * Calculates total cost from all procedures and lab tests performed that day
+     */
+    @Transactional
+    public void autoGenerateBillingForPatientService(Long patientId, LocalDate serviceDate) {
+        try {
+            if (patientId == null || patientId <= 0) {
+                throw new IllegalArgumentException("Patient ID must be valid");
+            }
+            if (serviceDate == null) {
+                throw new IllegalArgumentException("Service date must be valid");
+            }
+
+            logger.info("Starting auto-billing for patient {} on date {}", patientId, serviceDate);
+
+            // Get patient's medical record (or create one if it doesn't exist)
+            MedicalRecord medicalRecord = medicalRecordRepository.findByPatientPatientId(patientId)
+                    .orElseGet(() -> {
+                        logger.info("Creating new medical record for patient {}", patientId);
+                        MedicalRecord newRecord = new MedicalRecord();
+                        newRecord.setPatient(patientRepository.findById(patientId)
+                                .orElseThrow(() -> new RuntimeException("Patient not found with ID: " + patientId)));
+                        return medicalRecordRepository.save(newRecord);
+                    });
+
+            logger.info("Using medical record {} for patient {}", medicalRecord.getRecordId(), patientId);
+
+            // Get all procedures and lab tests for the patient on that date
+            List<PerformedProcedures> procedures = performedProcedureRepository.findByPatientAndDate(patientId, serviceDate);
+            List<PerformedLabTests> labTests = performedLabTestRepository.findByPatientAndDate(patientId, serviceDate);
+
+            logger.info("Found {} procedures and {} lab tests for patient {} on {}",
+                    procedures.size(), labTests.size(), patientId, serviceDate);
+
+            // Only generate billing if there are procedures or lab tests on that date
+            if (procedures.isEmpty() && labTests.isEmpty()) {
+                logger.info("No procedures or lab tests found for patient {} on {}", patientId, serviceDate);
+                return;
+            }
+
+            // Calculate total cost
+            BigDecimal procedureCost = procedures.stream()
+                    .map(p -> {
+                        BigDecimal cost = p.getProcedure().getCost();
+                        logger.debug("Procedure {} cost: {}", p.getProcedure().getProcedureId(), cost);
+                        return cost;
+                    })
+                    .reduce(BigDecimal.ZERO, BigDecimal::add);
+
+            BigDecimal labTestCost = labTests.stream()
+                    .map(lt -> {
+                        BigDecimal cost = lt.getLabTest().getCost();
+                        logger.debug("Lab test {} cost: {}", lt.getLabTest().getTestId(), cost);
+                        return cost;
+                    })
+                    .reduce(BigDecimal.ZERO, BigDecimal::add);
+
+            BigDecimal totalCost = procedureCost.add(labTestCost);
+            logger.info("Total cost calculation: procedures={}, labTests={}, total={}", procedureCost, labTestCost, totalCost);
+
+            // Check if billing already exists for this patient on this date
+            Billing billing = billingRepository.findBillingForPatientOnDate(patientId, serviceDate);
+
+            if (billing != null) {
+                logger.info("Billing record {} already exists for patient {} on {}, updating with new total",
+                        billing.getBillId(), patientId, serviceDate);
+                billing.setTotalCost(totalCost);
+            } else {
+                // Get default admin (first admin in system)
+                Admin admin = adminRepository.findAll()
+                        .stream()
+                        .findFirst()
+                        .orElseThrow(() -> new RuntimeException("No admin found in system"));
+
+                // Create new billing record
+                billing = new Billing();
+                billing.setMedicalRecord(medicalRecord);
+                billing.setAdmin(admin);
+                billing.setTotalCost(totalCost);
+                billing.setPaymentStatus(PaymentStatus.PENDING);
+                billing.setPaymentDate(serviceDate);
+
+                logger.info("Creating new billing record for patient {} on {}", patientId, serviceDate);
+            }
+
+            Billing savedBilling = billingRepository.save(billing);
+            logger.info("Billing record {} for patient {} on {} with total cost: {}",
+                    savedBilling.getBillId(), patientId, serviceDate, totalCost);
+
+            // Link procedures to billing (only if not already linked)
+            for (PerformedProcedures procedure : procedures) {
+                try {
+                    BillingProcedures billingProcedure = new BillingProcedures(savedBilling, procedure.getProcedure());
+                    billingProceduresRepository.save(billingProcedure);
+                    logger.debug("Linked procedure {} to billing {}", procedure.getProcedure().getProcedureId(), savedBilling.getBillId());
+                } catch (Exception e) {
+                    logger.debug("Procedure {} already linked to billing {}", procedure.getProcedure().getProcedureId(), savedBilling.getBillId());
+                }
+            }
+
+            // Link lab tests to billing (only if not already linked)
+            for (PerformedLabTests labTest : labTests) {
+                try {
+                    BillingLabTests billingLabTest = new BillingLabTests(savedBilling, labTest.getLabTest());
+                    billingLabTestsRepository.save(billingLabTest);
+                    logger.debug("Linked lab test {} to billing {}", labTest.getLabTest().getTestId(), savedBilling.getBillId());
+                } catch (Exception e) {
+                    logger.debug("Lab test {} already linked to billing {}", labTest.getLabTest().getTestId(), savedBilling.getBillId());
+                }
+            }
+
+            logger.info("Successfully processed {} procedures and {} lab tests for billing record {}",
+                    procedures.size(), labTests.size(), savedBilling.getBillId());
+
+        } catch (Exception e) {
+            logger.error("Error in auto-billing for patient {} on date {}: {}", patientId, serviceDate, e.getMessage(), e);
+            throw e;
+        }
+    }
+
+    /**
+     * Get detailed billing information with itemized procedures and lab tests
+     */
+    @Transactional(readOnly = true)
+    public BillingDetailDTO getBillingDetail(Long billId) {
+        if (billId == null || billId <= 0) {
+            throw new IllegalArgumentException("Bill ID must be valid");
+        }
+
+        Billing billing = billingRepository.findById(billId)
+                .orElseThrow(() -> new RuntimeException("Billing record not found with ID: " + billId));
+
+        // Get procedures for this bill
+        List<Object[]> procedureResults = billingRepository.findProceduresForBilling(billId);
+        List<BillingItemDTO> procedures = new ArrayList<>();
+        for (Object[] row : procedureResults) {
+            procedures.add(new BillingItemDTO(
+                    ((Number) row[0]).longValue(),
+                    (String) row[1],
+                    (BigDecimal) row[2]
+            ));
+        }
+
+        // Get lab tests for this bill
+        List<Object[]> labTestResults = billingRepository.findLabTestsForBilling(billId);
+        List<BillingItemDTO> labTests = new ArrayList<>();
+        for (Object[] row : labTestResults) {
+            labTests.add(new BillingItemDTO(
+                    ((Number) row[0]).longValue(),
+                    (String) row[1],
+                    (BigDecimal) row[2]
+            ));
+        }
+
+        // Build the detail DTO
+        BillingDetailDTO detail = new BillingDetailDTO();
+        detail.setBillId(billing.getBillId());
+        detail.setPatientName(billing.getMedicalRecord().getPatient().getFirstName() + " " +
+                billing.getMedicalRecord().getPatient().getLastName());
+        detail.setPatientEmbg(billing.getMedicalRecord().getPatient().getEmbg());
+        detail.setPatientPhone(billing.getMedicalRecord().getPatient().getPhoneNumber());
+        detail.setTotalCost(billing.getTotalCost());
+        detail.setPaymentStatus(billing.getPaymentStatus().toString());
+        detail.setPaymentDate(billing.getPaymentDate());
+        detail.setBillDate(billing.getPaymentDate());
+        detail.setProcedures(procedures);
+        detail.setLabTests(labTests);
+
+        logger.info("Retrieved detailed billing information for bill {}", billId);
+        return detail;
+    }
 }

backend/src/main/java/medora/service/LabService.java

@@ -31 +31 @@
     private final DoctorRepository doctorRepository;
     private final LabTechnicianRepository labTechnicianRepository;
+    private final BillingService billingService;
 
     public LabService(LabTestRepository labTestRepository,
@@ -39 +40 @@
                       PatientRepository patientRepository,
                       DoctorRepository doctorRepository,
-                      LabTechnicianRepository labTechnicianRepository) {
+                      LabTechnicianRepository labTechnicianRepository,
+                      BillingService billingService) {
         this.labTestRepository = labTestRepository;
         this.labResultsRepository = labResultsRepository;
@@ -48 +50 @@
         this.doctorRepository = doctorRepository;
         this.labTechnicianRepository = labTechnicianRepository;
-    }
-
-    // LAB TEST
+        this.billingService = billingService;
+    }
+
+    // ================= LAB TEST =================
 
     @Transactional
@@ -104 +107 @@
     }
 
-    //  LAB TEST REQUESTS (UC013)
+    // ================= LAB TEST REQUESTS (UC013) =================
 
     @Transactional
@@ -134 +137 @@
         performedTest.setDoctor(doctor);
         performedTest.setLabTest(test);
-        performedTest.setTestDate(testDate != null ? testDate : LocalDate.now());
+        LocalDate finalTestDate = testDate != null ? testDate : LocalDate.now();
+        performedTest.setTestDate(finalTestDate);
         performedTest.setNotes(notes);
 
         logger.info("Lab test {} requested for patient {} by doctor {}", testId, patientId, doctorId);
-        return performedLabTestRepository.save(performedTest);
+        PerformedLabTests saved = performedLabTestRepository.save(performedTest);
+
+        // Auto-generate billing for the patient on this date
+        billingService.autoGenerateBillingForPatientService(patientId, finalTestDate);
+
+        return saved;
     }
 
@@ -163 +172 @@
     }
 
-    //  LAB RESULTS (UC014, UC015)
+    // ================= LAB RESULTS (UC014, UC015) =================
 
     @Transactional
@@ -193 +202 @@
         LabResults saved = labResultsRepository.save(labResult);
 
-
+        // Use the join repository to safely link (avoid deleting existing links)
+        // Create and save the join entity explicitly
         MedicalRecordLabResults link = new MedicalRecordLabResults();
         link.setMedicalRecord(medicalRecord);

backend/src/main/java/medora/service/ProcedureService.java

@@ -29 +29 @@
     private final MedicalRecordProcedureResultRepository medicalRecordProcedureResultRepository;
     private final EntityManager entityManager;
+    private final BillingService billingService;
 
     public ProcedureService(PerformedProcedureRepository performedProcedureRepository,
@@ -39 +40 @@
                             ProcedureResultRepository procedureResultRepository,
                             MedicalRecordProcedureResultRepository medicalRecordProcedureResultRepository,
-                            EntityManager entityManager) {
+                            EntityManager entityManager,
+                            BillingService billingService) {
 
         this.performedProcedureRepository = performedProcedureRepository;
@@ -51 +53 @@
         this.medicalRecordProcedureResultRepository = medicalRecordProcedureResultRepository;
         this.entityManager = entityManager;
+        this.billingService = billingService;
     }
 
@@ -97 +100 @@
 
         logger.info("Requested procedure {} for patient {} by doctor {}", procedureId, patientId, doctorId);
-        return performedProcedureRepository.saveAndFlush(performed);
+        PerformedProcedures saved = performedProcedureRepository.saveAndFlush(performed);
+
+        // Auto-generate billing for the patient on this date
+        billingService.autoGenerateBillingForPatientService(patientId, procedureDate);
+
+        return saved;
     }
 
@@ -142 +150 @@
 
         logger.info("Recorded procedure {} for patient {}", procedureId, patientId);
-        return performedProcedureRepository.saveAndFlush(performed);
+        PerformedProcedures saved = performedProcedureRepository.saveAndFlush(performed);
+
+        // Auto-generate billing for the patient on this date
+        billingService.autoGenerateBillingForPatientService(patientId, procedureDate);
+
+        return saved;
     }
 

backend/src/main/java/medora/service/ReferralService.java

@@ -1 +1 @@
 package medora.service;
 
+import medora.models.domain.Referrals;
 import medora.models.domain.Doctors;
-import medora.models.domain.Referrals;
+import medora.repository.ReferralRepository;
 import medora.repository.DoctorRepository;
+import medora.repository.PatientRepository;
 import medora.repository.MedicalRecordRepository;
-import medora.repository.PatientRepository;
-import medora.repository.ReferralRepository;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -13 +13 @@
 
 import java.time.LocalDate;
+import java.time.LocalTime;
 import java.util.List;
 import java.util.Optional;
@@ -19 +20 @@
  * RefferalService handles referral operations.
  * UC019 – Create Referral Record
- * OPTIONAL - Use only if needed
+
  */
 @Service
@@ -30 +31 @@
     private final PatientRepository patientRepository;
     private final MedicalRecordRepository medicalRecordRepository;
+    private final AppointmentService appointmentService;
 
     public ReferralService(ReferralRepository referralRepository,
                            DoctorRepository doctorRepository,
                            PatientRepository patientRepository,
-                           MedicalRecordRepository medicalRecordRepository) {
+                           MedicalRecordRepository medicalRecordRepository,
+                           AppointmentService appointmentService) {
         this.referralRepository = referralRepository;
         this.doctorRepository = doctorRepository;
         this.patientRepository = patientRepository;
         this.medicalRecordRepository = medicalRecordRepository;
+        this.appointmentService = appointmentService;
     }
 
     /**
      * UC019 – Create Referral Record
-     * Create a referral from one doctor to another
+     * Create a referral from one doctor to another and automatically create an appointment
      */
     @Transactional
     public Referrals createReferral(Long medicalRecordId, Long fromDoctorId, Long toDoctorId,
-                                    String reason, LocalDate referralDate) {
+                                    String reason, LocalDate referralDate, LocalDate appointmentDate, LocalTime appointmentTime) {
         if (medicalRecordId == null || medicalRecordId <= 0) {
             throw new IllegalArgumentException("Medical record ID must be valid");
@@ -62 +66 @@
         if (referralDate == null) {
             throw new IllegalArgumentException("Referral date is required");
+        }
+        if (appointmentDate == null) {
+            throw new IllegalArgumentException("Appointment date is required");
+        }
+        if (appointmentTime == null) {
+            throw new IllegalArgumentException("Appointment time is required");
         }
 
@@ -83 +93 @@
         referral.setReason(reason);
         referral.setReferralDate(referralDate);
+        referral.setAppointmentDate(appointmentDate);
+        referral.setAppointmentTime(appointmentTime);
 
         logger.info("Creating referral for medical record ID: {} from doctor ID: {} to doctor ID: {}",
                 medicalRecordId, fromDoctorId, toDoctorId);
-        return referralRepository.save(referral);
+        Referrals savedReferral = referralRepository.save(referral);
+
+        return savedReferral;
     }
 
@@ -143 +157 @@
         return referralRepository.findIncomingReferralsForDoctor(doctorId);
     }
+
+
+    @Transactional(propagation = org.springframework.transaction.annotation.Propagation.REQUIRES_NEW)
+    private void createAppointmentForReferral(Long patientId, Long doctorId, LocalDate appointmentDate, LocalTime appointmentTime) {
+        try {
+            appointmentService.createAppointment(patientId, doctorId, appointmentDate, appointmentTime);
+            logger.info("Automatically created appointment for patient ID: {} with doctor ID: {} on {} at {}",
+                    patientId, doctorId, appointmentDate, appointmentTime);
+        } catch (RuntimeException e) {
+            logger.warn("Failed to create appointment for referral. Error: {}", e.getMessage());
+        }
+    }
 }