Part B: Appointment Scheduling - Mediator Pattern

// The mediator responsibilities are fulfilled by AppointmentScheduler
// Could be made explicit with an interface, but concrete implementation suffices
public interface SchedulingMediator {
    String bookAppointment(String patientId, Doctor doctor,
                          LocalDateTime requestedDateTime, String reason, String doctorNotes);
}
 

/**
 * The Mediator. It handles the complex logic of scheduling,
 * checking for conflicts, and coordinating between the database and the request.
 */
public class AppointmentScheduler {
    private final SchedulingDAO schedulingDAO;
 
    public AppointmentScheduler() {
        this.schedulingDAO = new SchedulingDAO();
    }
 
    /**
     * Central coordination method for appointment booking
     * Encapsulates all complex scheduling logic
     */
    public String bookAppointment(String patientId, Doctor doctor,
                                 LocalDateTime requestedDateTime, String reason,
                                 String doctorNotes) {
        // Step 1: Retrieve existing appointments for conflict checking
        List<Appointment> existingAppointments =
            schedulingDAO.getAppointmentsForDoctorOnDate(doctor.getDoctorId(),
                                                        requestedDateTime.toLocalDate());
 
        // Step 2: Apply business rules for conflict detection
        for (Appointment existing : existingAppointments) {
            LocalDateTime existingStart = existing.getAppointmentDateTime();
 
            // 30-minute conflict rule implementation
            if (requestedDateTime.isAfter(existingStart.minusMinutes(30)) &&
                requestedDateTime.isBefore(existingStart.plusMinutes(30))) {
                return "Booking failed: Time slot conflicts with an existing appointment (30-min rule).";
            }
        }
 
        // Step 3: Create and persist new appointment
        Appointment newAppointment = new Appointment(patientId, doctor.getDoctorId(),
                                                    requestedDateTime, reason);
        newAppointment.setDoctorNotes(doctorNotes);
 
        boolean success = schedulingDAO.createAppointment(newAppointment);
        return success ? "Appointment booked successfully!" :
                        "Booking failed: Could not save to database.";
    }
}
 

public class Appointment implements Visitable {
    private int appointmentId;
    private String patientId;
    private String doctorId;
    private LocalDateTime appointmentDateTime;
    private String reason;
    private String status;
    private String doctorNotes;
    private LocalDateTime lastUpdated;
    private String lastUpdatedBy;
 
    public Appointment(String patientId, String doctorId,
                      LocalDateTime appointmentDateTime, String reason) {
        this.patientId = patientId;
        this.doctorId = doctorId;
        this.appointmentDateTime = appointmentDateTime;
        this.reason = reason;
        this.status = "Scheduled"; // Default status
        this.doctorNotes = "";
        this.lastUpdated = LocalDateTime.now();
        this.lastUpdatedBy = "system";
    }
 
    // Getters and setters...
}
 

public class Doctor {
    private String doctorId;
    private String fullName;
    private String specialty;
 
    public Doctor(String doctorId, String fullName, String specialty) {
        this.doctorId = doctorId;
        this.fullName = fullName;
        this.specialty = specialty;
    }
 
    // Getters and setters...
}
 

public class SchedulingDAO {
    public List<Appointment> getAppointmentsForDoctorOnDate(String doctorId, LocalDate date) {
        // Database query implementation
    }
 
    public boolean createAppointment(Appointment appointment) {
        // Database persistence implementation
    }
 
    public List<Doctor> getAllDoctors() {
        // Doctor retrieval implementation
    }
}
 

┌─────────────────────────────────────┐
│      AppointmentController          │
│         (Client/Colleague)          │
├─────────────────────────────────────┤
│ - scheduler: AppointmentScheduler   │
│ - dao: SchedulingDAO                │
│ - view: AppointmentPanel            │
├─────────────────────────────────────┤
│ + bookNewAppointment(): void        │
│ + viewSchedule(): void              │
│ + cancelAppointment(): void         │
└─────────────────────────────────────┘
                    │
                    │ uses
                    ▼
┌─────────────────────────────────────┐
│     AppointmentScheduler            │
│         (Mediator)                  │
├─────────────────────────────────────┤
│ - schedulingDAO: SchedulingDAO      │
├─────────────────────────────────────┤
│ + bookAppointment(): String         │
└─────────────────────────────────────┘
                    │
                    │ coordinates
                    ▼
┌─────────────────────────────────────┐    ┌─────────────────────────────────────┐
│         Appointment                 │    │            Doctor                   │
│       (Colleague)                   │    │          (Colleague)                │
├─────────────────────────────────────┤    ├─────────────────────────────────────┤
│ - appointmentId: int                │    │ - doctorId: String                  │
│ - patientId: String                 │    │ - fullName: String                  │
│ - doctorId: String                  │    │ - specialty: String                 │
│ - appointmentDateTime: LocalDateTime│    ├─────────────────────────────────────┤
│ - reason: String                    │    │ + getDoctorId(): String             │
│ - status: String                    │    │ + getFullName(): String             │
│ - doctorNotes: String               │    │ + getSpecialty(): String            │
├─────────────────────────────────────┤    └─────────────────────────────────────┘
│ + getAppointmentDateTime(): LocalDT │
│ + setStatus(status): void           │
│ + setDoctorNotes(notes): void       │
└─────────────────────────────────────┘
                    ▲
                    │ manages
                    │
┌─────────────────────────────────────┐
│         SchedulingDAO               │
│       (Data Access)                 │
├─────────────────────────────────────┤
│ + getAppointmentsForDoctorOnDate()  │
│ + createAppointment(): boolean      │
│ + updateAppointment(): boolean      │
│ + getAllDoctors(): List<Doctor>     │
└─────────────────────────────────────┘

Client Request → Controller → Mediator → Database/Entities → Response

AppointmentController.bookNewAppointment()
            │
            ▼
AppointmentScheduler.bookAppointment()
            │
            ├─→ SchedulingDAO.getAppointmentsForDoctorOnDate()
            │                    │
            │                    ▼
            │            [Conflict Detection Logic]
            │                    │
            ├─→ new Appointment()
            │                    │
            └─→ SchedulingDAO.createAppointment()
                                │
                                ▼
                         [Success/Failure Response]

/**
 * Core business logic: 30-minute appointment window conflict detection
 * This algorithm prevents overlapping appointments by ensuring a 30-minute
 * buffer around each existing appointment.
 */
public String bookAppointment(String patientId, Doctor doctor,
                             LocalDateTime requestedDateTime, String reason,
                             String doctorNotes) {
 
    // Retrieve all appointments for the doctor on the requested date
    List<Appointment> existingAppointments =
        schedulingDAO.getAppointmentsForDoctorOnDate(doctor.getDoctorId(),
                                                    requestedDateTime.toLocalDate());
 
    // Apply 30-minute conflict rule
    for (Appointment existing : existingAppointments) {
        LocalDateTime existingStart = existing.getAppointmentDateTime();
 
        /*
         * Conflict scenarios:
         * - Existing at 10:00, Requested at 10:15 → CONFLICT (within 30 min)
         * - Existing at 10:00, Requested at 09:45 → CONFLICT (within 30 min)
         * - Existing at 10:00, Requested at 10:30 → NO CONFLICT (exactly 30 min)
         * - Existing at 10:00, Requested at 09:30 → NO CONFLICT (exactly 30 min)
         */
        if (requestedDateTime.isAfter(existingStart.minusMinutes(30)) &&
            requestedDateTime.isBefore(existingStart.plusMinutes(30))) {
            return "Booking failed: Time slot conflicts with an existing appointment (30-min rule).";
        }
    }
 
    // No conflicts found - proceed with booking
    Appointment newAppointment = new Appointment(patientId, doctor.getDoctorId(),
                                                requestedDateTime, reason);
    newAppointment.setDoctorNotes(doctorNotes);
 
    boolean success = schedulingDAO.createAppointment(newAppointment);
    return success ? "Appointment booked successfully!" :
                    "Booking failed: Could not save to database.";
}
 

/**
 * The mediator coordinates with the DAO layer to retrieve necessary data
 * for conflict checking without exposing database operations to the client
 */
public List<Appointment> getAppointmentsForDoctorOnDate(String doctorId, LocalDate date) {
    List<Appointment> appointments = new ArrayList<>();
    String sql = "SELECT * FROM appointments WHERE doctor_id = ? AND DATE(appointment_datetime) = ?";
 
    try (Connection conn = DatabaseManager.getConnection();
         PreparedStatement pstmt = conn.prepareStatement(sql)) {
 
        pstmt.setString(1, doctorId);
        pstmt.setDate(2, Date.valueOf(date));
        ResultSet rs = pstmt.executeQuery();
 
        while (rs.next()) {
            Appointment appt = new Appointment(
                rs.getString("patient_id"),
                rs.getString("doctor_id"),
                rs.getTimestamp("appointment_datetime").toLocalDateTime(),
                rs.getString("reason")
            );
            appt.setAppointmentId(rs.getInt("appointment_id"));
            appt.setStatus(rs.getString("status"));
            appt.setDoctorNotes(rs.getString("doctor_notes"));
            appointments.add(appt);
        }
    } catch (SQLException e) {
        System.err.println("Error fetching appointments for doctor " +
                          doctorId + " on " + date + ": " + e.getMessage());
    }
    return appointments;
}
 

/**
 * The mediator handles object creation and initial state setup
 * ensuring consistent object initialization across the system
 */
Appointment newAppointment = new Appointment(patientId, doctor.getDoctorId(),
                                           requestedDateTime, reason);
 
// Set additional properties through mediator logic
newAppointment.setDoctorNotes(doctorNotes);
// Status is automatically set to "Scheduled" in constructor
// lastUpdated and lastUpdatedBy are set automatically
 
// Persistence is handled through the mediator's DAO coordination
boolean success = schedulingDAO.createAppointment(newAppointment);
 

/**
 * Complete appointment booking workflow managed by the mediator:
 * 1. Data Retrieval
 * 2. Business Rule Validation
 * 3. Object Creation
 * 4. Persistence
 * 5. Response Generation
 */
public String bookAppointment(...) {
    // Step 1: Data Retrieval
    List<Appointment> existingAppointments = schedulingDAO.getAppointmentsForDoctorOnDate(...);
 
    // Step 2: Business Rule Validation
    for (Appointment existing : existingAppointments) {
        if (hasConflict(requestedDateTime, existing.getAppointmentDateTime())) {
            return generateConflictMessage();
        }
    }
 
    // Step 3: Object Creation
    Appointment newAppointment = createAppointment(...);
 
    // Step 4: Persistence
    boolean success = schedulingDAO.createAppointment(newAppointment);
 
    // Step 5: Response Generation
    return generateResponseMessage(success);
}
 

/**
 * AppointmentController delegates complex scheduling to the mediator
 * while handling UI concerns and user permissions
 */
public class AppointmentController {
    private final AppointmentScheduler scheduler; // Mediator instance
 
    private void bookNewAppointment() {
        // UI validation and data collection
        String patientId = view.patientIdField.getText().trim();
        String reason = view.reasonField.getText().trim();
        String doctorNotes = view.getDoctorNotesText();
 
        // Permission checking
        if (!currentUser.hasPermission("can_book_appointment")) {
            showPermissionError();
            return;
        }
 
        // Doctor selection logic
        Doctor selectedDoctor = getSelectedDoctor();
        LocalDateTime requestedDateTime = getRequestedDateTime();
 
        // Delegate to mediator for complex scheduling logic
        String resultMessage = scheduler.bookAppointment(
            patientId, selectedDoctor, requestedDateTime, reason, doctorNotes
        );
 
        // Handle response and update UI
        JOptionPane.showMessageDialog(view, resultMessage +
            "\\nBooked by: " + currentUser.getUsername());
        viewSchedule(); // Refresh display
        view.clearBookingFormFields();
    }
}
 

/**
 * The mediator can coordinate database transactions across multiple operations
 * ensuring data consistency for complex scheduling scenarios
 */
public boolean createAppointment(Appointment appointment) {
    String sql = "INSERT INTO appointments (patient_id, doctor_id, appointment_datetime, " +
                "reason, doctor_notes, status) VALUES (?, ?, ?, ?, ?, ?)";
 
    try (Connection conn = DatabaseManager.getConnection();
         PreparedStatement pstmt = conn.prepareStatement(sql)) {
 
        pstmt.setString(1, appointment.getPatientId());
        pstmt.setString(2, appointment.getDoctorId());
        pstmt.setTimestamp(3, Timestamp.valueOf(appointment.getAppointmentDateTime()));
        pstmt.setString(4, appointment.getReason());
        pstmt.setString(5, appointment.getDoctorNotes());
        pstmt.setString(6, appointment.getStatus() != null ?
                           appointment.getStatus() : "Scheduled");
 
        boolean success = pstmt.executeUpdate() > 0;
        if (success) {
            System.out.println("SUCCESS: Created appointment for patient " +
                             appointment.getPatientId() + " with doctor " +
                             appointment.getDoctorId());
        }
        return success;
    } catch (SQLException e) {
        System.err.println("ERROR: Error creating appointment: " + e.getMessage());
        return false;
    }
}
 

// Setup
AppointmentScheduler scheduler = new AppointmentScheduler();
Doctor doctor = new Doctor("D001", "Dr. Smith", "Cardiology");
LocalDateTime requestTime = LocalDateTime.of(2025, 8, 31, 14, 0); // 2:00 PM
 
// Execution
String result = scheduler.bookAppointment(
    "P001",           // Patient ID
    doctor,           // Doctor object
    requestTime,      // Requested time
    "Chest pain",     // Reason
    "Follow-up needed" // Doctor notes
);
 
// Expected Result
assertEquals("Appointment booked successfully!", result);
 

// Setup - Existing appointment at 2:00 PM
Appointment existing = new Appointment("P002", "D001",
    LocalDateTime.of(2025, 8, 31, 14, 0), "Regular checkup");
// Assume existing appointment is already in database
 
// Attempt to book at 2:15 PM (within 30-minute window)
String result = scheduler.bookAppointment(
    "P003", doctor,
    LocalDateTime.of(2025, 8, 31, 14, 15),
    "Consultation", ""
);
 
// Expected Result
assertTrue(result.contains("conflicts with an existing appointment"));
 

// Different doctors can have appointments at the same time
Doctor doctor1 = new Doctor("D001", "Dr. Smith", "Cardiology");
Doctor doctor2 = new Doctor("D002", "Dr. Jones", "Neurology");
 
LocalDateTime sameTime = LocalDateTime.of(2025, 8, 31, 14, 0);
 
// Both should succeed - no conflict between different doctors
String result1 = scheduler.bookAppointment("P001", doctor1, sameTime, "Reason1", "");
String result2 = scheduler.bookAppointment("P002", doctor2, sameTime, "Reason2", "");
 
assertEquals("Appointment booked successfully!", result1);
assertEquals("Appointment booked successfully!", result2);
 

// Existing appointment at 2:00 PM
LocalDateTime existingTime = LocalDateTime.of(2025, 8, 31, 14, 0);
// New appointment at 2:30 PM (exactly 30 minutes later)
LocalDateTime newTime = LocalDateTime.of(2025, 8, 31, 14, 30);
 
String result = scheduler.bookAppointment("P001", doctor, newTime, "Checkup", "");
 
// Should succeed - exactly 30 minutes is allowed
assertEquals("Appointment booked successfully!", result);
 

@Test
public void testSuccessfulAppointmentBooking() {
    // Arrange
    AppointmentScheduler scheduler = new AppointmentScheduler();
    Doctor doctor = new Doctor("D001", "Dr. Test", "General");
    LocalDateTime appointmentTime = LocalDateTime.of(2025, 9, 1, 10, 0);
 
    // Act
    String result = scheduler.bookAppointment(
        "P001", doctor, appointmentTime, "Check-up", "Regular visit"
    );
 
    // Assert
    assertEquals("Appointment booked successfully!", result);
}
 
@Test
public void testConflictDetection() {
    // Arrange - Create existing appointment
    AppointmentScheduler scheduler = new AppointmentScheduler();
    Doctor doctor = new Doctor("D001", "Dr. Test", "General");
    LocalDateTime existingTime = LocalDateTime.of(2025, 9, 1, 10, 0);
    LocalDateTime conflictTime = LocalDateTime.of(2025, 9, 1, 10, 15);
 
    // Create first appointment
    scheduler.bookAppointment("P001", doctor, existingTime, "First", "");
 
    // Act - Try to book conflicting appointment
    String result = scheduler.bookAppointment("P002", doctor, conflictTime, "Second", "");
 
    // Assert
    assertTrue(result.contains("conflicts with an existing appointment"));
}
 
@Test
public void testBoundaryConditions() {
    AppointmentScheduler scheduler = new AppointmentScheduler();
    Doctor doctor = new Doctor("D001", "Dr. Test", "General");
 
    // Test exact 30-minute boundary
    LocalDateTime baseTime = LocalDateTime.of(2025, 9, 1, 10, 0);
    LocalDateTime boundaryTime = baseTime.plusMinutes(30);
 
    scheduler.bookAppointment("P001", doctor, baseTime, "First", "");
    String result = scheduler.bookAppointment("P002", doctor, boundaryTime, "Second", "");
 
    assertEquals("Appointment booked successfully!", result);
}
 

@Test
public void testCompleteSchedulingWorkflow() {
    // Test complete workflow from controller through mediator to database
    AppointmentController controller = new AppointmentController(view, mainFrame, user);
 
    // Simulate user input
    view.patientIdField.setText("P001");
    view.reasonField.setText("Annual checkup");
 
    // Simulate doctor selection
    Doctor testDoctor = new Doctor("D001", "Dr. Test", "General");
    view.selectDoctor(testDoctor);
 
    // Simulate date/time selection
    view.setDateTime(LocalDateTime.of(2025, 9, 1, 14, 0));
 
    // Execute booking
    controller.bookNewAppointment();
 
    // Verify appointment was created in database
    List<Appointment> appointments = dao.getAppointmentsForDoctorOnDate(
        "D001", LocalDate.of(2025, 9, 1)
    );
    assertEquals(1, appointments.size());
    assertEquals("P001", appointments.get(0).getPatientId());
}
 

@Test
public void testConcurrentBookingScenarios() {
    AppointmentScheduler scheduler = new AppointmentScheduler();
    Doctor doctor = new Doctor("D001", "Dr. Test", "General");
    ExecutorService executor = Executors.newFixedThreadPool(10);
 
    List<Future<String>> futures = new ArrayList<>();
 
    // Submit multiple concurrent booking requests
    for (int i = 0; i < 10; i++) {
        final int patientNum = i;
        Future<String> future = executor.submit(() -> {
            return scheduler.bookAppointment(
                "P" + String.format("%03d", patientNum),
                doctor,
                LocalDateTime.of(2025, 9, 1, 10, patientNum * 5), // 5-minute intervals
                "Test appointment " + patientNum,
                ""
            );
        });
        futures.add(future);
    }
 
    // Verify all bookings completed successfully
    for (Future<String> future : futures) {
        String result = future.get();
        assertEquals("Appointment booked successfully!", result);
    }
}
 

@Test
public void testDatabaseFailureHandling() {
    // Test mediator behavior when database is unavailable
    AppointmentScheduler scheduler = new AppointmentScheduler();
 
    // Simulate database failure by using invalid connection
    // This would require dependency injection or mocking for proper testing
 
    String result = scheduler.bookAppointment(
        "P001", doctor, appointmentTime, "Test", ""
    );
 
    assertEquals("Booking failed: Could not save to database.", result);
}