)`
+ - `loadPrescriptions()`
+ - `exportPrescriptionToHtml(Prescription)`
+
+
+### Dependencies
+
+- **Model Classes**:
+ - `Patient`: For reading/writing patient data.
+ - `Appointment`: For loading and linking to patients.
+ - `Prescription`: For saving and generating HTML files.
+
+- **ManagementSystem**:
+ Required to correctly link appointments to existing patients upon loading.
+
+- **Parser**:
+ Parses raw text from files and reconstructs `Patient`, `Appointment`, and `Prescription` objects.
+
+- **Commons / Utils**:
+ May use constants or helper functions for formatting or file handling.
+
+
+### Design Considerations
+
+- **Separation of Concerns**
+ The `Storage` class is solely responsible for persistence. It does not contain any business logic related to how data is used.
+
+- **Safety Checks**
+ Throws `UnloadedStorageException` if static methods are called before proper initialisation via the constructor.
+
+- **Portability**
+ Allows flexible directory configuration via constructor, making it easy to adapt file locations for testing or deployment.
+
+- **Extensibility**
+ New file-based data (e.g., billing records) can be added without affecting the current architecture — simply add new load/save methods.
+
+
+### Remarks
+
+- `Storage` should be **initialized once** using its constructor before any read/write operations are performed.
+- Data is stored in a human-readable plain text format to support debugging and versioning.
+- HTML generation for prescriptions can be enhanced in future with CSS templates or PDF export support.
+- File structure and save formats are intentionally kept simple for ease of testing and transparency.
+
+---
+
+
+
+## Implementation
+
+### View patient feature
+
+The 'view-patient' feature allows the user to retrieve and view the personal details of a specified patient.
+
+**Step 1.** The user launches the application for the first time.
+- The `ClinicEase` will be initialized and load stored patient data.
+- The patient's details are now ready to view.
+
+**Step 2.** The user executes `view-patient ic/S1234567D` command to view the patient's details.
+- This command lets `ClinicEase` read the user input through the `UI` and pass it to `Parser`.
+- The `Parser` class determines that the command is `view-patient` and creates a `ViewPatientCommand` object.
+
+> **Note:**
+> If the input does not match the expected format, an `InvalidInputFormatException` is thrown. Hence, the patient's details will not be retrieved.
+
+**Step 3.** The system calls `execute()` method in `ViewPatientCommand`.
+- This class calls for the patient list in `ManagementSystem`.
+- The system checks if the patient exists in the list:
+ - If the NRIC exists, the system retrieves the patient's details.
+
+**Step 4.** If the patient is found, the system calls `showPatientViewed()` from `UI`.
+- The patient's details are displayed to the user.
+
+The sequence diagram below illustrates how the operation for 'view-patient' would be executed in the system.
+
+
+
+---
+
+### Add patient feature
+The `add-patient` feature allows users to register new patients by providing their personal information.
+The system ensures that the **input is valid** and that the **patient does not already exist** before adding them to the patient list.
+
+**Step 1.**
+The user launches the application for the first time. `ClinicEase` will be initialized with the saved data (if any).
+The system loads the stored list of patients and appointments. The user is now ready to register a new patient.
+
+**Step 2.**
+The user executes the following command to add a new patient:
+
+`add-patient n/John Doe ic/S1234567A dob/1990-01-01 g/M p/98765432 a/123 Main St h/Diabetes, Hypertension`
+
+This command is read by the `ClinicEase` class and passed to the `Parser`.
+The `Parser` class identifies the command as `add-patient` and parses the fields. A `Patient` object is then constructed from the parsed data.
+
+> **Note**
+> If any required field (such as name, NRIC, or address) is missing, the parser will return `null`, and the system will display an appropriate error message.
+> The patient will not be added in this case.
+
+**Step 3.**
+The `ManagementSystem.addPatient()` method is called with the parsed input.
+The method first checks if a patient with the same NRIC already exists in the system.
+If the NRIC is unique and all details are present, a new `Patient` object is added to the patient list.
+
+> **Note**
+> If the NRIC already exists, a message is shown to inform the user that the patient has already been registered.
+
+**Step 4.**
+After successful registration, `Storage.savePatients()` is called to update the saved patient list on disk.
+If saving fails, `ClinicEase` catches an `UnloadedStorageException` and alerts the user.
+
+The following sequence diagram shows how an `add-patient` operation flows through the system:
+
+
+---
+
+### Delete patient feature
+The `delete-patient` feature allows users to **remove a patient** from the system using their **NRIC**.
+When a patient is deleted, all their associated **appointments** are also removed to maintain data consistency.
+
+### Step 1.
+The user launches the application. `ClinicEase` loads any saved data, including the patient list and appointments.
+The user is now ready to delete a patient from the system.
+
+### Step 2.
+The user executes the following command:
+
+`delete-patient S1234567A`
+
+This command is passed to the `Parser` class.
+The `Parser` identifies the command as `delete-patient`, extracts the NRIC `S1234567A`, and passes it to a new `DeletePatientCommand`.
+
+> **Note**
+> If the input format is incorrect (e.g., `delete-patient` with no NRIC), the parser throws an `InvalidInputFormatException` and displays an error message to the user.
+
+### Step 3.
+The `DeletePatientCommand.execute()` method calls `ManagementSystem.deletePatient(nric)`.
+
+The method first **searches for the patient** with the provided NRIC in the patient list.
+If found:
+- The patient is removed from the list.
+- All of the patient’s appointments are also removed.
+- Both `patients` and `appointments` are saved using `Storage.savePatients()` and `Storage.saveAppointments()`.
+
+> **Note**
+> If the NRIC is not found, the method returns `null` and an appropriate message is displayed.
+
+### Step 4.
+Once the patient is successfully deleted, a confirmation message is shown to the user.
+If saving to disk fails, an `UnloadedStorageException` is thrown and handled by the system to alert the user.
+
+The following sequence diagram shows how a `delete-patient` operation flows through the system:
+
+
+---
+
+### Add/delete appointment feature
+The `add-appointment` and `delete-appointment` features allow users to manage appointments for registered patients.
+The system ensures that the **patient exists** before adding the appointment and that the **appointment exists** before deleting it.
+All changes are stored persistently.
+
+#### Add Appointment
+The add-appointment feature lets users schedule appointments for patients who are already registered in the system.
+
+**Example usage scenario** and how the `add appointment` mechanism behaves at each step:
+
+Step 1. The user launches the application for the first time. The `ClinicEase` is initialized with the stored list of
+patients and appointments. The user is now ready to add a new appointment.
+
+Step 2. The user executes the command: `add-appointment ic/S1234567D ...` to add the appointment to the appointment list.
+This command let `ClinicEase` class reads the user input and passes it to the `Parser`.
+The `Parser` class determines that the command is `add-appointment` and creates an `AddAppointmentCommand` object.
+
+````
+public static Command parse(String userInput) throws InvalidInputFormatException, UnknownCommandException {
+ //...
+ case "add-appointment":
+ return new AddAppointmentCommand(parseAddAppointment(userInput));
+ //...
+````
+
+> **Note:**
+> If the input does not match the expected format, an InvalidInputFormatException is thrown. Hence, the appointment will
+> not be successfully added and stored.
+
+Step 3. The system calls `execute()` method in `AddAppointmentCommand`. Then, this class calls `ManagementSystem.addAppointment()`
+to add the appointment to the system. `ManagementSystem` checks if the patient exists using `findPatientByNRIC()`.
+- If the patient is found, the system creates an `Appointment` object and adds it to the appointment list.
+- Conditions the appointment fail to be added and stored:
+ - If the patient's NRIC does not exist (a `PatientNotFoundException` is thrown).
+ - If the appointment clashes with another scheduled within 1 hour (an `AppointmentClashException` is thrown).
+
+Step 4. After the appointment is successfully added, `Storage.saveAppointments()` is called to update the stored appointment list.
+If saving fails, `ClinicEase` catches an `UnloadedStorageException` and informs the user.
+
+The following sequence diagram shows how an `add-appointment` operation goes through the system:
+
+Note: Ui component is omitted (only represented by "Display message" here) for simplicity reason.
+
+To clarify how is extractValue() called to extract each parameter:
+````
+public static Appointment parseAddAppointment(String input) throws InvalidInputFormatException {
+ //...
+ String nric = extractValue(temp, "ic/");
+ String date = extractValue(temp, "dt/");
+ String time = extractValue(temp, "t/");
+ String desc = extractValue(temp, "dsc/");
+ //...
+````
+
+#### Delete Appointment
+The `delete-appointment` feature allows users to remove an appointment that is no longer required.
+
+**Example usage scenario** and how the `delete appointment` mechanism behaves at each step:
+Step 1. Suppose the user has already added one or more appointments and wishes to delete one. The appointment must
+exist in the current appointment list.
+
+Step 2. The user needs to know the appointment ID of the appointment to be deleted. If unsure, he/she may execute the
+`list-appointment` command to view all existing appointments.
+
+Step 3. The user executes the command `delete-appointment A100`. Similar to `add appointment`, The `ClinicEase` class
+reads the user input and passes it to the `Parser`, which creates a `DeleteAppointmentCommand` object using the provided
+`APPOINTMENT_ID`.
+
+````
+public static Command parse(String userInput) throws InvalidInputFormatException, UnknownCommandException {
+ //...
+ case "delete-appointment":
+ return new DeleteAppointmentCommand(parseDeleteAppointment(userInput));
+ //...
+````
+
+Step 4. The system calls `execute()` method in `DeleteAppointmentCommand`. Then, it calls `ManagementSystem.deleteAppointment()`
+which removes the corresponding `Appointment` object from the list.
+
+- The system searches for the appointment with the specified `APPOINTMENT_ID`.
+- If found, it removes the appointment from the list.
+- It also retrieves the corresponding patient using findPatientByNric() and updates the patient's internal appointment list.
+
+> **Note:**
+> - If the `APPOINTMENT_ID` is invalid, an error message will be displayed and the deletion will not proceed.
+> - When a **specified patient** is **deleted**, all **appointment records associated** with that patient will be **removed** too.
+
+Step 5. After successful deletion, the system updates the stored list using `Storage.saveAppointments()`.
+
+The following sequence diagram shows how an `delete-appointment` operation goes through the system **(positive case,
+where the appointment exists and is successfully deleted):**
+
+
+### Why they are implemented this way
+The current design separates command parsing (`Parser`), command execution (`Command` subclasses), and core logic (`ManagementSystem`).
+This structure helps improve modularity, testability, and clarity in our codebase.
+
+- By using distinct `Command` classes (`AddAppointmentCommand`, `DeleteAppointmentCommand)`, each operation is encapsulated with its own logic, making it easier to maintain and extend.
+
+- Centralizing the data logic in ManagementSystem so that it is easier to maintain and test appointment-related operations.
+
+- Validating `NRIC` and `APPOINTMENT_ID` before performing operations could prevent invalid data from entering the system and improves user experience by providing clear error feedback.
+
+This design also aligns with the **Separation of Concerns** principle, allowing changes in one component (e.g., how appointments are stored)
+without affecting others (e.g., how commands are parsed or executed).
+
+### Design considerations:
+#### Aspect: Where to store appointment data
+
+1. **Alternative 1 (current choice)**: Maintain a centralized appointment list in `ManagementSystem` and update each patient's internal appointment list.
+ - **Pros:** Enables efficient listing, searching, and clash detection.
+ - **Cons:** Requires synchronization between the central list and per-patient records (slight redundancy).
+
+
+2. **Alternative 2:** Allowing appointment creation without verifying patient existence
+ - **Pros:** Simplifies implementation as patient verification is not needed.
+ - **Cons:** Compromises data integrity, as appointments could become orphaned (unlinked to valid patients).
+
+
+3. **Alternative 3:** Store appointments exclusively in `Patient` objects
+ - **Pros:** Keeps appointment data stored within each patient and reduces need for cross-references.
+ - **Cons:** Aggregating all appointments becomes inefficient (require
+ iterating through every patient); harder to search across patients and detect conflicts.
+
+---
+
+### Storing Medical History Feature
+
+The `store-history` feature allows users to **add new medical history entries** for a specific patient in the system.
+The system verifies that the **patient exists** before adding the entries, then the updated data is saved persistently.
+
+Below is a usage scenario illustrating how the `store-history` mechanism behaves step by step.
+
+**Step 1.** The user executes a command such as:
+
+store-history n/John Doe ic/S1234567A h/Diabetes,High Cholesterol
+- **ClinicEase** reads this command and passes the input string to **Parser**.
+- **Parser** identifies the command as `store-history` (based on the command word) and extracts the relevant parameters (`name`, `nric`, `h/` tokens).
+- If the input is invalid (missing or malformed parameters), an `InvalidInputFormatException` is thrown, aborting the process.
+
+**Step 2.** **Parser** creates a `StoreMedHistoryCommand` object with the extracted details:
+
+- `StoreMedHistoryCommand` holds the `name` ("John Doe"), `nric` ("S1234567A"), and `medHistory` string ("Diabetes,High Cholesterol").
+
+**Step 3.** `ClinicEase` invokes `StoreMedHistoryCommand#execute(...)`, which calls:
+
+1. `ManagementSystem.storeMedicalHistory(name, nric, medHistory)`
+2. `ManagementSystem` checks if the patient exists using `findPatientByNric(nric)`.
+ - If **not found**, it prints an error, and **no** changes are made to storage.
+ - If **found**, it splits `"Diabetes,High Cholesterol"` into an array of entries:
+ - `"Diabetes"`
+ - `"High Cholesterol"`
+ - Then, it appends these entries to the patient's existing `medicalHistory` list (skipping duplicates).
+
+**Step 4.** `ManagementSystem` calls `Storage.savePatients(...)` to persist any changes to the patient data on disk:
+
+- If saving fails, `UnloadedStorageException` is thrown, and `ClinicEase` displays an error to the user.
+
+Below is a detailed **PlantUML** sequence diagram showing how a `store-history` operation moves through the system and includes the check for a valid patient:
+
+
+---
+
+### Prescription Management Feature
+
+The `add-prescription`, `view-prescription`, and `view-all-prescriptions` features allow doctors and medical staff to create and track medication prescriptions for patients within the clinic system. The system ensures that the **patient exists** before adding a prescription and handles the generation of unique prescription IDs and HTML documents for printing.
+
+#### Adding a Prescription
+
+The add-prescription feature allows users to create detailed prescriptions with symptoms, medicines, and optional notes for registered patients.
+
+**Example usage scenario** and how the `add-prescription` mechanism behaves at each step:
+
+Step 1. The user launches the application. The `ClinicEase` is initialized with stored patient, appointment, and prescription data. The user is now ready to add a new prescription.
+
+Step 2. The user executes the command:
+```
+add-prescription ic/S1234567A s/Fever,Cough m/Paracetamol,Cough syrup nt/Take after meals
+```
+
+This command lets `ClinicEase` read the user input and pass it to the `Parser`. The `Parser` determines that the command is `add-prescription` and creates an `AddPrescriptionCommand` object with a new `Prescription` object.
+
+```java
+public static Command parse(String userInput) throws InvalidInputFormatException, UnknownCommandException {
+ //...
+ case "add-prescription":
+ return new AddPrescriptionCommand(parseAddPrescription(userInput));
+ //...
+}
+```
+
+> [!NOTE]:
+> If the input does not match the expected format, an `InvalidInputFormatException` is thrown. Hence, the prescription will not be successfully added and stored.
+
+Step 3. The system calls `execute()` method in `AddPrescriptionCommand`. This class calls `ManagementSystem.addPrescription(prescription)` to add the prescription to the system.
+
+The `ManagementSystem` verifies the patient exists using `findPatientByNric()`:
+- If the patient is found, the system generates a proper prescription ID and creates a new `Prescription` object.
+- If the patient's NRIC does not exist, an `IllegalArgumentException` is thrown.
+
+Step 4. After the prescription is successfully added, `Storage.savePrescriptions()` is called to update the stored prescriptions list. If saving fails, an `UnloadedStorageException` is thrown and ClinicEase informs the user.
+
+The following sequence diagram shows how an `add-prescription` operation flows through the system:
+
+
+#### Viewing Prescriptions
+
+The system provides two commands for viewing prescriptions:
+
+1. **`view-all-prescriptions PATIENT_ID`** - Shows all prescriptions for a specific patient.
+2. **`view-prescription PRESCRIPTION_ID`** - Shows details of a specific prescription and generates an HTML version.
+
+**Example usage scenario** for `view-prescription`:
+
+Step 1. The user needs to view a specific prescription and generate its printable HTML version. If the user knows the prescription ID, they can directly proceed to step 2. Otherwise, they may need to first use `view-all-prescriptions` to find the required ID.
+
+Step 2. The user executes the command `view-prescription S1234567A-1`. The `Parser` extracts the prescription ID and creates a `ViewPrescriptionCommand` object.
+
+Step 3. The system calls `execute()` in `ViewPrescriptionCommand`. The system fetches:
+ - The prescription using `ManagementSystem.getPrescriptionById()`
+ - The patient information using `ManagementSystem.viewPatient()`
+
+Step 4. If the prescription is found, the system:
+ - Displays the prescription details to the user
+ - Generates an HTML file with `Storage.savePrescriptionHtml()`
+ - Shows the file location to the user
+
+> **Note:**
+> If the prescription ID is invalid, an error message will be displayed and no HTML will be generated.
+
+#### HTML Prescription Generation
+
+An important feature of the prescription management system is the generation of printable HTML documents. This functionality is embedded within the `Prescription` class:
+
+```java
+public String generateHtml(Patient patient) {
+ StringBuilder html = new StringBuilder();
+ // Generate structured HTML with prescription details
+ // Include patient information when available
+ // Add print button and styling
+ return html.toString();
+}
+```
+
+The generated HTML provides:
+- A professional format for printing
+- All prescription details (ID, timestamp, symptoms, medicines)
+- Patient information when available
+- A print button for easy printing from any browser
+
+#### Why It's Implemented This Way
+
+The current design separates command parsing (`Parser`), command execution (command classes like `AddPrescriptionCommand`), and core logic (`ManagementSystem` and `Prescription`). This structure allows:
+
+- Better modularity by separating different aspects of functionality
+- Improved testability with clear interfaces between components
+- Consistent approach with other features in the system
+- Easy extension for future prescription-related features
+
+The HTML generation approach was chosen as it provides a printable output without requiring additional libraries, while maintaining visual quality needed for medical documentation.
+
+#### Class Structure
+
+The implementation follows these key classes:
+
+1. **Prescription** - Core class representing a prescription with all its attributes and conversion methods.
+2. **Command Classes:**
+ - **AddPrescriptionCommand** - Creates new prescriptions
+ - **ViewPrescriptionCommand** - Displays a prescription and generates HTML
+ - **ViewAllPrescriptionsCommand** - Lists all prescriptions for a patient
+3. **ManagementSystem** - Maintains the list of prescriptions and provides methods to add and retrieve them
+4. **Storage** - Handles saving and loading prescriptions from disk
+
+The class diagram below shows the relationships between these classes:
+
+
+#### Design Considerations
+
+##### Aspect: Prescription Identification
+
+* **Alternative 1 (current choice):** Patient ID plus sequence number (e.g., "S1234567A-1").
+ * Pros:
+ * Clear association between patients and their prescriptions
+ * Easy for staff to understand and reference verbally
+ * Intuitive sequential numbering for prescriptions
+ * Cons:
+ * Requires tracking the last used number for each patient
+
+* **Alternative 2:** Generate UUIDs for prescriptions.
+ * Pros:
+ * Guaranteed global uniqueness
+ * No need for sequence management
+ * Cons:
+ * Not human-friendly for verbal reference
+ * No visual connection to the patient ID
+
+##### Aspect: Prescription Output Format
+
+* **Alternative 1 (current choice):** HTML documents for prescriptions.
+ * Pros:
+ * Universal browser support for viewing and printing
+ * No external dependencies required
+ * Responsive design across devices
+ * Cons:
+ * Not a standardized medical document format
+
+* **Alternative 2:** PDF documents.
+ * Pros:
+ * Industry standard format for medical documents
+ * Better control over print layouts
+ * Cons:
+ * Requires external PDF library dependencies
+ * Increases complexity and dependencies
+
+##### Aspect: Storage Format
+
+* **Alternative 1 (current choice):** Simple pipe-delimited text storage.
+ * Pros:
+ * Consistency with other system data formats
+ * Easy to parse and maintain
+ * Human-readable in storage
+ * Cons:
+ * Limited handling of special characters
+
+* **Alternative 2:** JSON format.
+ * Pros:
+ * Better handling of complex data structures
+ * Standard data interchange format
+ * Cons:
+ * Requires additional parsing libraries
+ * Inconsistent with the system's other storage formats
+
+---
+
+
+
+## Appendix: Requirements
## Product scope
### Target user profile
-{Describe the target user profile}
+The target users are clinic staff, such as receptionists, assistants, or solo practitioners, who need a lightweight, no-frills system to manage patient records and appointment schedules. These users are assumed to be comfortable with basic command-line interfaces but may not have advanced technical expertise.
### Value proposition
-{Describe the value proposition: what problem does it solve?}
+This CLI-based Clinic Management System offers a simple yet effective solution for managing patient data and appointments without the need for complex software installations or internet access. It helps clinics save time, stay organized, and reduce manual errors by streamlining common administrative tasks like adding patients, scheduling appointments, and retrieving records, all from the command line.
+
+---
## User Stories
-|Version| As a ... | I want to ... | So that I can ...|
-|--------|----------|---------------|------------------|
-|v1.0|new user|see usage instructions|refer to them when I forget how to use the application|
-|v2.0|user|find a to-do item by name|locate a to-do without having to go through the entire list|
+
+| Version | As a ... | I want to ... | So that I can ... |
+|---------|----------|-----------------------------------------------------|-----------------------------------------------------------------|
+| v1.0 | doctor | add my patients' personal details | I can add them into the system |
+| v1.0 | doctor | delete my patients' personal details | I can remove them from the system |
+| v1.0 | doctor | view my certain patient's personal details | I can view them in the system |
+| v1.0 | doctor | add appointments into my schedule | I can add appointments plan from a patient needed to be tracked |
+| v1.0 | doctor | delete appointments from my schedule | I can get rid of appointments no longer needed to track |
+| v1.0 | doctor | list my upcoming appointments | I can manage my time effectively without manual scheduling |
+| v1.0 | doctor | store patients' medical history | I can understand the patient's situation better |
+| v1.0 | doctor | check all medical histories for one certain patient | I can know what happened before the patient come |
+| v2.0 | doctor | add a new prescription for a patient | record the prescribed medications and instructions |
+| v2.0 | doctor | view all prescriptions for a patient | track the patient's medication history |
+| v2.0 | doctor | add symptoms to a prescription | document the patient's condition |
+| v2.0 | doctor | add special notes to prescriptions | provide additional instructions to patients |
+| v2.0 | doctor | generate a printable prescription | provide a professional document to the patient |
+| v2.0 | doctor | edit my patients' personal details | update them if there is any updates |
+| v2.0 | doctor | sort appointments by date | check which appointements are coming first |
+| v2.0 | doctor | mark/unmark appointments | track my appointments more easily |
+
+---
+
+## Use Cases
+
+### Use Case: Add a Patient
+
+#### MSS
+User requests to add a patient, adding the personal details.
+ClinicEase adds the patient to the system.
+ClinicEase confirms the patient has been added successfully.
+
+Use case ends.
+
+#### Extensions
+1a. Required details are missing or incorrectly formatted.
+1a1. ClinicEase displays an error message.
+Use case resumes at step 1.
+
+1b. A patient with the same NRIC already exists.
+1b1. ClinicEase displays an error message.
+Use case ends.
+
+---
+
+### Use Case: Delete a Patient
+
+#### MSS
+User requests to list patients.
+ClinicEase displays a list of patients.
+User requests to delete a specific patient from the list.
+ClinicEase deletes the patient.
+
+Use case ends.
+
+#### Extensions
+2a. The patient list is empty.
+Use case ends.
+
+3a. The given NRIC is invalid.
+3a1. ClinicEase displays an error message.
+Use case resumes at step 2.
+
+---
+
+### Use Case: Add an Appointment
+
+#### MSS
+User requests to add appointment, specifying the patient NRIC, date, time, and description.
+ClinicEase verifies that the patient exists.
+ClinicEase adds the appointment to the system.
+ClinicEase confirms that the appointment has been added successfully.
+
+Use case ends.
+
+#### Extensions
+2a. The patient does not exist in the system.
+2a1. ClinicEase displays an error message.
+Use case ends.
+
+1a. Required details are missing or incorrectly formatted.
+1a1. ClinicEase displays an error message.
+Use case resumes at step 1.
+
+---
+
+### Use Case: Delete an Appointment
+
+#### MSS
+User requests to list appointments.
+ClinicEase displays a list of appointments.
+User requests to delete a specific appointment.
+ClinicEase deletes the appointment.
+
+Use case ends.
+
+#### Extensions
+2a. The appointment list is empty.
+Use case ends.
+
+3a. The given appointment ID is invalid.
+3a1. ClinicEase displays an error message.
+Use case resumes at step 2.
+
+---
+
+### Use Case: View a Patient's Medical History
+
+#### MSS
+User requests to view patient's medical history using the patient's NRIC.
+ClinicEase retrieves and displays the medical history of the patient.
+
+Use case ends.
+
+#### Extensions
+1a. The given NRIC is invalid or does not exist.
+1a1. ClinicEase displays an error message.
+Use case ends.
+
+2a. The patient has no recorded medical history.
+2a1. ClinicEase informs the user that no history is available.
+Use case ends.
+
+---
+
+### Use Case: Edit a Patient's Details
+
+#### MSS
+User requests to edit a patient's details using the patient's NRIC and the new details.
+ClinicEase verifies that the patient exists.
+ClinicEase updates patient's details.
+ClinicEase confirms the update was successful.
+
+Use case ends.
+
+#### Extensions
+2a. The patient does not exist in the system.
+2a1. ClinicEase displays an error message.
+Use case ends.
+
+1a. The provided new details are invalid or missing.
+1a1. ClinicEase displays an error message.
+Use case resumes at step 1.
+
+---
+
+### Use Case: Sort Appointments
+
+#### MSS
+User requests to sort appointments by date or by appointment ID.
+ClinicEase sorts the appointments accordingly.
+ClinicEase displays the sorted list.
+
+Use case ends.
+
+#### Extensions
+1a. The appointment list is empty.
+1a1. ClinicEase displays a message indicating there are no appointments to sort.
+Use case ends.
+
+1b. The sorting parameter is invalid.
+1b1. ClinicEase displays an error message.
+Use case resumes at step 1.
+
+---
+
+### Use case: Add a new prescription
+
+**MSS**
+
+1. Doctor requests to add a new prescription
+2. System prompts for prescription details (patient ID, symptoms, medicines, optional notes)
+3. Doctor enters the required information
+4. System validates the patient ID exists
+5. System generates a unique prescription ID
+6. System saves the prescription
+7. System displays success message with the prescription details
+
+ Use case ends.
+
+**Extensions**
+
+* 4a. Patient ID does not exist
+ * 4a1. System shows an error message
+ * 4a2. Use case resumes at step 2
+
+* 3a. Required fields are missing
+ * 3a1. System shows error message with correct format
+ * 3a2. Use case resumes at step 2
+
+---
+
+### Use case: View all prescriptions for a patient
+
+**MSS**
+
+1. Doctor requests to view all prescriptions for a patient
+2. Doctor enters patient ID
+3. System validates patient exists
+4. System retrieves and displays all prescriptions for the patient
+
+ Use case ends.
+
+**Extensions**
+
+* 3a. Patient ID does not exist
+ * 3a1. System shows an error message
+ * 3a2. Use case ends
+
+* 4a. No prescriptions found
+ * 4a1. System shows "No prescriptions found" message
+ * 4a2. Use case ends
+
+---
+
+### Use case: View and generate HTML prescription
+
+**MSS**
+
+1. Doctor requests to view a specific prescription
+2. Doctor enters prescription ID
+3. System validates prescription exists
+4. System displays prescription details
+5. System generates HTML version
+6. System shows location of generated file
+
+ Use case ends.
+
+**Extensions**
+
+* 3a. Prescription ID does not exist
+ * 3a1. System shows an error message
+ * 3a2. Use case ends
+
+* 5a. HTML generation fails
+ * 5a1. System shows error message
+ * 5a2. Use case ends
+
+---
## Non-Functional Requirements
+1. Should work on any mainstream OS as long as it has Java `17` or above installed.
+2. The system should efficiently manage up to 1000 patients or appointments without any noticeable performance lag during typical usage.
+3. A user with above average typing speed for regular English text (i.e. not code, not system admin commands) should be able to accomplish most of the tasks within 30 seconds using CLI commands.
+4. All error messages should clearly indicate how to correct the invalid input.
+5. Data files should be compatible across different OS platforms.
+6. All functionality should be accessible via keyboard-only commands.
-{Give non-functional requirements}
+---
## Glossary
+* *Mainstream OS* - Windows, Linux, Unix, macOS
+* *Performance Lag* – A noticeable delay or slowdown in the system's response to user actions.
+* *Error Messages* – System-generated messages that inform users of incorrect input and provide guidance on how to fix it.
+* *OS Platform Compatibility* – The ability for data files and system functionality to work consistently across different operating systems.
+
+---
+
+
+
+## Appendix: Instructions for Manual Testing
+
+Below is a suggested guide for **manual testing** of the ClinicEase application in a Command Line Interface (CLI) environment.
+
+
+## 1. Getting Started
+
+1. **Compilation**
+ - Navigate to the project's root folder (where the `ClinicEase.java` and other `.java` files reside).
+ - Compile the source files. For example:
+ ```
+ javac *.java
+ ```
+ - Alternatively, use your favorite IDE's build tool.
+
+2. **Launching the Application**
+ - Run the compiled main class:
+ ```
+ java ClinicEase
+ ```
+ You should see a welcome message that looks like this:
+ ```
+ --------------------------------------------------------------------------------
+ Welcome to ClinicEase!
+ Type a command, or 'bye' to exit.
+ --------------------------------------------------------------------------------
+ >
+ ```
+
+3. **Exiting the Application**
+ - To exit, type:
+ ```
+ bye
+ ```
+ - Expected output:
+ ```
+ --------------------------------------------------------------------------------
+ Goodbye!
+ --------------------------------------------------------------------------------
+ ```
+ - The program will then terminate.
+
+---
+
+## 2. Testing Patient Management Features
+
+### 2.1 Add a New Patient
+
+**Command Format**: `add-patient n/NAME ic/NRIC dob/BIRTHDATE g/GENDER p/PHONE a/ADDRESS [h/MEDICAL_HISTORY]`
+
+- `[h/MEDICAL_HISTORY]` is optional and can be multiple entries separated by commas.
+
+**Steps to Test**
+1. Input:
+ ```
+ add-patient n/Alice Tan ic/S1234567A dob/1990-01-01 g/F p/91234567 a/123 Bedok Road h/High blood pressure
+ ```
+2. Expected output:
+ ```
+ --------------------------------------------------------------------------------
+ Patient added successfully: Alice Tan
+ --------------------------------------------------------------------------------
+ ```
+3. The system should store the new patient data (written to `patient_data.txt`).
+
+**Additional Test Cases**
+- **Missing required fields** (e.g., no `a/ADDRESS`) should produce an `InvalidInputFormatException` message.
+- **Duplicate NRIC** should produce a `DuplicatePatientIDException`.
+
+
+### 2.2 List All Patients
+
+**Command Format**: `list-patient`
+
+**Steps to Test**
+1. Input:
+ ```
+ list-patient
+ ```
+2. If you have existing patients, the system displays each patient in a list format:
+ ```
+ ------------------------------------------Patient Details------------------------------------------
+ Patient NRIC: S1234567A Name: Alice Tan ...
+ --------------------------------------------------------------------------------
+ ```
+3. If no patients exist, the system prints:
+ ```
+ --------------------------------------------------------------------------------
+ No patients have been added.
+ --------------------------------------------------------------------------------
+ ```
+
+
+### 2.3 View a Patient by NRIC
+
+**Command Format**: `view-patient NRIC`
+
+**Steps to Test**
+1. Input:
+ ```
+ view-patient S1234567A
+ ```
+2. If the patient is found, detailed information is displayed. Otherwise, the system notifies you that no matching patient was found.
+
+
+### 2.4 Delete a Patient
+
+**Command Format**: `delete-patient NRIC`
+
+
+**Steps to Test**
+1. Input:
+ ```
+ delete-patient S1234567A
+ ```
+2. If the patient exists, the system confirms deletion:
+ ```
+ --------------------------------------------------------------------------------
+ No patients have been added.
+ --------------------------------------------------------------------------------
+ ```
+3. If the patient doesn't exist, it notifies you accordingly.
+
+
+### 2.5 Edit Patient Information
+
+**Command Format** `edit-patient ic/NRIC [n/NAME] [dob/BIRTHDATE] [g/GENDER] [a/ADDRESS] [p/PHONE]`
+
+- `ic/NRIC` is required to locate the patient.
+- The remaining fields are optional; include only those you want to edit.
+
+**Steps to Test**
+1. Input:
+ ```
+ edit-patient ic/S1234567A n/Alice Tan g/F a/321 Jurong Avenue
+ ```
+2. Expected output upon success:
+ ```
+ --------------------------------------------------------------------------------
+ Patient with NRIC S1234567A updated successfully.
+ Edit-patient command executed.
+ --------------------------------------------------------------------------------
+ ```
+3. Use `view-patient S1234567A` to confirm the updated details.
+
+---
+
+## 3. Testing Medical History Features
+
+### 3.1 Store Medical History
+
+**Command Format**: `store-history n/NAME ic/NRIC h/HISTORY`
+
+- `h/HISTORY` can contain multiple entries separated by commas.
+
+**Steps to Test**
+1. Input:
+ ```
+ store-history n/Bob Lee ic/S7654321B h/Diabetes,High cholesterol
+
+ ```
+2. If the patient doesn't exist, the system creates a new one and prints a confirmation message. If the patient exists, it simply adds new history entries.
+
+
+### 3.2 View Medical History
+
+**Command Format**:
+1. By NRIC: `view-history ic/NRIC`
+2. By Name: `view-history NAME`
+
+
+**Steps to Test**
+1. Input:
+ ```
+ view-history ic/S7654321B
+ ```
+2. Displays the patient's history if found. Otherwise, notifies you that it cannot find the patient.
+
+---
+
+### 3.3 Edit Medical History
+
+**Command Format**: `edit-history ic/NRIC old/OLD_TEXT new/NEW_TEXT`
+
+**Steps to Test**
+1. Input:
+ ```
+ edit-history ic/S7654321B old/Diabetes new/Type 2 Diabetes
+ ```
+2. If `old/Diabetes` matches an existing record, the system replaces it with `Type 2 Diabetes` and prints a confirmation message.
+
+---
+
+## 4. Testing Appointment Features
+
+### 4.1 Add an Appointment
+
+**Command Format**: `add-appointment ic/NRIC dt/DATE t/TIME dsc/DESCRIPTION`
+
+- Date: `yyyy-MM-dd`
+- Time: `HHmm` (24-hour format)
+
+**Steps to Test**
+1. Input:
+ ```
+ add-appointment ic/S1234567A dt/2025-12-01 t/0930 dsc/Dental Checkup
+ ```
+2. If the patient is found, the system adds the appointment and shows a success message. If the patient doesn't exist, it prints an error.
+
+
+### 4.2 List Appointments
+
+**Command Format**: `list-appointment`
+
+**Steps to Test**
+1. Input:
+ ```
+ list-appointment
+ ```
+
+2. Shows all appointments if any exist. Otherwise, prints a "No appointments found" message.
+
+
+### 4.3 Sort Appointments
+
+**Command Format**:
+1. by date:`sort-appointment byDate`
+2. by appointment id: `sort-appointment byId`
+
+**Steps to Test**
+1. Input:
+ ```
+ sort-appointment byDate
+ ```
+- Appointments should be sorted chronologically.
+
+2. Input:
+ ```
+ sort-appointment byId
+ ```
+- Appointments should be sorted by their `Axxx` IDs.
+
+
+### 4.4 Mark and Unmark an Appointment
+
+**Command Format**: `mark-appointment APPOINTMENT_ID unmark-appointment APPOINTMENT_ID`
+
+**Steps to Test**
+1. Input:
+ ```
+ mark-appointment A100
+ ```
+- The system marks the appointment as done (`[X]`).
+2. Input:
+ ```
+ unmark-appointment A100
+ ```
+- The system reverts the appointment to undone (`[ ]`).
+
+
+### 4.5 Find an Appointment by NRIC
+
+**Command Format**: `find-appointment NRIC`
+
+**Steps to Test**
+1. Input:
+ ```
+ find-appointment S1234567A
+ ```
+2. If any matching appointment is found, it prints the details. Otherwise, it prints "No appointment found."
+
+---
+
+## 5. Testing Prescription Management Features
+
+### 5.1 Adding a New Prescription
+
+**Command Format**: `add-prescription ic/PATIENT_ID s/SYMPTOMS m/MEDICINES [nt/NOTES]`
+
+- `[nt/NOTES]` is optional and can include special instructions.
+- Multiple symptoms and medicines can be separated by commas.
+
+**Steps to Test**
+1. Prerequisites: Patient with ID "S9876543B" exists in the system.
+
+2. Input:
+ ```
+ add-prescription ic/S9876543B s/Fever, Cough m/Paracetamol, Cough syrup nt/Take after meals
+ ```
+ * Expected output: Prescription is added. Details of the new prescription shown.
+
+**Additional Test Cases**
+- **Missing medicines field**:
+ ```
+ add-prescription ic/S9876543B s/Fever m/
+ ```
+ * Expected output: Error shown. Missing medicines field.
+
+- **Non-existent patient**:
+ ```
+ add-prescription ic/X1234567Y s/Fever m/Paracetamol
+ ```
+ * Expected output: Error shown. Patient ID does not exist.
+
+
+### 5.2 Viewing Prescriptions
+
+**Command Format**:
+1. View all for a patient: `view-all-prescriptions PATIENT_ID`
+2. View specific prescription: `view-prescription PRESCRIPTION_ID`
+
+**Steps to Test**
+1. Prerequisites: At least one prescription exists for patient "S9876543B".
+
+2. Input:
+ ```
+ view-all-prescriptions S9876543B
+ ```
+ * Expected output: List of all prescriptions for the patient shown.
+
+3. Input:
+ ```
+ view-prescription S9876543B-1
+ ```
+ * Expected output: Details of the specific prescription shown. HTML file generated.
+
+**Additional Test Cases**
+- **Invalid prescription ID**:
+ ```
+ view-prescription INVALID-ID
+ ```
+ * Expected output: Error shown. Invalid prescription ID.
+
+
+### 5.3 Generating HTML Prescriptions
+
+**Command Format**: `view-prescription PRESCRIPTION_ID`
+
+**Steps to Test**
+1. Prerequisites: Valid prescription exists with ID "S9876543B-1".
+
+2. Input:
+ ```
+ view-prescription S9876543B-1
+ ```
+ * Expected output: HTML file generated in data/prescriptions folder.
+ * Verification: Open the generated HTML file in a browser. Check that all prescription details are correctly displayed.
+
+---
+
+## 6. Error Handling Scenarios
+
+- **Unknown Commands**
+- If you type something invalid like `randomCommand`, the system should respond:
+ ```
+ Unknown command. Please try again.
+ ```
+- **Missing or Invalid Parameters**
+- For instance, `add-appointment` missing the `dt/DATE` should trigger an error message (`InvalidInputFormatException`).
+- **Storage Failures**
+- If there's an I/O error with reading or writing to `patient_data.txt`, you might see `UnloadedStorageException`.
+
+---
+
+## 7. Comprehensive Test Workflow
-* *glossary item* - Definition
+1. **Add multiple patients** and confirm they appear correctly with `list-patient`.
+2. **Add detailed medical histories** with `store-history`; verify them using `view-history`.
+3. **Add appointments** to different patients and use `list-appointment`, `sort-appointment`, `mark-appointment`, etc. to test appointment functionality.
+4. **Add prescriptions** to patients and test the prescription view and HTML generation features.
+5. **Delete a patient** and confirm the removal.
+6. **Exit** the program with `bye`.
-## Instructions for manual testing
+---
-{Give instructions on how to do a manual product testing e.g., how to load sample data to be used for testing}
diff --git a/docs/README.md b/docs/README.md
index bbcc99c1e7..bbce7c9ff9 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -1,6 +1,6 @@
-# Duke
+# ClinicEase
-{Give product intro here}
+ClinicEase is an application designed to assist doctors in managing patient records and appointments efficiently. It allows the user to add, edit, view, and delete patient information and medical history, as well as schedule and track appointments with ease. With its intuitive command-based interface, ClinicEase ensures smooth and reliable clinic operations.
Useful links:
* [User Guide](UserGuide.md)
diff --git a/docs/UserGuide.md b/docs/UserGuide.md
index d6cf4c3b3a..93ac878249 100644
--- a/docs/UserGuide.md
+++ b/docs/UserGuide.md
@@ -2,41 +2,597 @@
## Introduction
-{Give a product intro}
+ClinicEase is an application designed to assist doctors in managing patient records and appointments efficiently. It allows the user to add, edit, view, and delete patient information and medical history, as well as schedule and track appointments with ease. With its intuitive command-based interface, ClinicEase ensures smooth and reliable clinic operations.
-## Quick Start
+---
+## Table of Contents
+- [Quick Start](#quick-start)
+- [Features](#features-)
+ - [Viewing help: `help`](#viewing-help-help)
+ - Managing Patients
+ - [Adding a new patient: `add-patient`](#adding-a-new-patient--add-patient)
+ - [Deleting a patient: `delete-patient`](#deleting-a-patient--delete-patient)
+ - [Viewing patient details: `view-patient`](#viewing-patient-details-view-patient)
+ - [Listing all patients: `list-patient`](#listing-all-patients-list-patient)
+ - [Editing a specified patient: `edit-patient`](#editing-a-specified-patient-edit-patient)
+ - Managing Appointments
+ - [Adding an appointment: `add-appointment`](#adding-an-appointment-add-appointment)
+ - [Deleting an appointment: `delete-appointment`](#deleting-an-appointment-delete-appointment)
+ - [Sorting appointments: `sort-appointment`](#sorting-appointments-sort-appointment)
+ - [Marking an appointment as done: `mark-appointment`](#marking-an-appointment-as-done-mark-appointment)
+ - [Unmarking a completed appointment: `unmark-appointment`](#unmarking-a-completed-appointment-unmark-appointment)
+ - [Finding a patient's appointments: `find-appointment`](#finding-a-patients-appointments-find-appointment)
+ - Managing Prescriptions
+ - [Adding a prescription: `add-prescription`](#adding-a-prescription-add-prescription)
+ - [Viewing all prescriptions: `view-all-prescriptions`](#viewing-all-prescriptions-view-all-prescriptions)
+ - [Viewing specific prescription: `view-prescription`](#viewing-specific-prescription-view-prescription)
+ - Updating Medical History
+ - [Adding medical history: `store-history`](#adding-medical-history-store-history)
+ - [Viewing medical history: `view-history`](#viewing-medical-history-view-history)
+ - [Editing medical history: `edit-history`](#editing-medical-history-edit-history)
+ - [Exiting the program: `bye`](#exiting-the-program-bye)
+- [FAQ](#faq)
+- [Known Issues](#known-issues)
+- [Command Summary](#command-summary)
-{Give steps to get started quickly}
+---
+## Quick Start
-1. Ensure that you have Java 17 or above installed.
-1. Down the latest version of `Duke` from [here](http://link.to/duke).
+1. Ensure that you have Java 17 or above installed.
+ **Mac users:** Ensure you have the precise JDK version prescribed
+ [here](https://se-education.org/guides/tutorials/javaInstallationMac.html).
+2. Download the latest version of `ClinicEase` [here](https://github.com/AY2425S2-CS2113-T11b-4/tp/releases).
+3. Copy the file to the folder you want to use as the home folder for ClinicEase.
+4. Open a command terminal, `cd` into the folder you put the jar file in, and use the
+ `java -jar ClinicEase.jar` command to run the application.
+5. Type the command in the command box and press Enter to execute it.
+ Some example commands you can try:
+ - `add-patient n/John ic/S1234567D dob/2003-04-06 g/M p/91218188 a/123 Main St`:
+ Adds a patient named `John` to the patient list.
+ - `delete-patient S1234567D`: Deletes the patient with NRIC `S1234567D` in the patient list.
+ - `bye`: Exits the app.
+6. Refer to the Features below for details of each command.
+
+---
## Features
+Here are some feature that the product provides:
+
+> [!NOTE]
+> - Words in `UPPER_CASE` represent parameters that must be provided by the user.
+ e.g. in `view-patient NRIC`, `NRIC` is a parameter which can be used as `view-patient S1234567D`.
+> - Items in square brackets are optional.
+ e.g. `ic/NRIC [n/NAME] [dob/BIRTHDATE]` can be used as `ic/S1234567D n/John` or as `ic/S1234567D dob/2002-06-07`.
+> - Every parameter must be supplied by the user.
+ e.g. if the command specifies `add-appointment ic/NRIC dt/DATE t/TIME dsc/DESCRIPTION`, the user
+ must fill in all parameters for the input to be valid.
+> - Parameters could be entered in any order.
+ e.g. if the command recommends `ic/NRIC dt/DATE t/TIME dsc/DESCRIPTION`, the user
+ can also not follow this exact sequence for the input to be valid.
+> - Extraneous parameters for commands that do not take in parameters (such as `list` and `bye`) will be ignored.
+ e.g. if the command specifies `list-patient 12345`, it will be interpreted as `list-patient`.
+> - Command words are **case-insensitive**.
+ e.g. `liST-paTIEnt` will be interpreted as `list-patient`.
+
+
+
+### Viewing help: `help`
+Shows all available commands of the application.
+
+Format & Example of Usage:
+
+`help`
+
+Expected output:
+----------------------------------------------------------------------------------------------------
+These are the available commands:
+Patient:
+- add-patient n/NAME ic/NRIC dob/BIRTHDATE g/GENDER p/PHONE a/ADDRESS
+- delete-patient NRIC
+- edit-patient ic/NRIC [n/NAME] [dob/BIRTHDATE] [g/GENDER] [a/ADDRESS] [p/PHONE]
+- list-patient
+- view-patient NRIC
+- store-history n/NAME ic/NRIC h/MEDICAL_HISTORY
+- view-history NRIC or view-history NAME
+- edit-history ic/NRIC old/OLD_TEXT new/NEW_TEXT
+Appointment:
+- add-appointment ic/NRIC dt/DATE t/TIME dsc/DESCRIPTION
+- delete-appointment APPOINTMENT_ID
+- list-appointment
+- mark-appointment APPOINTMENT_ID
+- unmark-appointment APPOINTMENT_ID
+- sort-appointment byDate or sort-appointment byId
+- find-appointment PATIENT_NRIC
+Prescription:
+- add-prescription ic/PATIENT_ID s/SYMPTOMS m/MEDICINES [nt/NOTES]
+- view-all-prescriptions PATIENT_ID
+- view-prescription PRESCRIPTION_ID
+----------------------------------------------------------------------------------------------------
-{Give detailed description of each feature}
+
-### Adding a todo: `todo`
-Adds a new item to the list of todo items.
+### Adding a new patient : `add-patient`
+Adds a new patient to the system with their credentials.
-Format: `todo n/TODO_NAME d/DEADLINE`
+Format: `add-patient n/NAME ic/NRIC dob/BIRTHDATE g/GENDER p/PHONE a/ADDRESS h/MEDICAL_HISTORY`
-* The `DEADLINE` can be in a natural language format.
-* The `TODO_NAME` cannot contain punctuation.
+* The `NRIC` must be unique to the existing ones in the system.
+* All inputs doesn't handle every ASCII characters, only alphabets and numbers.
+* `h/MEDICAL_HISTORY` is optional, so users can use add-patient without it.
+* `p/PHONE` & `a/ADDRESS` can be duplicate, since some patient may be represented by the same phone number and/or address.
Example of usage:
-`todo n/Write the rest of the User Guide d/next week`
+`add-patient n/John Doe ic/S1234567D dob/1999-12-12 g/M p/98765432 a/123 Main Street h/Diabetes, Hypertension`
+
+Expected output:
+
+----------------------------------------------------------------------------------------------------
+Patient added successfully: John Doe
+----------------------------------------------------------------------------------------------------
+
+
+### Deleting a patient : `delete-patient`
+Deletes an existing patient in the system.
+
+Format: `delete-patient NRIC`
+
+* The `NRIC` must be of a patient existing in the system.
+
+Example of usage:
+
+`delete-patient S1234567D`
+
+Expected output:
+
+----------------------------------------------------------------------------------------------------
+Patient deleted successfully: John Doe
+----------------------------------------------------------------------------------------------------
+
+
+### Viewing patient details: `view-patient`
+Displays the details of a specific patient.
+
+Format: `view-patient NRIC`
+
+* The `NRIC` must be of a patient existing in the system.
+
+Example of usage:
+
+`view-patient S1234567D`
+
+Expected Output:
+
+------------------------------------------Patient Details------------------------------------------
+Patient NRIC: S1234567D
+Name: John Doe
+Date of Birth: 1999-12-12
+Gender: M
+Address: 123 Main Street
+Contact: 98765432
+Medical History: Diabetes, Hypertension
+Appointments: None
+----------------------------------------------------------------------------------------------------
+
+
+### Listing all patients: `list-patient`
+Displays a list of all registered patients in the system with details provided.
+
+Format: `list-patient`
+
+Example of usage:
+
+`list-patient`
+
+Expected Output:
+
+------------------------------------------Patient Details------------------------------------------
+1. Patient NRIC: S1234567D
+ Name: John Doe
+ Date of Birth: 1999-12-12
+ Gender: M
+ Address: 123 Main Street
+ Contact: 98765432
+ Medical History:
+ - Diabetes
+ - Hypertension
+ Appointments: None
+----------------------------------------------------------------------------------------------------
+2. Patient NRIC: S8765432F
+ Name: Jane Donna
+ Date of Birth: 2000-05-19
+ Gender: F
+ Address: 546 Main Street
+ Contact: 91209310
+ Medical History:
+ - Cough
+ Appointments: None
+----------------------------------------------------------------------------------------------------
+
+
+### Editing a specified patient: `edit-patient`
+Edits a specific patient credentials by NRIC.
+
+Format: `edit-patient ic/NRIC ATTRIBUTE`
+
+* The `NRIC` must be of a patient existing in the system.
+* The `ATTRIBUTE` can possibly be between `n/NAME`, `dob/BIRTHDATE`, `g/GENDER`, `a/ADDRESS`, or `p/PHONE`
+
+Example of usage:
+
+`edit-patient ic/S1234567D p/91238989` or `edit-patient ic/S1234567D dob/1945-08-17`
+
+Expected output:
+
+Patient with NRIC S1234567D updated successfully.
+----------------------------------------------------------------------------------------------------.
+Edit-patient command executed.
+----------------------------------------------------------------------------------------------------
+
+
+
+
+### Adding an appointment: `add-appointment`
+Adds a new appointment to the list of appointment.
+
+Format: `add-appointment ic/NRIC dt/DATE t/TIME dsc/DESCRIPTION`
+
+* The patient with the specified `NRIC` **must** exist in the system.
+* `DATE` format: `yyyy-MM-dd`, where `yyyy` is year, `MM` is month,
+ `dd` is day (e.g., `2025-03-31`).
+* `TIME` format: `HHmm` in 24-hour format (e.g., `1430` for 2:30 PM).
+* `DATE` and `TIME` **must not** be **before current date/time**.
+* The new appointment will only be added if it does not clash with the others.
+
+Example of usage:
+
+`add-appointment ic/S1234567D dt/2025-03-31 t/1200 dsc/Annual checkup`
+
+Expected output:
+
+----------------------------------------------------------------------------------------------------
+Appointment added for NRIC: S1234567D on 2025-03-31 at 12:00 PM.
+Now you have 1 appointment(s) in the list.
+----------------------------------------------------------------------------------------------------
+
+
+### Deleting an appointment: `delete-appointment`
+Deletes a specified appointment from the appointment list.
+
+Format: `delete-appointment APPOINTMENT_ID`
+
+* The `APPOINTMENT_ID` refers to the unique identifier assigned by the program (e.g., "A1XX") to an appointment.
+* The `APPOINTMENT_ID` can be found in the displayed appointment list when using the list-appointment command.
+
+Example of usage:
+
+`delete-appointment A100`
+
+Expected output:
+
+----------------------------------------------------------------------------------------------------
+Appointment A100 is deleted successfully.
+Now you have 0 appointment(s) in the list.
+----------------------------------------------------------------------------------------------------
+
+
+### Sorting appointments: `sort-appointment`
+Sorts the appointments in the appointment list.
+
+Format: `sort-appointment byDate` or `sort-appointment byId`
+
+* The `sort-appointment byDate` sorts the appointments by date and time in **ascending order**.
+* The `sort-appointment byId` sorts the appointments by `APPOINTMENT_ID` in **ascending order**.
+
+Example of usage:
+
+* `sort-appointment byDate`
+* `sort-appointment byId`
+
+Expected output of `sort-appointment byDate`:
+
+-------------------------------------------Appointments---------------------------------------------
+1. [A101][ ] - S1234567D - 2025-03-31 12:00 PM - Annual checkup
+2. [A102][ ] - S1234567D - 2025-04-30 2:00 PM - Annual checkup
+----------------------------------------------------------------------------------------------------
+
+
+### Marking an appointment as done: `mark-appointment`
+Marks a specified appointment as done.
+
+Format: `mark-appointment APPOINTMENT_ID`
+
+* The `APPOINTMENT_ID` refers to the unique identifier assigned by the system to an appointment.
+* A completed appointment will be marked accordingly in the system.
+
+Example of usage:
+
+`mark-appointment A100`
+
+Expected output:
+
+----------------------------------------------------------------------------------------------------
+Appointment A101 is marked successfully.
+----------------------------------------------------------------------------------------------------
+
+
+### Unmarking a completed appointment: `unmark-appointment`
+Unmarks a completed appointment, setting it back to pending.
+
+Format: `unmark-appointment APPOINTMENT_ID`
+
+* The `APPOINTMENT_ID` must belong to an appointment that has been marked as completed.
-`todo n/Refactor the User Guide to remove passive voice d/13/04/2020`
+Example of usage:
+
+`unmark-appointment A100`
+
+Expected output:
+
+----------------------------------------------------------------------------------------------------
+Appointment A101 is unmarked successfully.
+----------------------------------------------------------------------------------------------------
+
+
+### Finding a patient's appointments: `find-appointment`
+Searches for appointments based on the patient's NRIC.
+
+Format: `find-appointment NRIC`
+
+* The `NRIC` must match a registered patient’s NRIC in the system.
+* All appointments associated with the specified NRIC will be displayed.
+
+Example of usage:
+
+`find-appointment S1234567D`
+
+Expected output:
+
+----------------------------------------------------------------------------------------------------
+ Appointments found for NRIC: S1234567D
+ - [A101][ ] - S1234567D - 2025-03-31 12:00 PM - Annual checkup
+ - [A102][ ] - S1234567D - 2025-04-30 2:00 PM - Annual checkup
+----------------------------------------------------------------------------------------------------
+
+
+### Adding a prescription: `add-prescription`
+
+Adds a new prescription for a patient.
+
+Format: `add-prescription ic/PATIENT_ID s/SYMPTOMS m/MEDICINES [nt/NOTES]`
+
+* `PATIENT_ID` must be a valid patient ID in the system
+* `SYMPTOMS` is a comma-separated list of symptoms
+* `MEDICINES` is a comma-separated list of prescribed medications
+* `NOTES` is optional and can contain special instructions
+
+Example of usage:
+
+`add-prescription ic/S9876543B s/Fever, Cough m/Paracetamol, Cough syrup nt/Take after meals`
+
+Expected output:
+
+----------------------------------------------------------------------------------------------------
+Successfully added prescription:
+Prescription [S1234567D-1] (2025-04-05 18:52)
+Patient ID: S1234567D
+Symptoms:
+- Fever
+- Cough
+Medicines:
+- Paracetamol
+- Cough syrup
+Notes: Take after meals
+
+Prescription has been generated.
+View the prescription for the patient with ID: S1234567D
+and prescription ID: S1234567D-1
+----------------------------------------------------------------------------------------------------
+
+
+### Viewing all prescriptions: `view-all-prescriptions`
+
+Shows all prescriptions for a specific patient.
+
+Format: `view-all-prescriptions NRIC`
+
+`NRIC` must be an existing patient in the system
+
+Example of Usage:
+
+`view-all-prescriptions S9876543B`
+
+Expected output:
+
+----------------------------------------------------------------------------------------------------
+Prescriptions for patient John Doe (S1234567D):
+
+Prescription ID: S1234567D-1
+Date: 2025-04-05 18:52
+Symptoms:
+- Fever
+- Cough
+Medicines:
+- Paracetamol
+- Cough syrup
+Notes: Take after meals
+
+Prescription ID: S1234567D-2
+Date: 2025-04-05 19:08
+Symptoms:
+- Sore throat
+Medicines:
+- Cough pills
+Notes: Take 3 times a day
+
+Total prescriptions: 2
+Use 'view-prescription PRESCRIPTION_ID' to view details and generate HTML.
+----------------------------------------------------------------------------------------------------
+
+
+### Viewing specific prescription: `view-prescription`
+
+Views details of a specific prescription and generates a printable HTML version.
+
+Format: `view-prescription PRESCRIPTION_ID`
+
+* `PRESCRIPTION_ID` must be existent in the system
+* The HTML file will be generated in the data/prescriptions folder
+* Open the HTML file in a web browser to view and print
+
+Example of usage:
+
+`view-prescription S9876543B-1`
+
+Expected output:
+
+----------------------------------------------------------------------------------------------------
+Prescription details:
+Prescription [S1234567D-1] (2025-04-05 18:52)
+Patient ID: S1234567D
+Symptoms:
+- Fever
+- Cough
+Medicines:
+- Paracetamol
+- Cough syrup
+Notes: Take after meals
+
+Prescription HTML file generated at: C:\Users\Judha Hoka Wishika\Downloads\tp_personal\data\prescriptions\prescription_S1234567D_1.html
+Open this file in a web browser to view and print the prescription.
+----------------------------------------------------------------------------------------------------
+
+
+
+
+### Adding Medical History: `store-history`
+Adds one or more entries to a patient's medical history.
+
+Format: `store-history n/NAME ic/NRIC h/HISTORY_ENTRY1, HISTORY_ENTRY2, ...`
+
+* The `NRIC` must be of a patient existing in the system.
+* Use commas to separate multiple history entries.
+
+Examples of usage:
+
+`store-history n/Alex Tan ic/S1234567A h/Coughing, Swelling on left leg`
+
+Expected output:
+
+----------------------------------------------------------------------------------------------------
+Medical history added for John Doe (NRIC: S1234567D).
+----------------------------------------------------------------------------------------------------
+
+
+### Viewing Medical History: `view-history`
+Displays medical history of a patient by NRIC or name.
+
+**Format:**
+`view-history NRIC` or
+`view-history NAME`
+
+**Examples:**
+- `view-history S1234567A`
+- `view-history Alex Tan`
+
+Expected output:
+
+----------------------------------------------------------------------------------------------------
+Medical History for John Doe (NRIC: S1234567D):
+- Diabetes
+- Hypertension`
+- Coughing
+- Swelling on left leg
+----------------------------------------------------------------------------------------------------
+
+
+### Editing Medical History: `edit-history`
+Modifies a specific entry in a patient’s medical history.
+
+Format: `edit-history ic/NRIC old/OLD_HISTORY_ENTRY new/NEW_HISTORY_ENTRY`
+
+- NRIC must match an existing patient record.
+- All history entries are stored as simple strings.
+- Viewing by name will display all patients with the given name.
+- Editing only replaces the **first matched** old entry.
+
+Example of usage:
+
+`edit-history ic/S1234567A old/Diabetes new/Type 2 Diabetes`
+
+Expected output:
+
+
+Replaced old history "Diabetes" with "Type 2 Diabetes".
+----------------------------------------------------------------------------------------------------
+Edit-history command executed.
+----------------------------------------------------------------------------------------------------
+
+
+### Exiting the program: `bye`
+Exits the program.
+
+Format: `bye`
+
+
+
## FAQ
+**Q**: How do I save my data?
+
+**A**: ClinicEase's data, i.e. patients, appointments and prescriptions, are saved in the hard disk automatically after any command that changes the data.
+There is no need to save manually.
+
+**Q**: Can I edit the data file e.g. `patient_data.txt`?
+
+**A**: ClinicEase's data are saved automatically as a text file at [your current directory in Command Prompt]/data/[patient_data/appointment_data/prescription_data].txt.
+Advanced users are welcome to update data directly by editing that data file.
+
**Q**: How do I transfer my data to another computer?
-**A**: {your answer here}
+**A**: You can copy the 'data' folder and paste it in the directory that you save your jar file in another computer.
+
+> **CAUTION:**
+> - If your changes to the data file makes its format invalid, ClinicEase will skip that row.
+> - Consequently, that row of data will not be loaded.
+> - Therefore, only edit the data file if you are confident in making the correct updates.
+
+---
+
+## Known Issues
+
+1. **Command-Parameter Parsing Issue**
+ When users input commands without a space between the command word and parameters (e.g., `add-appointmentic/` instead of `add-appointment ic/`),
+ the system incorrectly treats this as an unknown command rather than identifying it as a valid command with incorrect formatting.
+ - **Cause:**
+ This behavior is due to from the current parser implementation's strict space-delimited tokenization logic in the initial input splitting phase.
+ - **Impact:** The system cannot recognize the intended valid command, provide appropriate format-suggestion error messages.
+ - **Current Resolution:** This is an intended design trade-off to maintain parsing consistency, though it may be revisited in future versions.
+
+---
+
## Command Summary
-{Give a 'cheat sheet' of commands here}
+| Action | Format, Examples |
+|----------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| Add patient | `add-patient n/NAME ic/NRIC dob/BIRTHDATE g/GENDER p/PHONE a/ADDRESS`
e.g. `add-patient n/John Doe ic/S1234567D dob/1999-12-12 g/M p/98765432 a/123 Main Street h/Diabetes, Hypertension` |
+| Delete patient | `delete-patient NRIC`
e.g. `delete-patient S1234567D` |
+| Edit patient | `edit-patient ic/NRIC [n/NAME] [dob/BIRTHDATE] [g/GENDER] [a/ADDRESS] [p/PHONE]`
e.g. `edit-patient ic/S1234567D n/Billy Joe dob/1999-12-21` |
+| List patient | `list-patient` |
+| View patient | `view-patient NRIC`
e.g. `view-patient S1234567D` |
+| Store medical history | `store-history n/NAME ic/NRIC h/MEDICAL_HISTORY`
e.g. `store-history n/John Doe ic/S1234567D h/Depression` |
+| View medical history | `view-history NRIC` or `view-history NAME`
e.g. `view-history S1234567D` or `view-history John Doe` |
+| Edit medical history | `edit-history ic/NRIC old/OLD_TEXT new/NEW_TEXT`
e.g. `edit-history ic/S1234567D old/Depression new/Obesity` |
+| Add appointment | `add-appointment ic/NRIC dt/DATE t/TIME dsc/DESCRIPTION`
e.g. `add-appointment ic/S1234567D dt/2025-06-15 t/1400 dsc/Annual Checkup` |
+| Delete appointment | `delete-appointment APPOINTMENT_ID`
e.g. `delete-appointment A123` |
+| List appointment | `list-appointment` |
+| Mark appointment | `mark-appointment APPOINTMENT_ID`
e.g. `mark-appointment A101` |
+| Unmark appointment | `unmark-appointment APPOINTMENT_ID`
e.g. `unmark-appointment A101` |
+| Sort appointment | `sort-appointment byDate` or `sort-appointment byId` |
+| Find appointment | `find-appointment PATIENT_NRIC`
e.g. `find-appointment S1234567D` |
+| Add prescription | `add-prescription ic/PATIENT_ID s/SYMPTOMS m/MEDICINES [nt/NOTES]` |
+| View all prescriptions | `view-all-prescriptions PATIENT_ID` |
+| View specific prescription | `view-prescription PRESCRIPTION_ID` |
-* Add todo `todo n/TODO_NAME d/DEADLINE`
diff --git a/docs/diagrams/ArchitectureDiagram.png b/docs/diagrams/ArchitectureDiagram.png
new file mode 100644
index 0000000000..67253cca02
Binary files /dev/null and b/docs/diagrams/ArchitectureDiagram.png differ
diff --git a/docs/diagrams/ArchitectureDiagram.puml b/docs/diagrams/ArchitectureDiagram.puml
new file mode 100644
index 0000000000..5735b78785
--- /dev/null
+++ b/docs/diagrams/ArchitectureDiagram.puml
@@ -0,0 +1,35 @@
+@startuml
+actor User
+
+package "ClinicEase"{
+component UI
+component Parser
+component Command
+component Manager
+component Object
+component Storage
+component Main
+}
+database FileSystem
+
+User --> UI
+UI ..> Object
+Main --> UI
+Main ..>Command
+Main --> Manager
+Main --> Storage
+Main ..> Object
+Parser ..> Command
+Parser ..> Object
+Command --> Object
+Command ..> UI
+Command ..> Manager
+Command ..> Storage
+Manager --> Object
+Manager <..> Storage
+Storage ..> Object
+Storage ..> Parser
+Storage --> FileSystem
+
+
+@enduml
\ No newline at end of file
diff --git a/docs/diagrams/ArchitectureSequenceDiagram.png b/docs/diagrams/ArchitectureSequenceDiagram.png
new file mode 100644
index 0000000000..683a1c951a
Binary files /dev/null and b/docs/diagrams/ArchitectureSequenceDiagram.png differ
diff --git a/docs/diagrams/ArchitectureSequenceDiagram.puml b/docs/diagrams/ArchitectureSequenceDiagram.puml
new file mode 100644
index 0000000000..181434a087
--- /dev/null
+++ b/docs/diagrams/ArchitectureSequenceDiagram.puml
@@ -0,0 +1,44 @@
+@startuml
+
+actor User
+participant ":UI" as UI
+participant ":Parser" as Parser
+participant ":DeletePatientCommand" as Command
+participant ":ManagementSystem" as Management
+participant ":Storage" as Storage
+
+User -> UI : "delete-patient S1234567A"
+activate UI
+
+UI -> Parser : parse("delete-patient S1234567A")
+activate Parser
+Parser -> Parser : parseDeletePatient(userInput)
+Parser --> UI : new DeletePatientCommand("S1234567A")
+deactivate Parser
+
+UI -> Command : execute(manager, ui)
+activate Command
+
+Command -> Management : deletePatient("S1234567A")
+activate Management
+
+Management -> Storage : savePatients(patients)
+activate Storage
+Storage --> Management
+deactivate Storage
+
+Management --> Command : removedPatient
+deactivate Management
+
+Command -> UI : showPatientDeleted(removedPatient, "S1234567A")
+activate UI
+UI --> Command
+deactivate UI
+
+Command --> UI
+deactivate Command
+
+UI --> User
+deactivate UI
+
+@enduml
\ No newline at end of file
diff --git a/docs/diagrams/Command.png b/docs/diagrams/Command.png
new file mode 100644
index 0000000000..52722af201
Binary files /dev/null and b/docs/diagrams/Command.png differ
diff --git a/docs/diagrams/Command.puml b/docs/diagrams/Command.puml
new file mode 100644
index 0000000000..2146127e05
--- /dev/null
+++ b/docs/diagrams/Command.puml
@@ -0,0 +1,184 @@
+@startuml
+skinparam componentStyle rectangle
+hide circle
+
+left to right direction
+skinparam ranksep 30
+skinparam nodesep 20
+
+package "Commands" {
+ abstract class Command {
+ +execute(manager: ManagementSystem, ui: Ui) : void
+ +isExit() : boolean
+ }
+
+ class AddAppointmentCommand {
+ - appointment : Appointment
+ +AddAppointmentCommand(appointment : Appointment)
+ +execute(manager: ManagementSystem, ui: Ui) : void
+ +isExit() : boolean
+ }
+
+ class AddPatientCommand {
+ - patient : Patient
+ +AddPatientCommand(patient : Patient)
+ +execute(manager: ManagementSystem, ui: Ui) : void
+ +isExit() : boolean
+ }
+
+ class AddPrescriptionCommand {
+ - prescription : Prescription
+ +AddPrescriptionCommand(prescription : Prescription)
+ +execute(manager: ManagementSystem, ui: Ui) : void
+ +isExit() : boolean
+ }
+
+ class DeleteAppointmentCommand {
+ - apptId : String
+ +DeleteAppointmentCommand(apptId : String)
+ +execute(manager: ManagementSystem, ui: Ui) : void
+ +isExit() : boolean
+ }
+
+ class DeletePatientCommand {
+ - nric : String
+ +DeletePatientCommand(nric : String)
+ +execute(manager: ManagementSystem, ui: Ui) : void
+ +isExit() : boolean
+ }
+
+ class EditPatientCommand {
+ - details : String[]
+ +EditPatientCommand(details : String[])
+ +execute(manager: ManagementSystem, ui: Ui) : void
+ +isExit() : boolean
+ }
+
+ class EditPatientHistoryCommand {
+ - details : String[]
+ +EditPatientHistoryCommand(details : String[])
+ +execute(manager: ManagementSystem, ui: Ui) : void
+ +isExit() : boolean
+ }
+
+ class ExitCommand {
+ +ExitCommand()
+ +execute(manager: ManagementSystem, ui: Ui) : void
+ +isExit() : boolean
+ }
+
+ class FindAppointmentCommand {
+ - nric : String
+ +FindAppointmentCommand(nric : String)
+ +execute(manager: ManagementSystem, ui: Ui) : void
+ +isExit() : boolean
+ }
+
+ class HelpCommand {
+ +HelpCommand()
+ +execute(manager: ManagementSystem, ui: Ui) : void
+ +isExit() : boolean
+ }
+
+ class ListAppointmentCommand {
+ +ListAppointmentCommand()
+ +execute(manager: ManagementSystem, ui: Ui) : void
+ +isExit() : boolean
+ }
+
+ class ListPatientCommand {
+ +ListPatientCommand()
+ +execute(manager: ManagementSystem, ui: Ui) : void
+ +isExit() : boolean
+ }
+
+ class MarkApppointmentCommand {
+ - apptId : String
+ +MarkApppointmentCommand(apptId : String)
+ +execute(manager: ManagementSystem, ui: Ui) : void
+ +isExit() : boolean
+ }
+
+ class SortAppointmentCommand {
+ - type : String
+ +SortAppointmentCommand(type : String)
+ +execute(manager: ManagementSystem, ui: Ui) : void
+ +isExit() : boolean
+ }
+
+ class StoreMedHistoryCommand {
+ - nric : String
+ - medHistory : String
+ +StoreMedHistoryCommand(details : String[])
+ +execute(manager: ManagementSystem, ui: Ui) : void
+ +isExit() : boolean
+ }
+
+ class UnmarkAppointmentCommand {
+ - apptId : String
+ +UnmarkAppointmentCommand(apptId : String)
+ +execute(manager: ManagementSystem, ui: Ui) : void
+ +isExit() : boolean
+ }
+
+ class ViewAllPrescriptionsCommand {
+ - patientId : String
+ +ViewAllPrescriptionsCommand(patientId : String)
+ +execute(manager: ManagementSystem, ui: Ui) : void
+ +isExit() : boolean
+ }
+
+ class ViewMedHistoryCommand {
+ - type : String
+ - nameOrIc : String
+ +ViewMedHistoryCommand(details : String[])
+ +execute(manager: ManagementSystem, ui: Ui) : void
+ +isExit() : boolean
+ }
+
+ class ViewPatientCommand {
+ - nric : String
+ +ViewPatientCommand(nric : String)
+ +execute(manager: ManagementSystem, ui: Ui) : void
+ +isExit() : boolean
+ }
+
+ class ViewPrescriptionCommand {
+ - prescriptionId : String
+ +ViewPrescriptionCommand(prescriptionId : String)
+ +execute(manager: ManagementSystem, ui: Ui) : void
+ +isExit() : boolean
+ }
+
+ Command <|-- AddAppointmentCommand
+ Command <|-- AddPatientCommand
+ Command <|-- AddPrescriptionCommand
+ Command <|-- DeleteAppointmentCommand
+ Command <|-- DeletePatientCommand
+ Command <|-- EditPatientCommand
+ Command <|-- EditPatientHistoryCommand
+ Command <|-- ExitCommand
+ Command <|-- FindAppointmentCommand
+ Command <|-- HelpCommand
+ Command <|-- ListAppointmentCommand
+ Command <|-- ListPatientCommand
+ Command <|-- MarkApppointmentCommand
+ Command <|-- SortAppointmentCommand
+ Command <|-- StoreMedHistoryCommand
+ Command <|-- UnmarkAppointmentCommand
+ Command <|-- ViewAllPrescriptionsCommand
+ Command <|-- ViewMedHistoryCommand
+ Command <|-- ViewPatientCommand
+ Command <|-- ViewPrescriptionCommand
+
+ AddAppointmentCommand -[hidden]-> FindAppointmentCommand
+ AddPatientCommand -[hidden]-> HelpCommand
+ AddPrescriptionCommand -[hidden]-> ListAppointmentCommand
+ DeleteAppointmentCommand -[hidden]-> ListPatientCommand
+ DeletePatientCommand -[hidden]-> MarkApppointmentCommand
+ EditPatientCommand -[hidden]-> SortAppointmentCommand
+ EditPatientHistoryCommand -[hidden]-> StoreMedHistoryCommand
+ ExitCommand -[hidden]-> UnmarkAppointmentCommand
+}
+
+@enduml
\ No newline at end of file
diff --git a/docs/diagrams/addAppointmentSequence.png b/docs/diagrams/addAppointmentSequence.png
new file mode 100644
index 0000000000..e2999127bc
Binary files /dev/null and b/docs/diagrams/addAppointmentSequence.png differ
diff --git a/docs/diagrams/addAppointmentSequence.puml b/docs/diagrams/addAppointmentSequence.puml
new file mode 100644
index 0000000000..fe98dd9d96
--- /dev/null
+++ b/docs/diagrams/addAppointmentSequence.puml
@@ -0,0 +1,71 @@
+@startuml
+hide footbox
+
+actor User
+
+participant ":ClinicEase" as ClinicEase
+participant ":Parser" as Parser
+participant ":Appointment" as Appointment
+participant ":AddAppointmentCommand" as AddAppointmentCommand
+participant ":ManagementSystem" as ManagementSystem
+participant ":Storage" as Storage
+
+User -> ClinicEase : enter input
+activate ClinicEase
+ClinicEase -> Parser : parse(input)
+activate Parser
+
+Parser -> Parser : parseAddAppointment(userInput)
+activate Parser
+
+Parser -> Parser : extractValue(userInput)
+activate Parser
+note right of Parser: extractValue is called separately \n (not in a loop) to parse input and extract each parameter \n: NRIC, date, time, and description
+Parser --> Parser : :String
+deactivate Parser
+
+create Appointment
+Parser -> Appointment : new Appointment()
+activate Appointment
+Appointment --> Parser : appt :Appointment
+deactivate Appointment
+
+Parser --> Parser : appt :Appointment
+deactivate Parser
+
+
+
+create AddAppointmentCommand
+Parser -> AddAppointmentCommand : new AddAppointmentCommand(appt)
+activate AddAppointmentCommand
+AddAppointmentCommand --> Parser : :AddAppointmentCommand
+deactivate AddAppointmentCommand
+Parser --> ClinicEase : :AddAppointmentCommand
+deactivate Parser
+
+ClinicEase -> AddAppointmentCommand : execute()
+activate AddAppointmentCommand
+AddAppointmentCommand -> ManagementSystem : addAppointment(appointment)
+activate ManagementSystem
+
+ManagementSystem -> ManagementSystem : findPatientByNRIC()
+activate ManagementSystem
+ManagementSystem -> Appointment : getNric()
+activate Appointment
+Appointment --> ManagementSystem : nric :String
+deactivate Appointment
+ManagementSystem --> ManagementSystem : nric :String
+deactivate ManagementSystem
+
+ManagementSystem -> Storage : saveAppointments()
+activate Storage
+Storage --> ManagementSystem :
+deactivate Storage
+ManagementSystem --> AddAppointmentCommand :
+deactivate ManagementSystem
+AddAppointmentCommand --> ClinicEase :
+deactivate AddAppointmentCommand
+ClinicEase --> User : display message
+deactivate ClinicEase
+
+@enduml
\ No newline at end of file
diff --git a/docs/diagrams/addPatientSequence.png b/docs/diagrams/addPatientSequence.png
new file mode 100644
index 0000000000..fe5544fa8e
Binary files /dev/null and b/docs/diagrams/addPatientSequence.png differ
diff --git a/docs/diagrams/addPatientSequence.puml b/docs/diagrams/addPatientSequence.puml
new file mode 100644
index 0000000000..636139e5a9
--- /dev/null
+++ b/docs/diagrams/addPatientSequence.puml
@@ -0,0 +1,60 @@
+@startuml
+hide footbox
+
+participant ":ClinicEase" as ClinicEase
+participant ":Parser" as Parser
+participant ":AddPatientCommand" as AddPatientCommand
+participant ":ManagementSystem" as ManagementSystem
+participant ":Patient" as Patient
+participant ":Storage" as Storage
+
+ClinicEase -> Parser : parse(input)
+activate Parser
+
+Parser -> Parser : parseAddPatient(userInput)
+activate Parser
+Parser -> Parser : extractValue(userInput)
+activate Parser
+note right of Parser
+ extractValue is called multiple times\n
+ to get name, nric, dob, gender,\n
+ address, and phone
+end note
+Parser --> Parser : :String[]
+deactivate Parser
+
+create AddPatientCommand
+Parser -> AddPatientCommand : new AddPatientCommand(String[])
+activate AddPatientCommand
+AddPatientCommand --> Parser
+deactivate Parser
+Parser --> ClinicEase : :AddPatientCommand
+deactivate Parser
+
+ClinicEase -> AddPatientCommand : execute()
+activate AddPatientCommand
+AddPatientCommand -> ManagementSystem : addPatient(details)
+activate ManagementSystem
+ManagementSystem -> ManagementSystem : check if NRIC exists
+alt NRIC already exists
+ ManagementSystem --> AddPatientCommand : Error message
+else Else
+ create Patient
+ ManagementSystem -> Patient : new Patient(...)
+ activate Patient
+ Patient --> ManagementSystem :
+ deactivate Patient
+
+ ManagementSystem -> ManagementSystem : add patient to HashMap
+ ManagementSystem -> Storage : savePatients(patients)
+ activate Storage
+ Storage --> ManagementSystem :
+ deactivate Storage
+
+ ManagementSystem --> AddPatientCommand :
+ deactivate AddPatientCommand
+ deactivate ManagementSystem
+end
+AddPatientCommand --> ClinicEase :
+deactivate AddPatientCommand
+@enduml
\ No newline at end of file
diff --git a/docs/diagrams/deleteAppointmentSequence.png b/docs/diagrams/deleteAppointmentSequence.png
new file mode 100644
index 0000000000..6b7849ebd7
Binary files /dev/null and b/docs/diagrams/deleteAppointmentSequence.png differ
diff --git a/docs/diagrams/deleteAppointmentSequence.puml b/docs/diagrams/deleteAppointmentSequence.puml
new file mode 100644
index 0000000000..194bf76f38
--- /dev/null
+++ b/docs/diagrams/deleteAppointmentSequence.puml
@@ -0,0 +1,59 @@
+@startuml
+hide footbox
+
+actor User
+
+participant ":ClinicEase" as ClinicEase
+participant ":Parser" as Parser
+participant ":DeleteAppointmentCommand" as DeleteAppointmentCommand
+participant ":ManagementSystem" as ManagementSystem
+participant ":Appointment" as Appointment
+participant ":Storage" as Storage
+
+User -> ClinicEase : enter input
+activate ClinicEase
+ClinicEase -> Parser : parse(input)
+activate Parser
+
+Parser -> Parser : parseDeleteAppointment(userInput)
+activate Parser
+Parser --> Parser : apptId :String
+deactivate Parser
+
+create DeleteAppointmentCommand
+Parser -> DeleteAppointmentCommand : new DeleteAppointmentCommand(apptId)
+activate DeleteAppointmentCommand
+DeleteAppointmentCommand --> Parser : :DeleteAppointmentCommand
+deactivate DeleteAppointmentCommand
+Parser --> ClinicEase : :DeleteAppointmentCommand
+deactivate Parser
+
+ClinicEase -> DeleteAppointmentCommand : execute()
+activate DeleteAppointmentCommand
+DeleteAppointmentCommand -> ManagementSystem : deleteAppointment(apptId)
+
+activate ManagementSystem
+ManagementSystem -> ManagementSystem : findPatientByNRIC()
+activate ManagementSystem
+ManagementSystem -> Appointment : getNric()
+activate Appointment
+Appointment --> ManagementSystem : nric :String
+deactivate Appointment
+ManagementSystem --> ManagementSystem : nric :String
+deactivate ManagementSystem
+
+ManagementSystem -> Storage : saveAppointments()
+activate Storage
+Storage --> ManagementSystem :
+deactivate Storage
+ManagementSystem --> DeleteAppointmentCommand :
+deactivate ManagementSystem
+
+deactivate ManagementSystem
+DeleteAppointmentCommand --> ClinicEase :
+deactivate DeleteAppointmentCommand
+ClinicEase --> User : display message
+deactivate ClinicEase
+
+
+@enduml
\ No newline at end of file
diff --git a/docs/diagrams/deletePatientSequence.png b/docs/diagrams/deletePatientSequence.png
new file mode 100644
index 0000000000..ce3f5b9726
Binary files /dev/null and b/docs/diagrams/deletePatientSequence.png differ
diff --git a/docs/diagrams/deletePatientSequence.puml b/docs/diagrams/deletePatientSequence.puml
new file mode 100644
index 0000000000..2106a8c6d1
--- /dev/null
+++ b/docs/diagrams/deletePatientSequence.puml
@@ -0,0 +1,53 @@
+@startuml
+hide footbox
+
+participant ":ClinicEase" as ClinicEase
+participant ":Parser" as Parser
+participant ":DeletePatientCommand" as DeletePatientCommand
+participant ":ManagementSystem" as ManagementSystem
+participant ":Storage" as Storage
+
+ClinicEase -> Parser : parse(input)
+activate Parser
+
+Parser -> Parser : parseDeletePatient(userInput)
+activate Parser
+Parser --> Parser : :String (nric)
+deactivate Parser
+
+create DeletePatientCommand
+Parser -> DeletePatientCommand : new DeletePatientCommand(String)
+activate DeletePatientCommand
+DeletePatientCommand --> Parser
+Parser --> ClinicEase : :DeletePatientCommand
+deactivate Parser
+
+ClinicEase -> DeletePatientCommand : execute()
+activate DeletePatientCommand
+DeletePatientCommand -> ManagementSystem : deletePatient(nric)
+activate ManagementSystem
+ManagementSystem -> ManagementSystem : find matching NRIC in list
+
+alt Patient found
+ ManagementSystem -> ManagementSystem : remove patient from list
+ ManagementSystem -> ManagementSystem : remove patient’s appointments
+ ManagementSystem -> Storage : savePatients(patients)
+ activate Storage
+ Storage --> ManagementSystem
+ deactivate Storage
+
+ ManagementSystem -> Storage : saveAppointments(appointments)
+ activate Storage
+ Storage --> ManagementSystem
+ deactivate Storage
+
+ ManagementSystem --> DeletePatientCommand : deleted Patient
+else Patient not found
+ ManagementSystem --> DeletePatientCommand : null
+ deactivate ManagementSystem
+ deactivate DeletePatientCommand
+end
+
+DeletePatientCommand --> ClinicEase : Result (success/failure message)
+deactivate DeletePatientCommand
+@enduml
diff --git a/docs/diagrams/mainComponent.png b/docs/diagrams/mainComponent.png
new file mode 100644
index 0000000000..e23265c288
Binary files /dev/null and b/docs/diagrams/mainComponent.png differ
diff --git a/docs/diagrams/mainComponent.puml b/docs/diagrams/mainComponent.puml
new file mode 100644
index 0000000000..c27df1c638
--- /dev/null
+++ b/docs/diagrams/mainComponent.puml
@@ -0,0 +1,22 @@
+@startuml
+skinparam classAttributeIconSize 0
+
+package "Main Component"{
+class ClinicEase {
+ - ManagementSystem manager
+ - Ui ui
+ - Storage storage
+
+ + ClinicEase(filePath: String)
+ + run(): void
+ + main(args: String[]): void
+}
+}
+
+ClinicEase --> UI
+ClinicEase --> Storage
+ClinicEase --> ManagementSystem
+ClinicEase ..> Command
+
+hide circle
+@enduml
\ No newline at end of file
diff --git a/docs/diagrams/managerComponent.png b/docs/diagrams/managerComponent.png
new file mode 100644
index 0000000000..410201dd3f
Binary files /dev/null and b/docs/diagrams/managerComponent.png differ
diff --git a/docs/diagrams/managerComponent.puml b/docs/diagrams/managerComponent.puml
new file mode 100644
index 0000000000..b5988db00f
--- /dev/null
+++ b/docs/diagrams/managerComponent.puml
@@ -0,0 +1,44 @@
+@startuml
+skinparam classAttributeIconSize 0
+
+package "Manager Component"{
+class ManagementSystem {
+ - appointments : List
+ - patients : List
+ - prescriptions : List
+
+ + ManagementSystem(List, List)
+ + ManagementSystem(List, List, List)
+
+ + getPatients() : List
+ + setAppointments(List) : void
+ + getAppointments() : List
+ + addPatient(Patient) : void
+ + deletePatient(String) : Patient
+ + viewPatient(String) : Patient
+ + editPatient(String, String, String, String, String, String) : void
+ + storeMedicalHistory(String, String) : void
+ + viewMedicalHistoryByNric(String) : void
+ + viewMedicalHistoryByName(String) : void
+ + editPatientHistory(String, String, String) : void
+ + findPatientByNric(String) : Patient
+ + addAppointment(Appointment) : void
+ + deleteAppointment(String) : Appointment
+ + sortAppointmentsByDateTime(List) : List
+ + sortAppointmentsById(List) : List
+ + markAppointment(String) : Appointment
+ + unmarkAppointment(String) : Appointment
+ + findAppointmentsByNric(String) : List
+ + getPrescriptions() : List
+ + addPrescription(Prescription) : Prescription
+}
+}
+
+ClinicEase --> ManagementSystem
+ManagementSystem --> Patient
+ManagementSystem --> Appointment
+ManagementSystem --> Prescription
+
+hide circle
+@enduml
+
diff --git a/docs/diagrams/objectComponent.png b/docs/diagrams/objectComponent.png
new file mode 100644
index 0000000000..f6688f08fd
Binary files /dev/null and b/docs/diagrams/objectComponent.png differ
diff --git a/docs/diagrams/objectComponent.puml b/docs/diagrams/objectComponent.puml
new file mode 100644
index 0000000000..877c8a0c0b
--- /dev/null
+++ b/docs/diagrams/objectComponent.puml
@@ -0,0 +1,89 @@
+@startuml
+skinparam classAttributeIconSize 0
+
+package "Object Component" {
+class Patient {
+ - id: String
+ - name: String
+ - dob: LocalDate
+ - contactInfo: String
+ - gender: String
+ - address: String
+ - medicalHistory: List
+ - appointments: List
+
+ + Patient(id, name, dobStr, gender, address, contactInfo, medicalHistory)
+ + getId(): String
+ + getName(): String
+ + getDob(): LocalDate
+ + getGender(): String
+ + getAddress(): String
+ + getContactInfo(): String
+ + getMedicalHistory(): List
+ + setName(name: String): void
+ + setDob(dob: LocalDate): void
+ + setContactInfo(info: String): void
+ + setGender(gender: String): void
+ + setAddress(address: String): void
+ + getAppointments(): List
+ + addAppointment(appointment: Appointment): void
+ + deleteAppointment(apptId: String): void
+ + toString(): String
+ + toStringForListView(): String
+ + toFileFormat(): String
+}
+
+class Appointment {
+ - id : String
+ - nric : String
+ - dateTime : LocalDateTime
+ - description : String
+ - isDone : boolean
+
+ + Appointment(nric: String, dateTime: LocalDateTime, description: String)
+ + Appointment(id: String, nric: String, dateTime: LocalDateTime, description: String)
+ + getId(): String
+ + setRunningId(newId: int): void
+ + getNric(): String
+ + getDate(): LocalDate
+ + getTime(): LocalTime
+ + getDateTime(): LocalDateTime
+ + getRunningId(): int
+ + getDescription(): String
+ + isDone(): boolean
+ + markAsDone(): void
+ + unmarkAsDone(): void
+ + setIsDone(mark: boolean): void
+ + getStatusIcon(): String
+ + toString(): String
+ + toFileFormat(): String
+}
+
+class Prescription {
+ - patientId : String
+ - timestamp : LocalDateTime
+ - prescriptionId : String
+ - symptoms : List
+ - medicines : List
+ - notes : String
+
+ + getPatientId(): String
+ + getPrescriptionId(): String
+ + getTimestamp(): LocalDateTime
+ + getSymptoms(): List
+ + getMedicines(): List
+ + getNotes(): String
+ + toString(): String
+ + toFileFormat(): String
+ + static fromFileFormat(String): Prescription
+ + generateHtml(Patient): String
+}
+
+}
+
+ManagementSystem --> Patient
+ManagementSystem --> Appointment
+ManagementSystem --> Prescription
+
+hide circle
+@enduml
diff --git a/docs/diagrams/parserClassDiagram.png b/docs/diagrams/parserClassDiagram.png
new file mode 100644
index 0000000000..f6ef29bdae
Binary files /dev/null and b/docs/diagrams/parserClassDiagram.png differ
diff --git a/docs/diagrams/parserClassDiagram.puml b/docs/diagrams/parserClassDiagram.puml
new file mode 100644
index 0000000000..60ecb02ee4
--- /dev/null
+++ b/docs/diagrams/parserClassDiagram.puml
@@ -0,0 +1,52 @@
+@startuml
+skinparam classAttributeIconSize 0
+hide circle
+
+abstract class Command {
+ + {abstract} execute(manager: ManagementSystem, ui: Ui): void
+ + {abstract} isExit(): boolean
+}
+
+class Parser {
+ + {static} parse(input: String): Command
+ - {static} parseAddPatient(input: String): Patient
+ - {static} parseDeletePatient(input: String): String
+ - {static} parseViewPatient(input: String): String
+ + {static} parseViewHistory(input: String): String[]
+ + {static} parseStoreHistory(input: String): String[]
+ - {static} parseAddAppointment(input: String): Appointment
+ - {static} parseDeleteAppointment(input: String): String
+ - {static} parseSortAppointment(input: String): String
+ - {static} parseMarkAppointment(input: String): String
+ - {static} parseUnmarkAppointment(input: String): String
+ - {static} parseFindAppointment(input: String): String
+ - {static} parseEditPatient(input: String): String[]
+ - {static} parseEditHistory(input: String): String[]
+ + {static} parseLoadPatient(line: String): Patient
+ + {static} parseLoadAppointment(line: String): Appointment
+ + {static} parseAddPrescription(input: String): Prescription
+ + {static} parseViewAllPrescriptions(input: String): String
+ + {static} parseViewPrescription(input: String): String
+ - {static} extractValue(input: String, prefix: String): String
+}
+
+class XYZCommand extends Command {
+ # commandData: SubData
+ + execute(manager: ManagementSystem, ui: Ui): void
+ + isExit(): boolean
+}
+
+class SubData {
+ - field1: Type
+ - field2: Type
+}
+
+Parser --> "1" XYZCommand : creates >
+Parser --> SubData : creates >
+
+XYZCommand --> SubData : uses >
+
+note top of Parser : Parses input into executable commands
+note bottom of XYZCommand: - XYZcommand = AddPatientCommand, AddAppointmentCommand, etc... \n- execute and isExit are overridden \n- Constructor: XYZCommand(SubData data)
+note right of SubData : - Subdata = Patient, Appointment and Prescription \n- field1 and field2 represent the variables extracted using Parser.extractValue()
+@enduml
diff --git a/docs/diagrams/parserSequence.png b/docs/diagrams/parserSequence.png
new file mode 100644
index 0000000000..7fa74efe26
Binary files /dev/null and b/docs/diagrams/parserSequence.png differ
diff --git a/docs/diagrams/parserSequence.puml b/docs/diagrams/parserSequence.puml
new file mode 100644
index 0000000000..6ad4f4e482
--- /dev/null
+++ b/docs/diagrams/parserSequence.puml
@@ -0,0 +1,45 @@
+@startuml
+hide footbox
+
+
+participant ":ClinicEase" as ClinicEase
+box "Interactions happened in Parser" #F0F0F0
+participant ":Parser" as Parser
+participant ":Appointment" as Appointment
+participant ":AddAppointmentCommand" as AddAppointmentCommand
+end box
+
+ClinicEase -> Parser : parse("add-appointment ic/...")
+activate ClinicEase
+
+activate Parser
+Parser -> Parser : parseAddAppointment(userInput)
+activate Parser #lightblue
+
+Parser -> Parser : extractValue(userInput)
+activate Parser #lightgreen
+note right of Parser: extractValue is called separately \n (not in a loop) to parse input and extract each parameter \n: NRIC, date, time, and description
+Parser --> Parser : :String
+deactivate Parser
+
+create Appointment
+Parser -> Appointment : new Appointment()
+activate Appointment
+Appointment --> Parser : appt :Appointment
+deactivate Appointment
+
+Parser --> Parser : appt :Appointment
+deactivate Parser
+
+
+create AddAppointmentCommand
+Parser -> AddAppointmentCommand : new AddAppointmentCommand(appt)
+activate AddAppointmentCommand
+AddAppointmentCommand --> Parser : :AddAppointmentCommand
+deactivate AddAppointmentCommand
+Parser --> ClinicEase : :AddAppointmentCommand
+deactivate Parser
+deactivate ClinicEase
+
+
+@enduml
\ No newline at end of file
diff --git a/docs/diagrams/prescriptionClassDiagram.png b/docs/diagrams/prescriptionClassDiagram.png
new file mode 100644
index 0000000000..04fd0cc997
Binary files /dev/null and b/docs/diagrams/prescriptionClassDiagram.png differ
diff --git a/docs/diagrams/prescriptionClassDiagram.puml b/docs/diagrams/prescriptionClassDiagram.puml
new file mode 100644
index 0000000000..15df428e32
--- /dev/null
+++ b/docs/diagrams/prescriptionClassDiagram.puml
@@ -0,0 +1,86 @@
+@startuml
+skinparam classAttributeIconSize 0
+hide circle
+
+class Prescription {
+ - patientId: String
+ - prescriptionId: String
+ - timestamp: LocalDateTime
+ - symptoms: List
+ - medicines: List
+ - notes: String
+ + Prescription(patientId: String, symptoms: List, medicines: List, notes: String)
+ + Prescription(patientId: String, prescriptionId: String, timestamp: LocalDateTime, symptoms: List, medicines: List, notes: String)
+ + getPatientId(): String
+ + getPrescriptionId(): String
+ + getTimestamp(): LocalDateTime
+ + getSymptoms(): List
+ + getMedicines(): List
+ + getNotes(): String
+ + toString(): String
+ + toFileFormat(): String
+ + {static} fromFileFormat(fileEntry: String): Prescription
+ + generateHtml(patient: Patient): String
+}
+
+class AddPrescriptionCommand extends Command {
+ - prescription: Prescription
+ + AddPrescriptionCommand(prescription: Prescription)
+ + execute(manager: ManagementSystem, ui: Ui): void
+ + isExit(): boolean
+}
+
+class ViewPrescriptionCommand extends Command {
+ - prescriptionId: String
+ + ViewPrescriptionCommand(prescriptionId: String)
+ + execute(manager: ManagementSystem, ui: Ui): void
+ + isExit(): boolean
+}
+
+class ViewAllPrescriptionsCommand extends Command {
+ - patientId: String
+ + ViewAllPrescriptionsCommand(patientId: String)
+ + execute(manager: ManagementSystem, ui: Ui): void
+ + isExit(): boolean
+}
+
+class ManagementSystem {
+ - prescriptions: List
+ + getPrescriptions(): List
+ + addPrescription(prescription: Prescription): Prescription
+ + getPrescriptionsForPatient(patientId: String): List
+ + getPrescriptionById(prescriptionId: String): Prescription
+}
+
+class Parser {
+ + {static} parseAddPrescription(input: String): Prescription
+ + {static} parseViewAllPrescriptions(input: String): String
+ + {static} parseViewPrescription(input: String): String
+}
+
+class Storage {
+ + {static} savePrescriptions(prescriptions: List): void
+ + {static} loadPrescriptions(): List
+ + {static} savePrescriptionHtml(prescription: Prescription, patient: Patient): void
+}
+
+abstract class Command {
+ + {abstract} execute(manager: ManagementSystem, ui: Ui): void
+ + {abstract} isExit(): boolean
+}
+
+Patient "1" -- "0..*" Prescription: has >
+
+ManagementSystem "1" --o "0..*" Prescription: manages >
+
+AddPrescriptionCommand "1" --o "1" Prescription: creates >
+ViewPrescriptionCommand .. ManagementSystem: retrieves prescription from >
+ViewAllPrescriptionsCommand .. ManagementSystem: retrieves prescriptions from >
+
+Parser ..> AddPrescriptionCommand: creates >
+Parser ..> ViewPrescriptionCommand: creates >
+Parser ..> ViewAllPrescriptionsCommand: creates >
+
+Storage ..> Prescription: saves/loads >
+
+@enduml
\ No newline at end of file
diff --git a/docs/diagrams/prescriptionManagementSequence.png b/docs/diagrams/prescriptionManagementSequence.png
new file mode 100644
index 0000000000..895f5af067
Binary files /dev/null and b/docs/diagrams/prescriptionManagementSequence.png differ
diff --git a/docs/diagrams/prescriptionManagementSequence.puml b/docs/diagrams/prescriptionManagementSequence.puml
new file mode 100644
index 0000000000..b6da5dbf3f
--- /dev/null
+++ b/docs/diagrams/prescriptionManagementSequence.puml
@@ -0,0 +1,76 @@
+@startuml
+hide footbox
+
+actor User
+
+participant ":ClinicEase" as ClinicEase
+participant ":Parser" as Parser
+participant ":AddPrescriptionCommand" as AddPrescriptionCommand
+participant ":ManagementSystem" as ManagementSystem
+participant ":Prescription" as Prescription
+participant ":Storage" as Storage
+
+User -> ClinicEase : enter input
+activate ClinicEase
+ClinicEase -> Parser : parse(input)
+activate Parser
+
+Parser -> Parser : parseAddPrescription(userInput)
+activate Parser
+Parser -> Parser : extractValue(userInput)
+activate Parser
+note right of Parser: extractValue is called multiple times\n to parse patient ID, symptoms, medicines, and notes
+Parser --> Parser : :String
+deactivate Parser
+
+create Prescription
+Parser -> Prescription : new Prescription(patientId, symptomsList, medicinesList, notes)
+activate Prescription
+Prescription --> Parser : prescription : Prescription
+deactivate Prescription
+deactivate Parser
+
+create AddPrescriptionCommand
+Parser -> AddPrescriptionCommand : new AddPrescriptionCommand(prescription)
+activate AddPrescriptionCommand
+AddPrescriptionCommand --> Parser : :AddPrescriptionCommand
+deactivate AddPrescriptionCommand
+Parser --> ClinicEase : :AddPrescriptionCommand
+deactivate Parser
+
+ClinicEase -> AddPrescriptionCommand : execute()
+activate AddPrescriptionCommand
+AddPrescriptionCommand -> ManagementSystem : addPrescription(prescription)
+activate ManagementSystem
+ManagementSystem -> ManagementSystem : findPatientByNric()
+activate ManagementSystem
+ManagementSystem --> ManagementSystem : patient : Patient
+deactivate ManagementSystem
+
+alt Patient not found
+ ManagementSystem --> AddPrescriptionCommand : throw IllegalArgumentException
+else Patient found
+ ManagementSystem -> ManagementSystem : Generate prescription ID
+
+ create Prescription
+ ManagementSystem -> Prescription : new Prescription(patientId, prescriptionId, timestamp, symptoms, medicines, notes)
+ activate Prescription
+ Prescription --> ManagementSystem : newPrescription : Prescription
+ deactivate Prescription
+
+ ManagementSystem -> Storage : savePrescriptions(prescriptions)
+ activate Storage
+ Storage --> ManagementSystem
+ deactivate Storage
+
+ ManagementSystem --> AddPrescriptionCommand : newPrescription : Prescription
+end
+deactivate ManagementSystem
+
+AddPrescriptionCommand -> AddPrescriptionCommand : Display prescription details
+AddPrescriptionCommand --> ClinicEase
+deactivate AddPrescriptionCommand
+ClinicEase --> User : display message
+deactivate ClinicEase
+
+@enduml
\ No newline at end of file
diff --git a/docs/diagrams/storageComponent.png b/docs/diagrams/storageComponent.png
new file mode 100644
index 0000000000..7fb06e5bcb
Binary files /dev/null and b/docs/diagrams/storageComponent.png differ
diff --git a/docs/diagrams/storageComponent.puml b/docs/diagrams/storageComponent.puml
new file mode 100644
index 0000000000..760805bc1d
--- /dev/null
+++ b/docs/diagrams/storageComponent.puml
@@ -0,0 +1,44 @@
+@startuml
+skinparam componentStyle rectangle
+hide circle
+
+package "Storage Component" {
+
+ class Storage {
+ - directoryPath : String
+ - patientFilePath : String
+ - appointmentFilePath : String
+ - prescriptionFilePath : String
+ - prescriptionDirPath : String
+ - patients : Patient
+
+ + Storage(directory : String)
+ + savePatients(patientList : List) : void
+ + loadPatients() : List
+ + saveAppointments(appointmentList : List) : void
+ + loadAppointments(system : ManagementSystem) : List
+ + savePrescriptions(prescriptionList : List) : void
+ + loadPrescriptions() : List
+ + savePrescriptionHtml(prescription : Prescription, patient : Patient) : void
+ }
+
+ }
+
+ package "Objects" {
+ class Patient
+ class Appointment
+ class Prescription
+ }
+
+ package "Utils" {
+ class Parser
+ class ManagementSystem
+ }
+
+ Storage ..> Patient
+ Storage ..> Appointment
+ Storage ..> Prescription
+ Storage ..> Parser
+ Storage <..> ManagementSystem
+
+@enduml
\ No newline at end of file
diff --git a/docs/diagrams/storeMedicalHistorySequence.png b/docs/diagrams/storeMedicalHistorySequence.png
new file mode 100644
index 0000000000..2e7cf05006
Binary files /dev/null and b/docs/diagrams/storeMedicalHistorySequence.png differ
diff --git a/docs/diagrams/storeMedicalHistorySequence.puml b/docs/diagrams/storeMedicalHistorySequence.puml
new file mode 100644
index 0000000000..cc9e3f1fed
--- /dev/null
+++ b/docs/diagrams/storeMedicalHistorySequence.puml
@@ -0,0 +1,54 @@
+@startuml
+hide footbox
+
+participant ":ClinicEase" as ClinicEase
+participant ":Parser" as Parser
+participant ":StoreMedHistoryCommand" as StoreMedHistoryCommand
+participant ":ManagementSystem" as ManagementSystem
+participant ":Patient" as Patient
+participant ":Storage" as Storage
+
+ClinicEase -> Parser : parse(input)
+activate Parser
+
+Parser -> Parser : parseStoreHistory(userInput)
+activate Parser
+Parser -> Parser : extractValue(userInput)
+activate Parser
+note right of Parser
+ extractValue is called multiple times
+ to parse input and extract parameters
+end note
+Parser --> Parser : :String
+deactivate Parser
+
+create StoreMedHistoryCommand
+Parser -> StoreMedHistoryCommand : new StoreMedHistoryCommand(String[])
+activate StoreMedHistoryCommand
+StoreMedHistoryCommand --> Parser : :StoreMedHistoryCommand
+deactivate StoreMedHistoryCommand
+Parser --> ClinicEase : :StoreMedHistoryCommand
+deactivate Parser
+
+ClinicEase -> StoreMedHistoryCommand : execute()
+activate StoreMedHistoryCommand
+StoreMedHistoryCommand -> ManagementSystem : storeMedicalHistory(name, nric, medHistory)
+activate ManagementSystem
+ManagementSystem -> ManagementSystem : findPatientByNric(nric)
+activate ManagementSystem
+ManagementSystem -> Patient : getMedicalHistory()
+activate Patient
+Patient --> ManagementSystem : returns List
+deactivate Patient
+deactivate ManagementSystem
+
+ManagementSystem -> Storage : savePatients(patients)
+activate Storage
+Storage --> ManagementSystem :
+deactivate Storage
+ManagementSystem --> StoreMedHistoryCommand :
+deactivate ManagementSystem
+StoreMedHistoryCommand -> ClinicEase :
+deactivate StoreMedHistoryCommand
+
+@enduml
diff --git a/docs/diagrams/uiComponent.png b/docs/diagrams/uiComponent.png
new file mode 100644
index 0000000000..10ef43302e
Binary files /dev/null and b/docs/diagrams/uiComponent.png differ
diff --git a/docs/diagrams/uiComponent.puml b/docs/diagrams/uiComponent.puml
new file mode 100644
index 0000000000..3a7c15bfb4
--- /dev/null
+++ b/docs/diagrams/uiComponent.puml
@@ -0,0 +1,33 @@
+@startuml
+skinparam classAttributeIconSize 0
+
+package "UI Component" {
+ class UI {
+ - Scanner sc
+ + Ui()
+ + showWelcome(): void
+ + showBye(): void
+ + showLine(): void
+ + readCommand(): String
+ + showError(message: String): void
+ + showHelp(): void
+ + showPatientAdded(patients: List): void
+ + showPatientDeleted(removedPatient: Patient, nric: String): void
+ + showPatientViewed(matchedPatient: Patient, nric: String): void
+ + showPatientList(patients: List): void
+ + showPatientHistory(patient: Patient): void
+ + showAppointmentAdded(appointments: List): void
+ + showAppointmentDeleted(appointments: List, removedAppointment: Appointment, apptId: String): void
+ + showAppointmentMarked(appointments: List, markedAppointment: Appointment, apptId: String): void
+ + showAppointmentUnmarked(appointments: List, markedAppointment: Appointment, apptId: String): void
+ + showAppointmentList(appointments: List): void
+ + showAppointmentsFound(appointments: List, nric: String): void
+ }
+
+}
+
+UI ..> Object
+Main --> UI
+
+hide circle
+@enduml
diff --git a/docs/diagrams/viewPatientSequence.png b/docs/diagrams/viewPatientSequence.png
new file mode 100644
index 0000000000..474b9e47a3
Binary files /dev/null and b/docs/diagrams/viewPatientSequence.png differ
diff --git a/docs/diagrams/viewPatientSequence.puml b/docs/diagrams/viewPatientSequence.puml
new file mode 100644
index 0000000000..3c4d06d409
--- /dev/null
+++ b/docs/diagrams/viewPatientSequence.puml
@@ -0,0 +1,60 @@
+@startuml
+hide footbox
+
+actor User
+
+participant ":ClinicEase" as ClinicEase
+participant ":UI" as UI
+participant ":Parser" as Parser
+participant ":ViewPatientCommand" as ViewPatientCommand
+participant ":ManagementSystem" as ManagementSystem
+participant ":Patient" as Patient
+
+User -> ClinicEase : enter input
+activate ClinicEase
+
+ClinicEase -> UI : readCommand()
+activate UI
+
+UI --> ClinicEase : input
+deactivate UI
+ClinicEase -> Parser : parse(input)
+activate Parser
+Parser -> Parser : parseViewPatient(userInput)
+activate Parser
+Parser -> Parser : extractValue(userInput)
+activate Parser
+deactivate Parser
+Parser --> Parser : nric :String
+deactivate Parser
+
+Parser --> ClinicEase : ViewPatientCommand
+
+deactivate Parser
+
+ClinicEase -> ViewPatientCommand : execute()
+activate ViewPatientCommand
+
+ViewPatientCommand -> ManagementSystem : viewPatient(nric)
+activate ManagementSystem
+
+ManagementSystem -> Patient : getPatient(nric)
+activate Patient
+
+Patient --> ManagementSystem : matchedPatient
+deactivate Patient
+
+ManagementSystem --> ViewPatientCommand
+deactivate ManagementSystem
+
+ViewPatientCommand -> UI : showPatientViewed(matchedPatient)
+deactivate ViewPatientCommand
+activate UI
+
+UI --> ClinicEase
+deactivate UI
+
+ClinicEase --> User
+deactivate ClinicEase
+
+@enduml
diff --git a/docs/team/basudeb2005.md b/docs/team/basudeb2005.md
new file mode 100644
index 0000000000..f84b42c53e
--- /dev/null
+++ b/docs/team/basudeb2005.md
@@ -0,0 +1,94 @@
+# Basudeb Chakraborty - Project Portfolio Page
+
+## Overview
+ClinicEase is a desktop app with a command-line interface for doctors to manage patients, appointments, and prescriptions. It allows tracking medical histories, scheduling, and exporting detailed prescriptions in HTML format.
+
+## Summary of Contributions
+
+### Code contributed
+[RepoSense Code Dashboard](https://nus-cs2113-ay2425s2.github.io/tp-dashboard/?search=&sort=groupTitle%20dsc&sortWithin=title&since=2025-02-21&timeframe=commit&mergegroup=&groupSelect=groupByRepos&breakdown=false&tabOpen=true&tabType=authorship&tabAuthor=Basudeb2005&tabRepo=AY2425S2-CS2113-T11b-4%2Ftp%5Bmaster%5D&authorshipIsMergeGroup=false&authorshipFileTypes=docs~functional-code~test-code&authorshipIsBinaryFileTypeChecked=false&authorshipIsIgnoredFilesChecked=false)
+
+Full URL: [https://nus-cs2113-ay2425s2.github.io/tp-dashboard/?search=&sort=groupTitle%20dsc&sortWithin=title&since=2025-02-21&timeframe=commit&mergegroup=&groupSelect=groupByRepos&breakdown=false&tabOpen=true&tabType=authorship&tabAuthor=Basudeb2005&tabRepo=AY2425S2-CS2113-T11b-4%2Ftp%5Bmaster%5D&authorshipIsMergeGroup=false&authorshipFileTypes=docs~functional-code~test-code&authorshipIsBinaryFileTypeChecked=false&authorshipIsIgnoredFilesChecked=false](https://nus-cs2113-ay2425s2.github.io/tp-dashboard/?search=&sort=groupTitle%20dsc&sortWithin=title&since=2025-02-21&timeframe=commit&mergegroup=&groupSelect=groupByRepos&breakdown=false&tabOpen=true&tabType=authorship&tabAuthor=Basudeb2005&tabRepo=AY2425S2-CS2113-T11b-4%2Ftp%5Bmaster%5D&authorshipIsMergeGroup=false&authorshipFileTypes=docs~functional-code~test-code&authorshipIsBinaryFileTypeChecked=false&authorshipIsIgnoredFilesChecked=false)
+
+### Enhancements implemented
+
+#### 1. Core Application Structure
+I designed and implemented the foundational structure of the application, including:
+- Initial UI class setup with welcome/goodbye messages and command reading functionality
+- Parser framework for processing user commands
+- Basic application workflow in ClinicEase main class
+
+#### 2. Appointment Management System
+I implemented key appointment features:
+- Appointment class design with unique IDs and status tracking
+- Add appointment command to schedule patient appointments
+- Delete appointment functionality to remove unnecessary appointments
+- Appointment display functionality in UI with proper formatting
+
+#### 3. Prescription Management System
+I implemented the complete Prescription Management System, a key feature that enables doctors to create and manage patient prescriptions in the ClinicEase application:
+- **Prescription Class Design**: Designed and implemented the `Prescription` class with essential attributes and functionality:
+ - Storage of patient details, symptoms, medicines, and notes
+ - Automatic generation of unique prescription IDs
+ - Timestamp recording for each prescription
+
+- **Prescription Commands**: Implemented three main commands for managing prescriptions:
+ - `add-prescription`: Allows doctors to create new prescriptions with patient ID, symptoms, medicines, and optional notes
+ - `view-all-prescriptions`: Shows all prescriptions for a specific patient
+ - `view-prescription`: Displays details of a specific prescription by ID
+
+- **HTML Generation**: Created a feature that generates HTML prescription documents for printing:
+ - Professional layout with CSS styling
+ - Organized sections for patient information, symptoms, medicines, and special instructions
+ - Print functionality via a button in the HTML document
+
+- **Storage and Persistence**: Implemented storage functionality to save and retrieve prescriptions from the file system with a custom serialization format.
+
+- **Comprehensive Testing**: Created an extensive test suite for the prescription subsystem: Unit tests for all prescription-related classes, Integration tests for prescription management functionality, End-to-end testing of the prescription workflow.
+
+### Contributions to the User Guide
+
+- Added the "Managing Prescriptions" section, documenting:
+ - Command format and examples for adding prescriptions
+ - Instructions for viewing all prescriptions for a patient
+ - Instructions for viewing specific prescriptions and generating HTML reports
+ - Command summary section for all prescription-related commands
+
+### Contributions to the Developer Guide
+
+- Added documentation for the core application structure
+- Added documentation for the prescription management features, including Use cases for adding, viewing, and generating prescriptions, Manual testing instructions for prescription management, and User stories related to prescription functionality.
+
+### Contributions to team-based tasks
+
+- Set up the initial application architecture that the team built upon
+- Integrated the prescription management subsystem with the existing patient management system and ensured compatibility of prescription commands with the overall parsing structure
+
+### Features I'm proud of
+
+1. **HTML Prescription Generation**
+ - The ability to generate professional-looking prescriptions that doctors can print was a feature I'm particularly proud of implementing. This bridges the gap between digital management and the physical documents patients need.
+
+2. **Comprehensive Prescription Workflow**
+ - Creating a complete end-to-end solution that handles everything from prescription creation to storage to retrieval to presentation was a significant achievement.
+
+3. **Robust Testing Framework**
+ - The extensive test suite I developed ensures the reliability of the prescription system, with test coverage for all major components and operations.
+
+4. **Technical Documentation**
+ - The detailed sequence and class diagrams help future developers understand the architecture and implementation of the prescription management feature.
+
+5. **Architecture Documentation Blueprint**
+ - Created initial architecture diagram
+ - Created the sequence diagrams
+ - Collaborated with the team to refine and evolve the architecture diagram
+
+### Issues Resolved
+
+1. **Better User Experience**
+ - Fixed vague error messages for prescription commands
+ - Provided clearer, more intuitive feedback
+
+2. **Prescription Storage Bug Fixed**
+ - Resolved "Index out of bounds" error when loading over 5 prescriptions
+ - Enabled support for unlimited entries and prevented data loss
\ No newline at end of file
diff --git a/docs/team/chwenyee.md b/docs/team/chwenyee.md
new file mode 100644
index 0000000000..4d06050d15
--- /dev/null
+++ b/docs/team/chwenyee.md
@@ -0,0 +1,88 @@
+# Wen Yee's Project Portfolio Page
+
+## Project: ClinicEase
+
+**ClinicEase** is a CLI-based clinic management program that helps doctors - our target users - to efficiently manage patient records,
+medical histories, and appointments. The system enables user to view and update patient details,
+manage appointments, maintain medical history records, and manage prescriptions.
+This project aims to simplify clinic administrative tasks with a user-friendly interface.
+
+## Summary of Contributions
+Code Dashboard Link: [Wen Yee's Code Dashboard](https://nus-cs2113-ay2425s2.github.io/tp-dashboard/?search=chwenyee&breakdown=true&sort=groupTitle%20dsc&sortWithin=title&since=2025-02-21&timeframe=commit&mergegroup=&groupSelect=groupByRepos&checkedFileTypes=docs~functional-code~test-code~other)
+
+### Enhancement Implemented
+
+1. Reformat the UI output to ensure a consistent and aligned display format across the program.
+2. Introduced custom exceptions e.g. `DuplicatePatientIDException`, `UnknownCommandException` and `InvalidInputFormatException`
+in v1.0 to enable more graceful error handling.
+3. Improved the logic of `Parser.extractValue()` to correctly extract user input parameters, especially when both `dt/` and `t/`
+are present.
+4. Restructured the code in `ClinicEase.java` and `Parser.java`, and created a `command` package to make the codebase more OOP after v1.0.
+5. Linked `Appointment` Class to `Patient` Class to ensure appointments stored in a `Patient` object are kept in sync
+with the appointment list in `ManagementSystem`.
+6. Changed the data type of `dateTime` variable in `Appointment` to be `LocalDateTime` for better input validation of
+`dt/` and `t/`, and to simplify the implementation of the `sort-appointment` feature.
+7. Added comprehensive validation for: NRIC format compliance, appointment scheduling conflicts (throws `AppointmentClashException`)
+and future-dated appointments (prevents past-date/time entries)
+8. Implemented cleanup of associated appointment records when the patient is deleted.
+9. Added JavaDoc for files such as AddAppointmentCommand, DeleteAppointmentCommand, ListAppointmentCommand, SortAppointmentCommand,
+Appointment, ExitCommand, HelpCommand, and Parser.
+
+#### Features Implemented
+- `add-appointment`: Adds a new appointment.
+- `delete-appointment`: Deletes a specified appointment.
+- `sort-appointment`: Sorts appointments by `byDate` or `byId`.
+- `help`: Lists all available commands.
+
+#### Contributions to the UG:
+- Wrote sections: Table of Contents, Quick Start, Features (`help`, `add-appointment`, `delete-appointment`, `sort-appointment`, `bye`).
+- Added "NOTES" on feature's command syntax, parameters (`NRIC`, `DATE`, `TIME`, `APPOINTMENT_ID`).
+- Wrote FAQ: data saving, data transfer, risks of editing files.
+- Documented Known Issue: space omission in command parsing.
+- Wrote Command Summary table with formats & examples of usage.
+
+#### Contributions to the DG:
+- Documented `Parser` component design:
+ - Wrote explanation of parsing workflow.
+ - Created diagrams: `parserClassDiagram.png`, `parserSequence.png`.
+- Add & Delete Appointment Features:
+ - Documented implementation details & usage scenarios.
+ - Diagrams: `addAppointmentSequence.png`, `deleteAppointmentSequence.png`.
+ - Explained rationale & rejected alternatives.
+- Other sections: Table of Contents, Non-functional Requirements, Glossary.
+- Non-functional requirements
+- Glossary
+
+#### Contributions to team-based tasks:
+
+- Setting up the Github team repo
+- Maintaining the issue tracker e.g. issue and milestones
+- Release management e.g. wrapping up milestones, saving DG and UG as PDFs
+
+#### Review/mentoring contributions:
+
+- Helped teammates resolve Git merge conflicts and guided them on pull request practices.
+- Reminding teammates of important deadlines.
+- Helped to test out the newly-implemented features to ensure the feature works as desired.
+- Discussed with teammates on what to include for Design and Implementation section in Developer Guide.
+- Helped review the coding style consistency
+
+
+
+#### Contributions to the Developer Guide
+
+**Diagrams I contributed:**
+
+Parser Class Diagram:
+
+
+Parser Sequence Diagram:
+
+
+Add Appointment Sequence Diagram:
+
+
+Delete Appointment Sequence Diagram:
+
+
+
diff --git a/docs/team/dylancmznus.md b/docs/team/dylancmznus.md
new file mode 100644
index 0000000000..a1d783bff1
--- /dev/null
+++ b/docs/team/dylancmznus.md
@@ -0,0 +1,97 @@
+# Dylan's Project Portfolio Page
+
+## Project: ClinicEase
+
+**ClinicEase** is a CLI-based clinic management application that allows users to efficiently manage patient records, medical histories, and appointments. The system provides commands for viewing and updating patient details, managing appointments, and maintaining medical history records. This project aims to simplify clinic administrative tasks with a user-friendly interface.
+
+Given below are my contributions to the project.
+
+---
+
+### New Feature:
+**`view-patient`**:
+- Allows users to view a patient's personal details via their NRIC (e.g., `view-patient ic/S1234567A`).
+- Displays the patient's full name, contact details, and other personal information.
+- Ensures that the provided NRIC matches an existing patient before retrieving the data.
+
+### New Feature:
+
+**`find-appointment`**:
+- Finds and lists all appointments for a patient using their NRIC (e.g., `find-appointment ic/S1234567A`).
+- Retrieves a list of appointments with the specified patient.
+
+### New Feature:
+**`mark-appointment`**:
+- Allows users to mark an appointment as completed for a specific patient using their NRIC and the appointment ID (e.g., `mark-appointment ic/S1234567A id/001`).
+- Verifies that the patient exists and that the appointment ID corresponds to an existing appointment before updating the status.
+
+### New Feature:
+**`unmark-appointment`**:
+- Unmarks a completed appointment, changing its status as uncompleted (e.g., `unmark-appointment ic/S1234567A id/001`).
+
+---
+
+### Code Contributed:
+
+**Code Dashboard Link**: [Click here]()
+
+---
+
+### Enhancements Implemented:
+
+**Parser Integration**
+ - Implemented some parsing logic (`parseViewPatient`, `parseMarkAppointment`, `parseUnmarkAppointment`, `parseFindAppointment`) to handle new command formats.
+ - Ensured error messages provide clarity for invalid commands or incorrect command parameters (e.g., `InvalidInputFormatException`).
+
+**Persistence and Data Integrity**
+ - Enhanced the `ManagementSystem` to:
+ - Verify the existence of the patient and appointments before marking or unmarking.
+ - Ensure that changes to appointment statuses are reflected persistently in the system.
+
+**Exception Handling**
+ - Improved user feedback for invalid commands or missing parameters, particularly for appointment management.
+
+---
+
+### User Guide (UG)
+
+- **Sections**:
+ - [Viewing Patient Information: `view-patient`](#)
+ - [Marking Appointments: `mark-appointment`](#)
+ - [Unmarking Appointments: `unmark-appointment`](#)
+ - [Finding Appointments: `find-appointment`](#)
+
+ I authored the instructions, formats, and examples for these commands, providing clarification on valid NRIC formats and how to use appointment IDs for marking and unmarking.
+
+---
+
+### Developer Guide (DG)
+
+1. **Use Cases for Essential and Additional Features**
+ - Authored the use cases for essential commands like:
+ - `add-patient`
+ - `delete-patient`
+ - `add-appointment`
+ - `edit-patient`
+ - `sort-appointment`
+ - Provided detailed step-by-step scenarios for users to understand how these features should be used to interact with the system.
+
+2. **Implementation and UML Diagrams**
+ - Created **Sequence Diagrams** for the `view-patient` feature, demonstrating how the command interacts with the `Parser`, `ManagementSystem`, and `Storage` components.
+ - Updated UML diagrams to reflect the data flow and validation steps involved in retrieving patient information using NRIC.
+
+3. **Components and Class Diagrams**
+ - Created **Class Diagrams** for the Manager Component and Object Component.
+ - Provided details about these components in the Architecture Diagram,.
+
+---
+
+### Community Involvement
+
+- Conducted code reviews for pull requests affecting appointment management, particularly focusing on ensuring that appointments are validated correctly and updates are persisted in storage.
+- Assisted teammates in resolving command parsing issues and clarified how appointments are managed and retrieved in the system.
+- Ensured adherence to Java coding conventions across the codebase, especially in method naming and parameter validation.
+- Suggested improvements for better user experience, such as providing clearer feedback on appointment status updates.
+- Contributed ideas for expanding the appointment feature, such as introducing appointment reminders or notifications.
+
+---
diff --git a/docs/team/johndoe.md b/docs/team/johndoe.md
deleted file mode 100644
index ab75b391b8..0000000000
--- a/docs/team/johndoe.md
+++ /dev/null
@@ -1,6 +0,0 @@
-# John Doe - Project Portfolio Page
-
-## Overview
-
-
-### Summary of Contributions
diff --git a/docs/team/judhoka.md b/docs/team/judhoka.md
new file mode 100644
index 0000000000..c8d8b0999b
--- /dev/null
+++ b/docs/team/judhoka.md
@@ -0,0 +1,113 @@
+# Judha's Project Portfolio Page
+
+## Project: ClinicEase
+
+**ClinicEase** is a CLI-based clinic management system that allows users to manage patient records, appointments, and prescriptions efficiently. The application streamlines administrative workflows in clinics by offering reliable, user-friendly, and persistent command-line interactions.
+
+My main contribution in features was to design and implement patient related features (`add-patient`, `delete-patient`, etc...) to ensure that users can store patient data properly with their respective credentials. I also mainly contributed in creating the storage system for the entire system to ensure that data is properly kept and saved.
+
+---
+
+## Code Contributed
+
+**Code Dashboard Link**: [Click here to see my code contribution](https://nus-cs2113-ay2425s2.github.io/tp-dashboard/?search=judhoka&sort=groupTitle&sortWithin=title&timeframe=commit&mergegroup=&groupSelect=groupByRepos&breakdown=true&checkedFileTypes=docs~functional-code~test-code~other&since=2025-02-21)
+
+---
+
+## Features Implemented
+
+### [`add-patient`](../UserGuide.md/#adding-a-new-patient--add-patient)
+- Allows users to register a new patient by specifying fields such as name, NRIC, date of birth, gender, phone number, and address.
+- Includes validation to prevent duplicate NRIC entries, ensuring each patient is uniquely identified.
+- Example:
+ `add-patient n/John Doe ic/S1234567A dob/1990-01-01 g/M p/98765432 a/123 Main St`
+
+### [`delete-patient`](../UserGuide.md/#deleting-a-patient--delete-patient)
+- Enables the removal of a patient using their NRIC.
+- Validates whether the NRIC exists in the system before attempting deletion, and provides informative error messages if not found.
+- Upon successful deletion, confirms the action and removes any associated appointments and prescription references.
+
+### [`list-patient`](../UserGuide.md/#listing-all-patients-list-patient)
+- Displays all patients currently stored in the system in a numbered and neatly formatted list.
+- Includes name, NRIC, and other key attributes in a concise format.
+- Improves usability with consistent dividers and spacing for readability.
+- Helpful in providing an overview of all registered patients before performing operations like `delete-patient` or `view-patient`.
+
+### [`view-patient`](../UserGuide.md/#viewing-patient-details-view-patient)
+- Shows full details of a selected patient, including:
+ - Name, NRIC, date of birth, gender, phone number, and address.
+ - Optionally, linked appointments and prescriptions (if supported by system design).
+- Supports lookup by NRIC (e.g., `view-patient ic/S1234567A`), with input validation and out-of-bounds handling.
+- Designed to be clear and informative, acting as a one-stop overview of a patient's data.
+
+---
+
+## Parser Integration
+
+- Developed parser logic for all implemented commands and storage system.
+- Handled command recognition, parameter extraction, and error messaging.
+- Validated argument formats and threw custom exceptions like `InvalidInputFormatException`.
+
+---
+
+## Storage System
+
+- Designed and implemented the file-based persistent `Storage` class.
+- Saved and loaded:
+ - Patient data from `patient_data.txt`
+ - Appointment data from `appointment_data.txt`
+ - Prescription data from `prescription_data.txt`
+- Linked appointments to patients during data load.
+- Generated HTML versions of prescriptions for viewing and printing.
+- Ensured initialization safety via `UnloadedStorageException`.
+
+---
+
+## Exception Handling
+
+- Designed exception handling framework with custom messages.
+- Threw descriptive exceptions when:
+ - File paths were missing.
+ - Data parsing failed.
+ - Commands were malformed or incomplete.
+- Used try-catch in the main loop to ensure graceful error handling.
+
+---
+
+## Testing
+
+- Wrote JUnit test cases for parser logic, patient model, and storage.
+- Threw various types of exceptions (e.g, `UnloadedStorageException`) if data writing fails, allowing the system to safely abort the operation.
+- Manually tested combinations of valid and invalid inputs.
+
+---
+
+## User Guide (UG)
+
+- Contributed to documentation for all implemented commands.
+- Provided consistent format, expected outputs, and usage examples.
+- Documented edge cases and failure scenarios for better UX.
+
+---
+
+## Developer Guide (DG)
+
+- Authored complete component sections:
+ - Architecture
+ - `UI` component
+ - `Storage` component
+ - `Main` component
+- Explained design considerations, structure, and responsibilities.
+- Created and updated UML diagrams (Architecture, Class, and Sequence).
+- Maintained consistency in formatting, phrasing, and layout across the DG.
+
+---
+
+## Community Involvement
+
+- Reviewed teammate pull requests, particularly those related to parser, patient, appointment and storage system.
+- Proposed improvements for error messaging and user experience.
+- Ensured coding style consistency (naming, spacing, error format).
+- Participated in team sync-ups to align features, naming conventions, and architecture decisions.
+
+---
diff --git a/docs/team/jyukuan.md b/docs/team/jyukuan.md
new file mode 100644
index 0000000000..ef269d351d
--- /dev/null
+++ b/docs/team/jyukuan.md
@@ -0,0 +1,99 @@
+# Project Portfolio Page (PPP)
+
+## Overview
+
+**ClinicEase** is a CLI-based clinic management application that enables users to handle patient records, medical
+histories, and appointments quickly and effectively. It provides commands for adding, editing, and viewing patient
+details, as well as storing and updating their medical histories. This project streamlines a clinic’s administrative
+tasks in a single, user-friendly CLI system.
+
+I have been primarily involved in designing and implementing the **patient’s history** functionality to ensure users can
+store, view, and edit patients’ medical histories with robust validation and persistence.
+
+---
+
+## Summary of Contributions
+
+### 1. Code Contributed
+
+- **Code Dashboard Link
+ **: [Click here to see my code contribution]()
+
+### 2. Enhancements Implemented
+
+1. **Medical History Commands**
+ - **`store-history`**:
+ - Allows users to add new medical history entries to an existing patient’s record.
+ - Accepts multiple comma-separated entries for one command (e.g., `h/Diabetes, Hypertension`).
+ - Performs checks to ensure the patient exists, preventing invalid input from updating records.
+ - **`view-history`**:
+ - Supports viewing a patient’s medical history by either NRIC (e.g., `view-history ic/S1234567A`) or by name (
+ e.g., `view-history John Doe`).
+ - Displays all stored entries for the patient(s) found.
+ - **`edit-history`**:
+ - Enables replacing the first occurrence of a specified old history entry with a new one.
+ - Uses `equalsIgnoreCase()` matching, providing leniency in text formatting.
+
+2. **Parser Integration**
+ - Implemented specialized parsing logic (`parseStoreHistory`, `parseViewHistory`, `parseEditHistory`) to handle the
+ format for new commands.
+ - Ensured error messages (e.g., `InvalidInputFormatException`) provide clarity when commands are malformed.
+
+3. **Exception Handling**
+ - Enhanced user feedback for invalid commands or missing parameters.
+ - Threw `UnloadedStorageException` if data writing fails, allowing the system to safely abort the operation.
+
+4. **Java Doc**
+ - Provided code reviews on pull requests that impacted the data structures for storing patient details and medical
+ histories.
+ - Authored detailed JavaDoc for classes and methods dealing with patient history (`store-history`, `view-history`,
+ `edit-history` commands, and related `ManagementSystem` methods). This documentation highlights parameters, return
+ values, and exceptions, making the code easier to read and maintain.
+ - Helped maintain consistent Java coding conventions (e.g., method naming, usage of final variables) throughout the
+ codebase.
+
+5. **Review / Mentoring Contributions**
+
+ - Provided code reviews on pull requests that impacted the data structures storing patient details.
+ - Helped maintain consistent Java coding conventions (e.g., method naming, usage of final variables) throughout the
+ codebase.
+
+### 3. Contributions to the User Guide (UG)
+
+- **Sections**:
+ - [Adding Medical History: `store-history`](#)
+ - [Viewing Medical History: `view-history`](#)
+ - [Editing Medical History: `edit-history`](#)
+
+ I wrote the instructions, formats, and examples for these commands. I also included **tips** about commas for multiple
+ entries and clarifications on the usage of NRIC vs. name.
+
+### 4. Contributions to the Developer Guide (DG)
+
+1. **Testing Patient Management Features**
+ - Authored the guidelines and scenarios on how to manually test and validate patient-related operations.
+ - Added use cases and step-by-step instructions to ensure testers can verify correctness for storing, viewing, and
+ editing patient history.
+
+2. **Storing Medical History Feature**
+ - Wrote the detailed explanation of how `store-history`, `view-history`, and `edit-history` commands work
+ internally.
+ - Added or updated sequence diagrams in PlantUML to illustrate the flow of data and command execution for medical
+ history.
+
+3. **UML Diagrams**
+ - Created the **Sequence Diagrams** for the `store-history` feature, demonstrating how the command interacts with
+ `Parser`, `ManagementSystem`, and `Storage`.
+ - Ensured diagrams accurately reflect the final implementation (parameter extraction, validation steps, and
+ file-saving routines).
+ - Created the **Class Diagrams** for Command Component.
+ - Ensured diagrams accurately reflect the final implementation.
+
+### 5. Contributions to Team-Based Tasks
+
+- Participated in **team discussions** to decide on command naming patterns (`store-history` vs. `add-history`) and the approach to handle multiple comma-separated entries.
+- Ensured consistent **exception messages** across the project for invalid data entries.
+- Reviewed and tested merges from teammates, particularly those that affected `ManagementSystem` or `Parser`.
+
+---
+
diff --git a/src/main/java/ClinicEase.java b/src/main/java/ClinicEase.java
new file mode 100644
index 0000000000..c496629116
--- /dev/null
+++ b/src/main/java/ClinicEase.java
@@ -0,0 +1,93 @@
+import command.Command;
+import exception.AppointmentClashException;
+import exception.DuplicatePatientIDException;
+import exception.InvalidInputFormatException;
+import exception.PatientNotFoundException;
+import exception.UnknownCommandException;
+import exception.UnloadedStorageException;
+import manager.ManagementSystem;
+import manager.Patient;
+import manager.Appointment;
+import manager.Prescription;
+import miscellaneous.Parser;
+import miscellaneous.Ui;
+import storage.Storage;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Main class of the ClinicEase application, responsible for initializing
+ * components and driving the command execution loop.
+ * ClinicEase is a desktop application designed for clinic management,
+ * providing a command-line interface for managing patients, appointments,
+ * and prescriptions.
+ */
+public class ClinicEase {
+
+ private ManagementSystem manager;
+ private Ui ui;
+ private Storage storage;
+
+ /**
+ * Constructs a new ClinicEase application with a specified storage location.
+ * Initializes the UI, storage, and management system components.
+ * Attempts to load existing data from storage files if available.
+ *
+ * @param filePath The directory path where data files will be stored
+ */
+ public ClinicEase(String filePath) {
+ assert filePath != null : "File path cannot be null";
+ this.ui = new Ui();
+ this.storage = new Storage(filePath);
+
+ try {
+ List patients = Storage.loadPatients();
+ List prescriptions = Storage.loadPrescriptions();
+ this.manager = new ManagementSystem(patients, new ArrayList<>(), prescriptions);
+
+ List appointments = Storage.loadAppointments(manager);
+ manager.setAppointments(appointments);
+ } catch (UnloadedStorageException e) {
+ ui.showError("Could not load data: " + e.getMessage());
+ this.manager = new ManagementSystem(new ArrayList<>(), new ArrayList<>(), new ArrayList<>());
+ }
+ }
+
+ /**
+ * Starts the application's main execution loop.
+ * Displays welcome message, continuously reads user commands,
+ * executes them until an exit command is received.
+ * Handles exceptions by displaying appropriate error messages.
+ */
+ public void run() {
+ ui.showWelcome();
+ boolean running = true;
+
+ while (running) {
+ try {
+ String input = ui.readCommand();
+ if (input.isEmpty()) {
+ continue;
+ }
+ Command command = Parser.parse(input);
+ command.execute(manager, ui);
+ running = !command.isExit();
+ } catch (InvalidInputFormatException | UnknownCommandException | DuplicatePatientIDException |
+ UnloadedStorageException | PatientNotFoundException | AppointmentClashException e) {
+ ui.showError(e.getMessage());
+ }
+ }
+ }
+
+ /**
+ * The entry point of the application.
+ * Creates a new ClinicEase instance with storage in the "data" directory
+ * and starts the application.
+ *
+ * @param args Command line arguments (not used)
+ */
+ public static void main(String[] args) {
+ new ClinicEase("data").run();
+ }
+}
diff --git a/src/main/java/command/AddAppointmentCommand.java b/src/main/java/command/AddAppointmentCommand.java
new file mode 100644
index 0000000000..27153080f7
--- /dev/null
+++ b/src/main/java/command/AddAppointmentCommand.java
@@ -0,0 +1,51 @@
+package command;
+
+import exception.AppointmentClashException;
+import exception.PatientNotFoundException;
+import exception.UnloadedStorageException;
+import manager.Appointment;
+import manager.ManagementSystem;
+import miscellaneous.Ui;
+
+/**
+ * Represents a command to add a new appointment to the management system.
+ */
+public class AddAppointmentCommand extends Command {
+
+ protected Appointment appointment;
+
+ /**
+ * Constructs an AddAppointmentCommand with the specified appointment.
+ *
+ * @param appointment The appointment to be added to the system.
+ */
+ public AddAppointmentCommand(Appointment appointment) {
+ this.appointment = appointment;
+ }
+
+ /**
+ * Gets the appointment associated with this command.
+ *
+ * @return The appointment to be added.
+ */
+ public Appointment getAppointment() {
+ return appointment;
+ }
+
+ /**
+ * Executes the command to add the appointment to the appointment list in management system.
+ *
+ * @param manager The management system that stores the appointment.
+ * @param ui The user interface for displaying messages.
+ * @throws UnloadedStorageException If the storage component is not properly loaded.
+ * @throws PatientNotFoundException If the patient associated with the appointment is not found.
+ * @throws AppointmentClashException If the appointment time conflicts with an existing appointment.
+ */
+ @Override
+ public void execute(ManagementSystem manager, Ui ui) throws UnloadedStorageException, PatientNotFoundException,
+ AppointmentClashException {
+ manager.addAppointment(appointment);
+ ui.showAppointmentAdded(manager.getAppointments());
+ }
+
+}
diff --git a/src/main/java/command/AddPatientCommand.java b/src/main/java/command/AddPatientCommand.java
new file mode 100644
index 0000000000..2168effa2d
--- /dev/null
+++ b/src/main/java/command/AddPatientCommand.java
@@ -0,0 +1,40 @@
+package command;
+
+import exception.DuplicatePatientIDException;
+import exception.UnloadedStorageException;
+import manager.ManagementSystem;
+import manager.Patient;
+import miscellaneous.Ui;
+
+/**
+ * Represents a command to add a patient to the system.
+ */
+public class AddPatientCommand extends Command {
+
+ protected Patient patient;
+
+ /**
+ * Constructs an AddPatientCommand with the specified patient.
+ *
+ * @param patient The patient to be added.
+ */
+ public AddPatientCommand(Patient patient) {
+ this.patient = patient;
+ }
+
+ /**
+ * Executes the add patient command.
+ * Adds the patient to the management system and shows confirmation via UI.
+ *
+ * @param manager The management system to update.
+ * @param ui The user interface to interact with the user.
+ * @throws DuplicatePatientIDException If a patient with the same ID already exists.
+ * @throws UnloadedStorageException If the storage is not properly initialized.
+ */
+ @Override
+ public void execute(ManagementSystem manager, Ui ui)
+ throws DuplicatePatientIDException, UnloadedStorageException {
+ manager.addPatient(patient);
+ ui.showPatientAdded(manager.getPatients());
+ }
+}
diff --git a/src/main/java/command/AddPrescriptionCommand.java b/src/main/java/command/AddPrescriptionCommand.java
new file mode 100644
index 0000000000..4c1e0accaf
--- /dev/null
+++ b/src/main/java/command/AddPrescriptionCommand.java
@@ -0,0 +1,62 @@
+package command;
+
+import exception.UnloadedStorageException;
+import manager.ManagementSystem;
+import manager.Prescription;
+import miscellaneous.Ui;
+
+/**
+ * Command to add a new prescription to the system.
+ * Handles the creation of a new prescription and displays
+ * feedback about the operation to the user.
+ */
+//@@author Basudeb2005
+public class AddPrescriptionCommand extends Command {
+ private final Prescription prescription;
+
+ /**
+ * Constructs an AddPrescriptionCommand with the specified prescription.
+ *
+ * @param prescription The prescription to be added to the system
+ */
+ public AddPrescriptionCommand(Prescription prescription) {
+ this.prescription = prescription;
+ }
+
+ /**
+ * Executes the add prescription command.
+ * Adds the prescription to the management system and displays confirmation.
+ * Shows error message if the patient ID doesn't exist.
+ *
+ * @param manager The management system that handles the data
+ * @param ui The user interface to display results
+ * @throws UnloadedStorageException If there was an error saving to storage
+ */
+ @Override
+ public void execute(ManagementSystem manager, Ui ui) throws UnloadedStorageException {
+ try {
+ Prescription addedPrescription = manager.addPrescription(prescription);
+ ui.showLine();
+ System.out.println("Successfully added prescription:");
+ System.out.println(addedPrescription.toString());
+ System.out.println("");
+ System.out.println("Prescription has been generated.");
+ System.out.println("View the prescription for the patient with ID: " + addedPrescription.getPatientId());
+ System.out.println("and prescription ID: " + addedPrescription.getPrescriptionId());
+ ui.showLine();
+ } catch (IllegalArgumentException e) {
+ ui.showError("Failed to add prescription: " + e.getMessage());
+ }
+ }
+
+ /**
+ * Returns whether this command should exit the application.
+ *
+ * @return false (this command does not exit the application)
+ */
+ @Override
+ public boolean isExit() {
+ return false;
+ }
+}
+
diff --git a/src/main/java/command/Command.java b/src/main/java/command/Command.java
new file mode 100644
index 0000000000..f3f69db48f
--- /dev/null
+++ b/src/main/java/command/Command.java
@@ -0,0 +1,44 @@
+package command;
+
+import exception.PatientNotFoundException;
+import exception.AppointmentClashException;
+import exception.DuplicatePatientIDException;
+import exception.InvalidInputFormatException;
+import exception.UnloadedStorageException;
+import manager.ManagementSystem;
+import miscellaneous.Ui;
+
+/**
+ * Abstract class representing a command in the clinic management system.
+ * All commands must extend this class and implement the execute method.
+ * Follows the Command pattern to encapsulate requests as objects.
+ */
+public abstract class Command {
+
+ /**
+ * Executes the command with the given management system and UI.
+ * Each subclass must implement this method with its specific behavior.
+ *
+ * @param manager The management system that provides operations on data
+ * @param ui The user interface to display results
+ * @throws DuplicatePatientIDException If a patient with the same ID already exists
+ * @throws UnloadedStorageException If there was an error with storage operations
+ * @throws PatientNotFoundException If a requested patient was not found
+ * @throws AppointmentClashException If an appointment conflicts with existing ones
+ * @throws InvalidInputFormatException If the input format is invalid
+ */
+ public abstract void execute(ManagementSystem manager, Ui ui)
+ throws DuplicatePatientIDException, UnloadedStorageException, PatientNotFoundException,
+ AppointmentClashException, InvalidInputFormatException;
+
+ /**
+ * Returns whether this command should exit the application.
+ * Default implementation returns false.
+ * Can be overridden by commands that should exit the application.
+ *
+ * @return true if the command should cause the application to exit, false otherwise
+ */
+ public boolean isExit() {
+ return false;
+ }
+}
diff --git a/src/main/java/command/DeleteAppointmentCommand.java b/src/main/java/command/DeleteAppointmentCommand.java
new file mode 100644
index 0000000000..a81525ac22
--- /dev/null
+++ b/src/main/java/command/DeleteAppointmentCommand.java
@@ -0,0 +1,45 @@
+package command;
+
+import exception.UnloadedStorageException;
+import manager.Appointment;
+import manager.ManagementSystem;
+import miscellaneous.Ui;
+
+/**
+ * Represents a command to delete an existing appointment from the management system.
+ */
+public class DeleteAppointmentCommand extends Command {
+ protected String apptId;
+
+ /**
+ * Constructs a DeleteAppointmentCommand with the specified appointment ID.
+ *
+ * @param apptId The unique identifier of the appointment to be deleted.
+ */
+ public DeleteAppointmentCommand(String apptId) {
+ this.apptId = apptId;
+ }
+
+ /**
+ * Gets the appointment ID associated with this command.
+ *
+ * @return The ID of the appointment to be deleted.
+ */
+ public String getApptId() {
+ return apptId;
+ }
+
+
+ /**
+ * Executes the command to delete the appointment from the management system.
+ *
+ * @param manager The management system that contains the appointment.
+ * @param ui The user interface for displaying messages.
+ * @throws UnloadedStorageException If the storage component is not properly loaded.
+ */
+ @Override
+ public void execute(ManagementSystem manager, Ui ui) throws UnloadedStorageException {
+ Appointment removedAppointment = manager.deleteAppointment(apptId);
+ ui.showAppointmentDeleted(manager.getAppointments(), removedAppointment, apptId);
+ }
+}
diff --git a/src/main/java/command/DeletePatientCommand.java b/src/main/java/command/DeletePatientCommand.java
new file mode 100644
index 0000000000..7283e8c565
--- /dev/null
+++ b/src/main/java/command/DeletePatientCommand.java
@@ -0,0 +1,36 @@
+package command;
+
+import exception.UnloadedStorageException;
+import manager.ManagementSystem;
+import manager.Patient;
+import miscellaneous.Ui;
+
+/**
+ * Represents a command to delete a patient from the system.
+ */
+public class DeletePatientCommand extends Command {
+ protected String nric;
+
+ /**
+ * Constructs a DeletePatientCommand with the given NRIC.
+ *
+ * @param nric The NRIC of the patient to delete.
+ */
+ public DeletePatientCommand(String nric) {
+ this.nric = nric;
+ }
+
+ /**
+ * Executes the delete patient command.
+ * Removes the patient with the specified NRIC from the system and shows confirmation via UI.
+ *
+ * @param manager The management system to update.
+ * @param ui The user interface to interact with the user.
+ * @throws UnloadedStorageException If storage is not properly initialized.
+ */
+ @Override
+ public void execute(ManagementSystem manager, Ui ui) throws UnloadedStorageException {
+ Patient removedPatient = manager.deletePatient(nric);
+ ui.showPatientDeleted(removedPatient, nric);
+ }
+}
diff --git a/src/main/java/command/EditPatientCommand.java b/src/main/java/command/EditPatientCommand.java
new file mode 100644
index 0000000000..6554cc33fc
--- /dev/null
+++ b/src/main/java/command/EditPatientCommand.java
@@ -0,0 +1,58 @@
+package command;
+
+import exception.InvalidInputFormatException;
+import exception.PatientNotFoundException;
+import exception.UnloadedStorageException;
+import manager.ManagementSystem;
+import miscellaneous.Ui;
+
+import java.time.LocalDate;
+import java.time.format.DateTimeFormatter;
+import java.time.format.DateTimeParseException;
+
+public class EditPatientCommand extends Command {
+
+ // details: [0]=nric, [1]=name, [2]=dob, [3]=gender, [4]=address, [5]=phone
+ private final String[] details;
+
+ public EditPatientCommand(String[] details) {
+ this.details = details;
+ }
+
+ /**
+ * Executes the edit-patient command by validating the new date of birth (if present),
+ * and then delegating to {@code manager.editPatient(...)} with the appropriate parameters.
+ *
+ * @param manager The ManagementSystem that manages patient data.
+ * @param ui The UI used to show error or success messages.
+ * @throws UnloadedStorageException If editing the patient data fails when saving to storage.
+ * @throws PatientNotFoundException If no patient with the specified NRIC is found.
+ * @throws InvalidInputFormatException If the provided date is invalid or if newDob is after the current date.
+ */
+ @Override
+ public void execute(ManagementSystem manager, Ui ui) throws UnloadedStorageException,
+ PatientNotFoundException, InvalidInputFormatException {
+ String nric = details[0];
+ String name = details[1];
+ String dob = details[2];
+ String gender = details[3];
+ String addr = details[4];
+ String phone = details[5];
+
+ // If dob is specified, we parse it here to confirm validity before calling editPatient
+ if (dob != null && !dob.isBlank()) {
+ DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
+ try {
+ LocalDate.parse(dob, formatter);
+ } catch (DateTimeParseException e) {
+ ui.showError("Invalid date format for Date of Birth! Please use yyyy-MM-dd (e.g., 1990-05-12).");
+ return;
+ }
+ }
+
+ manager.editPatient(nric, name, dob, gender, addr, phone);
+ Ui.showLine();
+ System.out.println("Edit-patient command executed.");
+ Ui.showLine();
+ }
+}
diff --git a/src/main/java/command/EditPatientHistoryCommand.java b/src/main/java/command/EditPatientHistoryCommand.java
new file mode 100644
index 0000000000..e8155fefcc
--- /dev/null
+++ b/src/main/java/command/EditPatientHistoryCommand.java
@@ -0,0 +1,48 @@
+package command;
+
+import exception.UnloadedStorageException;
+import manager.ManagementSystem;
+import miscellaneous.Ui;
+
+/**
+ * Represents a command to edit existing medical history entries for a patient.
+ */
+public class EditPatientHistoryCommand extends Command {
+
+ /**
+ * String array containing:
+ * [0] = Patient NRIC
+ * [1] = Old history text to be replaced
+ * [2] = New history text to replace with
+ */
+ private final String[] details;
+
+ /**
+ * Constructs an EditPatientHistoryCommand with the specified details.
+ *
+ * @param details Contains patient NRIC, old history entry, and new history entry.
+ */
+ public EditPatientHistoryCommand(String[] details) {
+ this.details = details;
+ }
+
+ /**
+ * Executes the command to edit the medical history of a specified patient.
+ *
+ * @param manager The ManagementSystem managing patient data and operations.
+ * @param ui The Ui used to display output to the user.
+ * @throws UnloadedStorageException if saving changes to storage fails.
+ */
+ @Override
+ public void execute(ManagementSystem manager, Ui ui) throws UnloadedStorageException {
+ String nric = details[0];
+ String oldHistory = details[1];
+ String newHistory = details[2];
+
+ manager.editPatientHistory(nric, oldHistory, newHistory);
+
+ Ui.showLine();
+ System.out.println("Edit-history command executed.");
+ Ui.showLine();
+ }
+}
diff --git a/src/main/java/command/ExitCommand.java b/src/main/java/command/ExitCommand.java
new file mode 100644
index 0000000000..1bc842b02b
--- /dev/null
+++ b/src/main/java/command/ExitCommand.java
@@ -0,0 +1,32 @@
+package command;
+
+import manager.ManagementSystem;
+import miscellaneous.Ui;
+
+/**
+ * Represents a command to exit the application.
+ * This command terminates the program after displaying a goodbye message.
+ */
+public class ExitCommand extends Command {
+
+ /**
+ * Executes the exit command by displaying the goodbye message.
+ *
+ * @param manager The management system (unused in this command).
+ * @param ui The user interface used to display the goodbye message.
+ */
+ @Override
+ public void execute(ManagementSystem manager, Ui ui) {
+ ui.showBye();
+ }
+
+ /**
+ * Indicates that this command should terminate the application.
+ *
+ * @return Returns true to exit the application.
+ */
+ @Override
+ public boolean isExit() {
+ return true;
+ }
+}
diff --git a/src/main/java/command/FindAppointmentCommand.java b/src/main/java/command/FindAppointmentCommand.java
new file mode 100644
index 0000000000..681bca638e
--- /dev/null
+++ b/src/main/java/command/FindAppointmentCommand.java
@@ -0,0 +1,43 @@
+package command;
+
+import java.util.List;
+
+import manager.Appointment;
+import manager.ManagementSystem;
+import miscellaneous.Ui;
+
+/**
+ * Command to find appointments for a patient by their NRIC.
+ * Interacts with the {@link ManagementSystem} to retrieve
+ * all appointments associated with a specific NRIC and displays them through the {@link Ui}.
+ *
+ * This command follows the Command pattern, which encapsulates the appointment search
+ * functionality to allow for consistent execution without directly manipulating the system's components.
+ *
+ */
+public class FindAppointmentCommand extends Command {
+ protected String nric;
+
+ /**
+ * Constructs FindAppointmentCommand with the specified NRIC.
+ *
+ * @param nric the NRIC of the patient whose appointments are to be found
+ */
+ public FindAppointmentCommand(String nric) {
+ this.nric = nric;
+ }
+
+ /**
+ * Executes the command to find appointments for a patient with the given NRIC.
+ * It retrieves the list of appointments from ManagementSystem
+ * and displays the results using Ui.
+ *
+ * @param manager ManagementSystem responsible for handling appointment data
+ * @param ui Ui responsible for displaying the list of appointments
+ */
+ @Override
+ public void execute(ManagementSystem manager, Ui ui) {
+ List foundAppointments = manager.findAppointmentsByNric(nric);
+ ui.showAppointmentsFound(foundAppointments, nric);
+ }
+}
diff --git a/src/main/java/command/HelpCommand.java b/src/main/java/command/HelpCommand.java
new file mode 100644
index 0000000000..55fe86576e
--- /dev/null
+++ b/src/main/java/command/HelpCommand.java
@@ -0,0 +1,20 @@
+package command;
+
+import manager.ManagementSystem;
+import miscellaneous.Ui;
+
+/**
+ * Represents a command to display all available commands and their usage formats.
+ */
+public class HelpCommand extends Command {
+ /**
+ * Executes the help command by displaying the help message.
+ *
+ * @param manager The management system (unused in this command).
+ * @param ui The user interface used to display all available commands of the application.
+ */
+ @Override
+ public void execute(ManagementSystem manager, Ui ui) {
+ ui.showHelp();
+ }
+}
diff --git a/src/main/java/command/ListAppointmentCommand.java b/src/main/java/command/ListAppointmentCommand.java
new file mode 100644
index 0000000000..acffb8f40d
--- /dev/null
+++ b/src/main/java/command/ListAppointmentCommand.java
@@ -0,0 +1,21 @@
+package command;
+
+import manager.ManagementSystem;
+import miscellaneous.Ui;
+
+/**
+ * Represents a command to list all appointments in the system.
+ * This command displays all current appointments in the appointment list of the management system.
+ */
+public class ListAppointmentCommand extends Command {
+ /**
+ * Executes the list appointments command by displaying all appointments.
+ *
+ * @param manager The management system containing the appointment list.
+ * @param ui The user interface for displaying the appointment list.
+ */
+ @Override
+ public void execute(ManagementSystem manager, Ui ui) {
+ ui.showAppointmentList(manager.getAppointments());
+ }
+}
diff --git a/src/main/java/command/ListPatientCommand.java b/src/main/java/command/ListPatientCommand.java
new file mode 100644
index 0000000000..794d64dd33
--- /dev/null
+++ b/src/main/java/command/ListPatientCommand.java
@@ -0,0 +1,22 @@
+package command;
+
+import manager.ManagementSystem;
+import miscellaneous.Ui;
+
+/**
+ * Represents a command to list all patients in the system.
+ */
+public class ListPatientCommand extends Command {
+
+ /**
+ * Executes the list patient command.
+ * Displays all patients stored in the management system using the UI.
+ *
+ * @param manager The management system containing the patients.
+ * @param ui The user interface to interact with the user.
+ */
+ @Override
+ public void execute(ManagementSystem manager, Ui ui) {
+ ui.showPatientList(manager.getPatients());
+ }
+}
diff --git a/src/main/java/command/MarkApppointmentCommand.java b/src/main/java/command/MarkApppointmentCommand.java
new file mode 100644
index 0000000000..b3b9a6b0de
--- /dev/null
+++ b/src/main/java/command/MarkApppointmentCommand.java
@@ -0,0 +1,42 @@
+package command;
+
+import exception.UnloadedStorageException;
+import manager.Appointment;
+import manager.ManagementSystem;
+import miscellaneous.Ui;
+
+/**
+ * Represents a command to mark an appointment as done using its unique appointment ID.
+ * This command interacts with the ManagementSystem to update the appointment status
+ * and utilizes the Ui to provide feedback to the user.
+ *
+ * This class is part of the Command pattern implementation in the system,
+ * using the mark operation for appointments in a reusable and modular way.
+ */
+public class MarkApppointmentCommand extends Command {
+ protected String apptId;
+
+ /**
+ * Constructs a MarkApppointmentCommand with the specified appointment ID.
+ *
+ * @param apptId the ID of the appointment to be marked as completed
+ */
+ public MarkApppointmentCommand(String apptId) {
+ this.apptId = apptId;
+ }
+
+ /**
+ * Executes the command to mark the appointment with the given ID as completed.
+ * It updates the appointment's status through the ManagementSystem and
+ * displays the updated appointment list and confirmation via the Ui.
+ *
+ * @param manager the ManagementSystem responsible for managing appointments
+ * @param ui the Ui responsible for displaying results to the user
+ * @throws UnloadedStorageException if the storage system was not initialized when the command was executed
+ */
+ @Override
+ public void execute(ManagementSystem manager, Ui ui) throws UnloadedStorageException {
+ Appointment appointment = manager.markAppointment(apptId);
+ ui.showAppointmentMarked(manager.getAppointments(), appointment, apptId);
+ }
+}
diff --git a/src/main/java/command/SortAppointmentCommand.java b/src/main/java/command/SortAppointmentCommand.java
new file mode 100644
index 0000000000..35326cca96
--- /dev/null
+++ b/src/main/java/command/SortAppointmentCommand.java
@@ -0,0 +1,45 @@
+package command;
+
+import exception.DuplicatePatientIDException;
+import exception.UnloadedStorageException;
+import manager.Appointment;
+import manager.ManagementSystem;
+import miscellaneous.Ui;
+
+import java.util.List;
+
+/**
+ * Represents a command to sort appointments in the management system.
+ */
+public class SortAppointmentCommand extends Command {
+ protected String type;
+
+ /**
+ * Constructs a SortAppointmentCommand with the specified sorting type.
+ *
+ * @param type The type of sorting to perform ("date" or other supported types).
+ */
+ public SortAppointmentCommand(String type) {
+ this.type = type;
+ }
+
+ /**
+ * Executes the command to sort appointments in the management system.
+ *
+ * @param manager The management system containing the appointments.
+ * @param ui The user interface for displaying the sorted appointments.
+ * @throws DuplicatePatientIDException If duplicate patient IDs are encountered.
+ * @throws UnloadedStorageException If the storage component is not properly loaded.
+ */
+ @Override
+ public void execute(ManagementSystem manager, Ui ui) throws DuplicatePatientIDException,
+ UnloadedStorageException {
+ if (type.equals("date")) {
+ List sortedApptByDateTime = manager.sortAppointmentsByDateTime(manager.getAppointments());
+ ui.showAppointmentList(sortedApptByDateTime);
+ } else {
+ List sortedApptById = manager.sortAppointmentsById(manager.getAppointments());
+ ui.showAppointmentList(sortedApptById);
+ }
+ }
+}
diff --git a/src/main/java/command/StoreMedHistoryCommand.java b/src/main/java/command/StoreMedHistoryCommand.java
new file mode 100644
index 0000000000..84060f4e59
--- /dev/null
+++ b/src/main/java/command/StoreMedHistoryCommand.java
@@ -0,0 +1,47 @@
+package command;
+
+import exception.PatientNotFoundException;
+import exception.UnloadedStorageException;
+import manager.ManagementSystem;
+import miscellaneous.Ui;
+
+
+/**
+ * Represents a command to store medical history for a specified patient.
+ */
+//@@author jyukuan
+public class StoreMedHistoryCommand extends Command {
+ /**
+ * Patient's NRIC to which the medical history belongs.
+ */
+ private String nric;
+ /**
+ * The medical history (or histories) to store, typically in comma-separated format.
+ */
+ private String medHistory;
+
+ /**
+ * Constructs a StoreMedHistoryCommand with the necessary details.
+ * The first element in the array is the patient's NRIC, the second is the medical history text.
+ *
+ * @param details String array containing [0] = NRIC, [1] = Medical history text.
+ */
+ public StoreMedHistoryCommand(String[] details) {
+ this.nric = details[0];
+ this.medHistory = details[1];
+ }
+
+
+ /**
+ * Executes the command to store the given medical history for the specified patient.
+ *
+ * @param manager The ManagementSystem that manages patient and appointment data.
+ * @param ui The Ui used to display success or error messages.
+ * @throws UnloadedStorageException if saving to storage fails due to uninitialized storage.
+ * @throws PatientNotFoundException if the patient with the given NRIC is not found.
+ */
+ @Override
+ public void execute(ManagementSystem manager, Ui ui) throws UnloadedStorageException, PatientNotFoundException {
+ manager.storeMedicalHistory(nric, medHistory);
+ }
+}
diff --git a/src/main/java/command/UnmarkAppointmentCommand.java b/src/main/java/command/UnmarkAppointmentCommand.java
new file mode 100644
index 0000000000..669513e5a5
--- /dev/null
+++ b/src/main/java/command/UnmarkAppointmentCommand.java
@@ -0,0 +1,42 @@
+package command;
+
+import exception.UnloadedStorageException;
+import manager.Appointment;
+import manager.ManagementSystem;
+import miscellaneous.Ui;
+
+/**
+ * Represents a command to unmark an appointment, indicating it is no longer completed.
+ * This command interacts with the ManagementSystem to revert the appointment status
+ * and utilizes the Ui to provide feedback to the user.
+ *
+ * It is part of the Command pattern implementation, encapsulating the logic
+ * for unmarking appointments in a modular and reusable way.
+ */
+public class UnmarkAppointmentCommand extends Command {
+ protected String apptId;
+
+ /**
+ * Constructs an UnmarkAppointmentCommand with the specified appointment ID.
+ *
+ * @param apptId the ID of the appointment to be unmarked
+ */
+ public UnmarkAppointmentCommand(String apptId) {
+ this.apptId = apptId;
+ }
+
+ /**
+ * Executes command to unmark the appointment with the given ID.
+ * It updates appointment's status through the ManagementSystem and
+ * displays the updated list and confirmation via the Ui.
+ *
+ * @param manager the ManagementSystem responsible for managing appointments
+ * @param ui the Ui responsible for displaying results to the user
+ * @throws UnloadedStorageException if the storage system was not initialized when the command was executed
+ */
+ @Override
+ public void execute(ManagementSystem manager, Ui ui) throws UnloadedStorageException {
+ Appointment appointment = manager.unmarkAppointment(apptId);
+ ui.showAppointmentUnmarked(manager.getAppointments(), appointment, apptId);
+ }
+}
diff --git a/src/main/java/command/ViewAllPrescriptionsCommand.java b/src/main/java/command/ViewAllPrescriptionsCommand.java
new file mode 100644
index 0000000000..d4322b8614
--- /dev/null
+++ b/src/main/java/command/ViewAllPrescriptionsCommand.java
@@ -0,0 +1,89 @@
+package command;
+
+import exception.UnloadedStorageException;
+import manager.ManagementSystem;
+import manager.Patient;
+import manager.Prescription;
+import miscellaneous.Ui;
+
+import java.util.List;
+
+/**
+ * Command to view all prescriptions for a specific patient.
+ * Lists all prescriptions with their basic details for the given patient ID.
+ */
+//@@author Basudeb2005
+public class ViewAllPrescriptionsCommand extends Command {
+ private final String patientId;
+
+ /**
+ * Constructs a ViewAllPrescriptionsCommand with the specified patient ID.
+ *
+ * @param patientId The ID of the patient whose prescriptions will be displayed
+ */
+ public ViewAllPrescriptionsCommand(String patientId) {
+ this.patientId = patientId;
+ }
+
+ /**
+ * Executes the view all prescriptions command.
+ * Retrieves and displays all prescriptions associated with the specified patient.
+ * Shows an appropriate message if no prescriptions exist or if the patient is not found.
+ *
+ * @param manager The management system that handles the data
+ * @param ui The user interface to display results
+ * @throws UnloadedStorageException If there was an error with storage operations
+ */
+ @Override
+ public void execute(ManagementSystem manager, Ui ui) throws UnloadedStorageException {
+ Patient patient = manager.viewPatient(patientId);
+ if (patient == null) {
+ ui.showError("Patient with ID " + patientId + " not found.");
+ return;
+ }
+
+ List prescriptions = manager.getPrescriptionsForPatient(patientId);
+
+ ui.showLine();
+ if (prescriptions.isEmpty()) {
+ System.out.println("No prescriptions found for patient " + patient.getName() + " (" + patientId + ").");
+ } else {
+ System.out.println("Prescriptions for patient " + patient.getName() + " (" + patientId + "):");
+ System.out.println("");
+
+ for (Prescription prescription : prescriptions) {
+ System.out.println("Prescription ID: " + prescription.getPrescriptionId());
+ System.out.println("Date: " + prescription.getTimestamp().format(
+ java.time.format.DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm")));
+
+ System.out.println("Symptoms:");
+ for (String symptom : prescription.getSymptoms()) {
+ System.out.println("- " + symptom);
+ }
+
+ System.out.println("Medicines:");
+ for (String medicine : prescription.getMedicines()) {
+ System.out.println("- " + medicine);
+ }
+
+ System.out.println("Notes: " + prescription.getNotes());
+ System.out.println("");
+ }
+
+ System.out.println("Total prescriptions: " + prescriptions.size());
+ System.out.println("Use 'view-prescription PRESCRIPTION_ID' to view details and generate HTML.");
+ }
+ ui.showLine();
+ }
+
+ /**
+ * Returns whether this command should exit the application.
+ *
+ * @return false (this command does not exit the application)
+ */
+ @Override
+ public boolean isExit() {
+ return false;
+ }
+}
+
diff --git a/src/main/java/command/ViewMedHistoryCommand.java b/src/main/java/command/ViewMedHistoryCommand.java
new file mode 100644
index 0000000000..8739915b79
--- /dev/null
+++ b/src/main/java/command/ViewMedHistoryCommand.java
@@ -0,0 +1,43 @@
+package command;
+
+import exception.PatientNotFoundException;
+import manager.ManagementSystem;
+import miscellaneous.Ui;
+
+
+/**
+ * Represents a command to view medical history for a patient,
+ * either by NRIC or by name.
+ */
+public class ViewMedHistoryCommand extends Command {
+ protected String type;
+ protected String nameOrIc;
+
+ /**
+ * Constructs a ViewMedHistoryCommand with the necessary details.
+ * details[0] = "ic" or "n" (search type), details[1] = the actual NRIC or name.
+ *
+ * @param details String array indicating search type and the patient's NRIC or name.
+ */
+ public ViewMedHistoryCommand(String[] details) {
+ this.type = details[0];
+ this.nameOrIc = details[1];
+ }
+
+ /**
+ * Executes the command to view a patient's medical history.
+ * If type == "ic", it searches by NRIC; otherwise, it searches by name.
+ *
+ * @param manager The ManagementSystem that manages patient data.
+ * @param ui The Ui used to display output to the user.
+ * @throws PatientNotFoundException if no matching patient is found when searching by NRIC.
+ */
+ @Override
+ public void execute(ManagementSystem manager, Ui ui) throws PatientNotFoundException {
+ if (type.equals("ic")) {
+ manager.viewMedicalHistoryByNric(nameOrIc);
+ } else {
+ manager.viewMedicalHistoryByName(nameOrIc);
+ }
+ }
+}
diff --git a/src/main/java/command/ViewPatientCommand.java b/src/main/java/command/ViewPatientCommand.java
new file mode 100644
index 0000000000..b203e996e8
--- /dev/null
+++ b/src/main/java/command/ViewPatientCommand.java
@@ -0,0 +1,51 @@
+package command;
+
+import manager.ManagementSystem;
+import manager.Patient;
+import miscellaneous.Ui;
+
+/**
+ * Command to view a patient in the system by their NRIC.
+ * This command interacts with the {@link ManagementSystem} to retrieve
+ * a patient and displays their details through the {@link Ui}.
+ *
+ * This command is part of the Command pattern used to encapsulate
+ * the viewing functionality of a patient, allowing easy execution
+ * without directly manipulating system objects.
+ *
+ *
+ * @author dylancmznus
+ */
+public class ViewPatientCommand extends Command {
+ protected String nric;
+
+ /**
+ * Constructs ViewPatientCommand with the specified NRIC.
+ *
+ * @param nric the NRIC of the patient to be viewed
+ */
+ public ViewPatientCommand(String nric) {
+ this.nric = nric;
+ }
+
+ /**
+ * Executes the command to view a patient with the given NRIC.
+ * Retrieves the patient from ManagementSystem and
+ * displays the details using Ui.
+ *
+ * @param manager the {@link ManagementSystem} responsible for handling patient data
+ * @param ui the {@link Ui} responsible for displaying the patient information
+ * @throws AssertionError if the manager or ui instances are null
+ * @throws AssertionError if no patient is found for the given NRIC
+ */
+ @Override
+ public void execute(ManagementSystem manager, Ui ui) {
+ assert manager != null : "ManagementSystem instance can't be empty";
+ assert ui != null : "Ui instance can't be empty";
+
+ Patient matchedPatient = manager.viewPatient(nric);
+ assert matchedPatient != null : "No patient found for NRIC: " + nric;
+
+ ui.showPatientViewed(matchedPatient, nric);
+ }
+}
diff --git a/src/main/java/command/ViewPrescriptionCommand.java b/src/main/java/command/ViewPrescriptionCommand.java
new file mode 100644
index 0000000000..2e790f8a37
--- /dev/null
+++ b/src/main/java/command/ViewPrescriptionCommand.java
@@ -0,0 +1,79 @@
+package command;
+
+import exception.UnloadedStorageException;
+import manager.ManagementSystem;
+import manager.Patient;
+import manager.Prescription;
+import miscellaneous.Ui;
+import storage.Storage;
+
+import java.io.File;
+
+/**
+ * Command to view a specific prescription and generate its HTML document.
+ * Displays detailed prescription information and creates a printable
+ * HTML version of the prescription.
+ */
+//@@author Basudeb2005
+public class ViewPrescriptionCommand extends Command {
+ private final String prescriptionId;
+
+ /**
+ * Constructs a ViewPrescriptionCommand with the specified prescription ID.
+ *
+ * @param prescriptionId The ID of the prescription to view
+ */
+ public ViewPrescriptionCommand(String prescriptionId) {
+ this.prescriptionId = prescriptionId;
+ }
+
+ /**
+ * Executes the view prescription command.
+ * Retrieves the prescription with the specified ID and displays its details.
+ * Also generates an HTML file for printing the prescription.
+ *
+ * @param manager The management system that handles the data
+ * @param ui The user interface to display results
+ * @throws UnloadedStorageException If there was an error with storage operations
+ */
+ @Override
+ public void execute(ManagementSystem manager, Ui ui) throws UnloadedStorageException {
+ Prescription prescription = manager.getPrescriptionById(prescriptionId);
+ if (prescription == null) {
+ ui.showError("Prescription with ID " + prescriptionId + " not found.");
+ return;
+ }
+
+ Patient patient = manager.viewPatient(prescription.getPatientId());
+
+ ui.showLine();
+ System.out.println("Prescription details:");
+ System.out.println(prescription.toString());
+ System.out.println("");
+
+ // Generate HTML file
+ Storage.savePrescriptionHtml(prescription, patient);
+
+ String fileName = "prescription_" + prescription.getPatientId() + "_"
+ + prescription.getPrescriptionId().split("-")[1] + ".html";
+ String filePath = new File("").getAbsolutePath()
+ + File.separator + "data"
+ + File.separator + "prescriptions"
+ + File.separator + fileName;
+
+ System.out.println("Prescription HTML file generated at: " + filePath);
+ System.out.println("Open this file in a web browser to view and print the prescription.");
+ ui.showLine();
+ }
+
+ /**
+ * Returns whether this command should exit the application.
+ *
+ * @return false (this command does not exit the application)
+ */
+ @Override
+ public boolean isExit() {
+ return false;
+ }
+}
+
diff --git a/src/main/java/exception/AppointmentClashException.java b/src/main/java/exception/AppointmentClashException.java
new file mode 100644
index 0000000000..01a0c4ef39
--- /dev/null
+++ b/src/main/java/exception/AppointmentClashException.java
@@ -0,0 +1,18 @@
+package exception;
+
+/**
+ * Represents an exception specific to appointment clash.
+ * This exception is thrown when attempting to schedule an appointment that conflicts with
+ * an existing appointment in the system.
+ */
+public class AppointmentClashException extends Exception {
+
+ /**
+ * Constructs an AppointmentClashException with the specified detail message.
+ *
+ * @param message The detail message explaining the appointment conflict
+ */
+ public AppointmentClashException(String message) {
+ super(message);
+ }
+}
diff --git a/src/main/java/exception/DuplicatePatientIDException.java b/src/main/java/exception/DuplicatePatientIDException.java
new file mode 100644
index 0000000000..4c77b3e51f
--- /dev/null
+++ b/src/main/java/exception/DuplicatePatientIDException.java
@@ -0,0 +1,18 @@
+package exception;
+
+/**
+ * Represents an exception specific to duplicate patient IDs.
+ * This exception is thrown when attempting to add a patient with an ID that already
+ * exists in the system.
+ */
+public class DuplicatePatientIDException extends Exception {
+
+ /**
+ * Constructs a DuplicatePatientIDException with the specified detail message.
+ *
+ * @param message The detail message explaining the duplicate ID issue
+ */
+ public DuplicatePatientIDException(String message) {
+ super(message);
+ }
+}
diff --git a/src/main/java/exception/InvalidInputFormatException.java b/src/main/java/exception/InvalidInputFormatException.java
new file mode 100644
index 0000000000..e80dd8ab57
--- /dev/null
+++ b/src/main/java/exception/InvalidInputFormatException.java
@@ -0,0 +1,18 @@
+package exception;
+
+/**
+ * Represents an exception specific to the invalid user input format.
+ * This exception is thrown when the user input does not match the expected format
+ * for a command or parameter.
+ */
+public class InvalidInputFormatException extends Exception {
+
+ /**
+ * Constructs an InvalidInputFormatException with the specified detail message.
+ *
+ * @param message The detail message explaining the correct input format
+ */
+ public InvalidInputFormatException(String message) {
+ super(message);
+ }
+}
diff --git a/src/main/java/exception/PatientNotFoundException.java b/src/main/java/exception/PatientNotFoundException.java
new file mode 100644
index 0000000000..90244c800d
--- /dev/null
+++ b/src/main/java/exception/PatientNotFoundException.java
@@ -0,0 +1,16 @@
+package exception;
+
+/**
+ * Exception thrown when a patient with the specified identifier is not found in the system.
+ */
+public class PatientNotFoundException extends Exception {
+
+ /**
+ * Constructs a new PatientNotFoundException with the specified detail message.
+ *
+ * @param message The detail message explaining the reason for the exception.
+ */
+ public PatientNotFoundException(String message) {
+ super(message);
+ }
+}
diff --git a/src/main/java/exception/UnknownCommandException.java b/src/main/java/exception/UnknownCommandException.java
new file mode 100644
index 0000000000..b03f5c4ba9
--- /dev/null
+++ b/src/main/java/exception/UnknownCommandException.java
@@ -0,0 +1,19 @@
+package exception;
+
+/**
+ * Represents an exception specific to the unknown user command.
+ * This exception is thrown when the user enters a command that is not recognized
+ * by the application.
+ */
+public class UnknownCommandException extends Exception {
+
+ /**
+ * Constructs an UnknownCommandException with the specified message.
+ *
+ * @param message The message indicating the command is invalid/unknown.
+ */
+ public UnknownCommandException(String message) {
+ super(message);
+ }
+
+}
diff --git a/src/main/java/exception/UnloadedStorageException.java b/src/main/java/exception/UnloadedStorageException.java
new file mode 100644
index 0000000000..5cf0875aba
--- /dev/null
+++ b/src/main/java/exception/UnloadedStorageException.java
@@ -0,0 +1,19 @@
+package exception;
+
+/**
+ * Represents an exception specific to storage access failure.
+ * This exception is thrown when the system fails to load or save data to/from storage,
+ * typically due to file system issues or corrupt data.
+ */
+public class UnloadedStorageException extends Exception {
+
+ /**
+ * Constructs an UnloadedStorageException with the specified detail message.
+ *
+ * @param message The detail message explaining the storage failure
+ */
+ public UnloadedStorageException(String message) {
+ super(message);
+ }
+
+}
diff --git a/src/main/java/manager/Appointment.java b/src/main/java/manager/Appointment.java
new file mode 100644
index 0000000000..31cea2865d
--- /dev/null
+++ b/src/main/java/manager/Appointment.java
@@ -0,0 +1,151 @@
+package manager;
+
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+import java.time.format.DateTimeFormatter;
+
+/**
+ * Represents an appointment in the clinic management system.
+ * Contains information about the patient (NRIC), appointment date/time,
+ * description, and completion status.
+ */
+public class Appointment {
+
+ public static final DateTimeFormatter INPUT_FORMAT = DateTimeFormatter.ofPattern("yyyy-MM-dd HHmm");
+ public static final DateTimeFormatter OUTPUT_FORMAT = DateTimeFormatter.ofPattern("yyyy-MM-dd h:mm a");
+
+ private static int runningId = 100;
+ private final String id;
+ private final String nric;
+ private final LocalDateTime dateTime;
+ private final String description;
+ private boolean isDone;
+
+ /**
+ * Constructs a new Appointment with auto-generated ID.
+ *
+ * @param nric The NRIC of the patient for this appointment
+ * @param dateTime The date and time of the appointment
+ * @param description The description of the appointment
+ */
+ public Appointment(String nric, LocalDateTime dateTime, String description) {
+ assert nric != null && !nric.isBlank() : "NRIC cannot be null or blank";
+ assert dateTime != null : "DateTime cannot be null";
+ assert description != null && !description.isBlank() : "Description cannot be null or blank";
+
+ this.id = "A" + runningId++;
+ this.nric = nric;
+ this.dateTime = dateTime;
+ this.description = description;
+ this.isDone = false;
+ }
+
+ /**
+ * Constructs an Appointment with a specific ID (used for loading from storage).
+ *
+ * @param id The predefined ID for the appointment
+ * @param nric The NRIC of the patient
+ * @param dateTime The date and time of the appointment
+ * @param description The description of the appointment
+ */
+ public Appointment(String id, String nric, LocalDateTime dateTime, String description) {
+ this.id = id;
+ this.nric = nric;
+ this.dateTime = dateTime;
+ this.description = description;
+ }
+
+ public String getId() {
+ return id;
+ }
+
+ /**
+ * Sets the running ID counter for new appointments.
+ *
+ * @param newId The new starting value for ID generation
+ */
+ public static void setRunningId(int newId) {
+ runningId = newId;
+ }
+
+ public String getNric() {
+ return nric;
+ }
+
+ public LocalDate getDate() {
+ return dateTime.toLocalDate();
+ }
+
+ public LocalTime getTime() {
+ return dateTime.toLocalTime();
+ }
+
+ public LocalDateTime getDateTime() {
+ return dateTime;
+ }
+
+ public static int getRunningId() {
+ return runningId;
+ }
+
+ public String getDescription() {
+ return description;
+ }
+
+ /**
+ * Checks the completion status of the appointment.
+ *
+ * @return true if the appointment is completed, false otherwise
+ */
+ public boolean isDone() {
+ return isDone;
+ }
+
+ public void markAsDone() {
+ this.isDone = true;
+ }
+
+ public void unmarkAsDone() {
+ this.isDone = false;
+ }
+
+ /**
+ * Sets the completion status of the appointment.
+ *
+ * @param mark true to mark as done, false to mark as not done
+ */
+ public void setIsDone(boolean mark) {
+ this.isDone = mark;
+ }
+
+ /**
+ * Gets the status icon of the appointment for display purposes.
+ *
+ * @return "X" if done, " " (space) if not done
+ */
+ public String getStatusIcon() {
+ return (isDone ? "X" : " ");
+ }
+
+ /**
+ * Returns the formatted string representation of the appointment
+ *
+ * @return A formatted string showing appointment ID, status, NRIC, date/time and description
+ */
+ @Override
+ public String toString() {
+ return "[" + id + "]" + "[" + this.getStatusIcon() + "]" + " - "
+ + nric + " - " + dateTime.format(OUTPUT_FORMAT) + " - " + description;
+ }
+
+ /**
+ * Returns the string representation of the appointment in a file-friendly format (for storage).
+ *
+ * @return Pipe-delimited string containing all appointment's information
+ */
+ public String toFileFormat() {
+ return id.substring(1) + "|" + this.isDone + "|" + this.nric + "|" +
+ dateTime.format(OUTPUT_FORMAT) + "|" + this.description;
+ }
+}
diff --git a/src/main/java/manager/ManagementSystem.java b/src/main/java/manager/ManagementSystem.java
new file mode 100644
index 0000000000..3a1b39b0ba
--- /dev/null
+++ b/src/main/java/manager/ManagementSystem.java
@@ -0,0 +1,622 @@
+package manager;
+
+import exception.PatientNotFoundException;
+import exception.AppointmentClashException;
+import exception.DuplicatePatientIDException;
+import exception.InvalidInputFormatException;
+import exception.UnloadedStorageException;
+import miscellaneous.Ui;
+import storage.Storage;
+
+import java.time.Duration;
+import java.time.LocalDate;
+import java.time.format.DateTimeFormatter;
+import java.time.format.DateTimeParseException;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+
+/**
+ * The ManagementSystem class handles all business logic for the clinic management system.
+ * It manages patients, appointments, and prescriptions, and coordinates with the storage system.
+ * This class serves as the central component that maintains the state of the application
+ * and provides operations to access and modify that state.
+ */
+public class ManagementSystem {
+ private final List appointments;
+ private final List patients;
+ private final List prescriptions;
+
+ /**
+ * Constructs a ManagementSystem with patients and appointments but no prescriptions.
+ *
+ * @param loadedPatients The list of patients to initialize with
+ * @param loadedAppointments The list of appointments to initialize with
+ */
+ public ManagementSystem(List loadedPatients, List loadedAppointments) {
+ assert loadedPatients != null : "Patient list cannot be null";
+ assert loadedAppointments != null : "Appointment list cannot be null";
+ appointments = loadedAppointments;
+ patients = loadedPatients;
+ prescriptions = new ArrayList<>();
+ }
+
+ /**
+ * Constructs a ManagementSystem with patients, appointments, and prescriptions.
+ *
+ * @param loadedPatients The list of patients to initialize with
+ * @param loadedAppointments The list of appointments to initialize with
+ * @param loadedPrescriptions The list of prescriptions to initialize with
+ */
+ public ManagementSystem(List loadedPatients, List loadedAppointments,
+ List loadedPrescriptions) {
+ assert loadedPatients != null : "Patient list cannot be null";
+ assert loadedAppointments != null : "Appointment list cannot be null";
+ assert loadedPrescriptions != null : "Prescription list cannot be null";
+ appointments = loadedAppointments;
+ patients = loadedPatients;
+ prescriptions = loadedPrescriptions;
+ }
+
+ /**
+ * Gets the list of all patients in the system.
+ *
+ * @return List of all Patient objects
+ */
+ public List getPatients() {
+ return patients;
+ }
+
+ /**
+ * Updates the list of appointments in the system.
+ * Replaces the entire appointment list with the provided one.
+ *
+ * @param appointments The new list of appointments to set
+ */
+ public void setAppointments(List appointments) {
+ this.appointments.clear();
+ this.appointments.addAll(appointments);
+ }
+
+ /**
+ * Gets the list of all appointments in the system.
+ *
+ * @return List of all Appointment objects
+ */
+ public List getAppointments() {
+ return appointments;
+ }
+
+ /**
+ * Adds a new patient to the system.
+ * Checks for duplicate NRICs before adding the patient.
+ * Saves the updated patient list to storage after successful addition.
+ *
+ * @param patient The patient to add
+ * @throws DuplicatePatientIDException If a patient with the same NRIC already exists
+ * @throws UnloadedStorageException If there was an error saving to storage
+ */
+ public void addPatient(Patient patient) throws DuplicatePatientIDException, UnloadedStorageException {
+ assert patient != null : "Patient cannot be null";
+ assert patients != null : "Patient list cannot be null";
+
+ for (Patient existingPatient : patients) {
+ assert existingPatient != null : "Existing patient in list cannot be null";
+ if (existingPatient.getId().equals(patient.getId())) {
+ throw new DuplicatePatientIDException("Patient ID already exists!");
+ }
+ }
+ patients.add(patient);
+ Storage.savePatients(patients);
+ }
+
+ /**
+ * Deletes a patient from the system by NRIC.
+ * Also removes all appointments associated with the deleted patient.
+ * Saves the updated patient and appointment lists to storage after successful deletion.
+ *
+ * @param nric The NRIC of the patient to delete
+ * @return The deleted Patient object, or null if no patient was found with the given NRIC
+ * @throws UnloadedStorageException If there was an error saving to storage
+ */
+ public Patient deletePatient(String nric) throws UnloadedStorageException {
+ assert nric != null && !nric.isBlank() : "NRIC must not be null or blank";
+ assert patients != null : "Patient list cannot be null";
+
+ for (Patient patient : patients) {
+ if (patient.getId().equals(nric)) {
+ patients.remove(patient);
+ // delete all appointments associated with a patient to be deleted
+ appointments.removeIf(appointment -> appointment.getNric().equals(nric));
+ Storage.savePatients(patients);
+ Storage.saveAppointments(appointments);
+ return patient;
+ }
+ }
+ return null;
+ }
+
+ //@@author dylancmznus
+
+ /**
+ * Retrieves the patient object that matches the specified NRIC.
+ *
+ * The method iterates through the list of existing patients to find a match
+ * based on the NRIC. If a match is found, the corresponding Patient object is returned;
+ * otherwise, it returns null.
+ *
+ * @param nric The NRIC of the patient to be retrieved.
+ * @return The Patient object matching the given NRIC, or null if no match is found.
+ * @throws AssertionError if the input NRIC is null or blank.
+ */
+ public Patient viewPatient(String nric) {
+ assert nric != null && !nric.isBlank() : "NRIC must not be null or blank";
+ Patient matchedPatient = null;
+ for (Patient patient : patients) {
+ if (patient.getId().equals(nric)) {
+ matchedPatient = patient;
+ break;
+ }
+ }
+ return matchedPatient;
+ }
+
+
+ /**
+ * Edits an existing patient's information.
+ * Updates only the fields that are provided (non-null).
+ * Saves changes to storage after successful update.
+ *
+ * @param nric The NRIC of the patient to edit (cannot be changed)
+ * @param newName New name for the patient, or null to keep unchanged
+ * @param newDob New date of birth, or null to keep unchanged
+ * @param newGender New gender, or null to keep unchanged
+ * @param newAddress New address, or null to keep unchanged
+ * @param newPhone New phone number, or null to keep unchanged
+ * @throws UnloadedStorageException If there was an error saving to storage
+ * @throws PatientNotFoundException If no patient with the given NRIC exists
+ */
+ //@@author jyukuan
+ public void editPatient(String nric, String newName, String newDob, String newGender, String newAddress,
+ String newPhone) throws UnloadedStorageException, PatientNotFoundException,
+ InvalidInputFormatException {
+
+ assert nric != null && !nric.isBlank() : "NRIC must not be null or blank";
+ assert patients != null : "Patient list cannot be null";
+
+ Patient patient = findPatientByNric(nric);
+ if (patient == null) {
+ throw new PatientNotFoundException("Patient with NRIC " + nric + " not found.");
+ }
+ if (newName != null && !newName.isBlank()) {
+ patient.setName(newName);
+ }
+ if (newDob != null && !newDob.isBlank()) {
+ try {
+ DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
+ LocalDate parsedDob = LocalDate.parse(newDob, formatter);
+ if (parsedDob.isAfter(LocalDate.now())) {
+ throw new InvalidInputFormatException("Date of birth must be before today.");
+ }
+ patient.setDob(parsedDob);
+ } catch (DateTimeParseException e) {
+ throw new InvalidInputFormatException("Invalid date format. Use yyyy-MM-dd.");
+ }
+ }
+
+ if (newGender != null && !newGender.isBlank()) {
+ patient.setGender(newGender);
+ }
+ if (newAddress != null && !newAddress.isBlank()) {
+ patient.setAddress(newAddress);
+ }
+ if (newPhone != null && !newPhone.isBlank()) {
+ patient.setContactInfo(newPhone);
+ }
+ Storage.savePatients(patients);
+ System.out.println("Patient with NRIC " + nric + " updated successfully.");
+ }
+
+ /**
+ * Stores new medical history entries for a patient.
+ * If an entry already exists in the patient's history, it will not be duplicated.
+ * Saves the updated patient list to storage.
+ *
+ * @param nric The NRIC of the patient
+ * @param medHistory Comma-separated medical history entries to add
+ * @throws PatientNotFoundException If no patient with the given NRIC exists
+ * @throws UnloadedStorageException If there was an error saving to storage
+ */
+ public void storeMedicalHistory(String nric, String medHistory) throws PatientNotFoundException,
+ UnloadedStorageException {
+ Patient existingPatient = findPatientByNric(nric);
+
+ assert nric != null && !nric.isBlank() : "NRIC must not be null or blank";
+ assert medHistory != null && !medHistory.isBlank() : "Medical history must not be null or blank";
+
+
+ if (existingPatient == null) {
+ throw new PatientNotFoundException("Patient with NRIC not found. Patient's history can not be added");
+ } else {
+ Ui.showLine();
+ }
+
+ String[] historyEntries = medHistory.split(",\\s*");
+ for (String entry : historyEntries) {
+ if (!existingPatient.getMedicalHistory().contains(entry.trim())) {
+ existingPatient.getMedicalHistory().add(entry.trim());
+ }
+ }
+ Storage.savePatients(patients);
+ System.out.println("Medical history added for patient with NRIC: " + nric + ".");
+ Ui.showLine();
+ }
+
+
+ /**
+ * Views the medical history for a single patient identified by NRIC,
+ * and displays it to the user via the Ui component.
+ *
+ * @param nric The NRIC of the patient whose medical history should be displayed.
+ * @throws PatientNotFoundException if no patient with the specified NRIC is found.
+ */
+ public void viewMedicalHistoryByNric(String nric) throws PatientNotFoundException {
+ Patient foundPatients = findPatientByNric(nric.trim());
+
+ if (foundPatients == null) {
+ throw new PatientNotFoundException("No patient/patients found with NRIC " + nric + ".");
+ } else {
+ Ui.showLine();
+ Ui.showPatientHistory(foundPatients);
+ }
+ }
+
+ /**
+ * Finds one or more patients by name, then displays each patient's medical history.
+ * If multiple patients share the same name, all their histories are shown.
+ *
+ * @param name The name of the patient(s) whose medical history should be displayed.
+ */
+ public void viewMedicalHistoryByName(String name) {
+ List foundPatients = findPatientsByName(name.trim());
+
+ Ui.showLine();
+
+ if (foundPatients.isEmpty()) {
+ System.out.println("No patients found with name '" + name + "'.");
+ Ui.showLine();
+ } else {
+ System.out.println("Found " + foundPatients.size() + " patient(s) with name '" + name + "'");
+ for (Patient p : foundPatients) {
+ Ui.showPatientHistory(p);
+ }
+ }
+ }
+
+ /**
+ * Edits a specific medical history entry for a patient.
+ * Replaces the old history text with new text if the old text is found.
+ *
+ * @param nric The patient's unique identifier
+ * @param oldHistory The existing history text to be replaced
+ * @param newHistory The new history text to replace it with
+ * @throws UnloadedStorageException If there was an error saving to storage
+ */
+ public void editPatientHistory(String nric, String oldHistory, String newHistory) throws UnloadedStorageException {
+
+ assert nric != null && !nric.isBlank() : "NRIC must not be null or blank";
+ assert oldHistory != null && !oldHistory.isBlank() : "Old history must not be blank";
+ assert newHistory != null && !newHistory.isBlank() : "New history must not be blank";
+
+ Patient patient = findPatientByNric(nric);
+ if (patient == null) {
+ System.out.println("Patient with NRIC " + nric + " not found.");
+ return;
+ }
+ List histories = patient.getMedicalHistory();
+ boolean foundOld = false;
+ for (int i = 0; i < histories.size(); i++) {
+ if (histories.get(i).equalsIgnoreCase(oldHistory.trim())) {
+ histories.set(i, newHistory.trim());
+ foundOld = true;
+ System.out.println("Replaced old history \"" + oldHistory + "\" with \"" + newHistory + "\".");
+ break;
+ }
+ }
+ Storage.savePatients(patients);
+ if (!foundOld) {
+ System.out.println("Old history \"" + oldHistory + "\" not found for patient " + patient.getName());
+ }
+ }
+
+
+ /**
+ * Finds a patient by their NRIC, ignoring case.
+ *
+ * @param nric The NRIC string to search for.
+ * @return The Patient object if found, or null if no matching patient is found.
+ */
+ public Patient findPatientByNric(String nric) {
+ String object = nric.trim().toUpperCase();
+ for (Patient p : patients) {
+ String patientId = p.getId().trim().toUpperCase();
+ if (patientId.equals(object)) {
+ return p;
+ }
+ }
+ return null;
+ }
+
+ /**
+ * Finds a list of patients who have a matching name (case-insensitive).
+ *
+ * @param name The name string to search for.
+ * @return A List of Patient objects that match the given name (could be empty if none found).
+ */
+ private List findPatientsByName(String name) {
+ List result = new ArrayList<>();
+ for (Patient p : patients) {
+ if (p.getName().trim().equalsIgnoreCase(name)) {
+ result.add(p);
+ }
+ }
+ return result;
+ }
+
+ //@@author chwenyee
+
+ /**
+ * Adds a new appointment to the system.
+ * Checks for appointment clashes (within 1 hour) and verifies the patient exists.
+ * Saves the updated appointment list to storage after successful addition.
+ *
+ * @param appointment The appointment to add
+ * @throws UnloadedStorageException If there was an error saving to storage
+ * @throws PatientNotFoundException If the patient associated with the appointment doesn't exist
+ * @throws AppointmentClashException If the appointment clashes with an existing appointment
+ */
+ public void addAppointment(Appointment appointment) throws UnloadedStorageException, PatientNotFoundException,
+ AppointmentClashException {
+ assert appointment != null : "Appointment cannot be null";
+ assert patients != null : "Patient list cannot be null";
+
+ // Check if there is any scheduled appointment in the list clashing with this newly-added one
+ for (Appointment appointmentInList : appointments) {
+ long timeDiff = Math.abs(Duration.between(appointmentInList.getDateTime(),
+ appointment.getDateTime()).toMinutes());
+ if (timeDiff < 60) {
+ throw new AppointmentClashException("This appointment clashes with another scheduled within 1 hour.");
+ }
+ }
+
+ Patient patient = findPatientByNric(appointment.getNric());
+ if (patient == null) {
+ throw new PatientNotFoundException("Patient with NRIC: " + appointment.getNric() + " not found");
+ }
+
+ appointments.add(appointment);
+ patient.addAppointment(appointment);
+ Storage.saveAppointments(appointments);
+ }
+
+ /**
+ * Deletes an appointment from the system by appointment ID.
+ * Also removes the appointment from the patient's appointment list.
+ * Saves the updated appointment list to storage after successful deletion.
+ *
+ * @param apptId The ID of the appointment to delete
+ * @return The deleted Appointment object, or null if no appointment was found with the given ID
+ * @throws UnloadedStorageException If there was an error saving to storage
+ */
+ public Appointment deleteAppointment(String apptId) throws UnloadedStorageException {
+ assert apptId != null && !apptId.isBlank() : "Appointment ID cannot be null or blank";
+ assert appointments != null : "Appointment list cannot be null";
+
+ for (Appointment appointment : appointments) {
+ if (appointment.getId().equalsIgnoreCase(apptId)) {
+ appointments.remove(appointment);
+ Patient patient = findPatientByNric(appointment.getNric());
+ if (patient != null) {
+ patient.deleteAppointment(apptId);
+ Storage.saveAppointments(appointments);
+ }
+ return appointment;
+ }
+ }
+ return null;
+ }
+
+ /**
+ * Sorts a list of appointments by date and time.
+ * Orders appointments chronologically from earliest to latest.
+ *
+ * @param appointments The list of appointments to sort
+ * @return The sorted list of appointments
+ */
+ public List sortAppointmentsByDateTime(List appointments) {
+ appointments.sort(Comparator.comparing(Appointment::getDateTime));
+ return appointments;
+ }
+
+ /**
+ * Sorts a list of appointments by their ID.
+ * Orders appointments alphanumerically based on their appointment ID.
+ *
+ * @param appointments The list of appointments to sort
+ * @return The sorted list of appointments
+ */
+ public List sortAppointmentsById(List appointments) {
+ appointments.sort(Comparator.comparing(Appointment::getId));
+ return appointments;
+ }
+
+ /**
+ * Marks an appointment as completed.
+ * Updates the appointment status and saves changes to storage.
+ *
+ * @param apptId The ID of the appointment to mark as done
+ * @return The updated appointment, or null if no appointment with the given ID was found
+ * @throws UnloadedStorageException If there was an error saving to storage
+ */
+ public Appointment markAppointment(String apptId) throws UnloadedStorageException {
+ for (Appointment appointment : appointments) {
+ if (appointment.getId().equalsIgnoreCase(apptId)) {
+ appointment.markAsDone();
+ Storage.saveAppointments(appointments);
+ return appointment;
+ }
+ }
+ return null;
+ }
+
+ /**
+ * Unmarks a previously completed appointment.
+ * Updates the appointment status and saves changes to storage.
+ *
+ * @param apptId The ID of the appointment to unmark
+ * @return The updated appointment, or null if no appointment with the given ID was found
+ * @throws UnloadedStorageException If there was an error saving to storage
+ */
+ public Appointment unmarkAppointment(String apptId) throws UnloadedStorageException {
+ for (Appointment appointment : appointments) {
+ if (appointment.getId().equalsIgnoreCase(apptId)) {
+ appointment.unmarkAsDone();
+ Storage.saveAppointments(appointments);
+ return appointment;
+ }
+ }
+ return null;
+ }
+
+
+ /**
+ * Finds all appointments associated with the specified NRIC.
+ *
+ * This method searches through the list of stored appointments and collects
+ * all appointments that match the given NRIC exactly.
+ *
+ * @param nric The NRIC used to search for matching appointments.
+ * @return A list of appointments that are associated with the provided NRIC.
+ */
+ public List findAppointmentsByNric(String nric) {
+ List matchingAppointments = new ArrayList<>();
+ for (Appointment appt : appointments) {
+ if (appt.getNric().equals(nric)) {
+ matchingAppointments.add(appt);
+ }
+ }
+ return matchingAppointments;
+ }
+
+ //@@author Basudeb2005
+
+ /**
+ * Gets all prescriptions stored in the system.
+ *
+ * @return A list of all prescription records
+ */
+ public List getPrescriptions() {
+ return prescriptions;
+ }
+
+ //@@author Basudeb2005
+
+ /**
+ * Adds a new prescription to the system.
+ * Verifies the patient exists before adding the prescription.
+ * Generates a unique prescription ID based on patient ID and prescription count.
+ * Saves the updated prescription list to storage.
+ *
+ * @param prescription The prescription to add (without final ID)
+ * @return The newly created prescription with final ID
+ * @throws IllegalArgumentException If the patient doesn't exist or maximum prescriptions reached
+ * @throws UnloadedStorageException If there was an error saving to storage
+ */
+ public Prescription addPrescription(Prescription prescription)
+ throws IllegalArgumentException, UnloadedStorageException {
+ assert prescription != null : "Prescription cannot be null";
+ assert patients != null : "Patient list cannot be null";
+
+ Patient patient = findPatientByNric(prescription.getPatientId());
+ if (patient == null) {
+ throw new IllegalArgumentException("Patient with NRIC: " + prescription.getPatientId() + " not found");
+ }
+
+ // Generate prescription ID with counter
+ int prescriptionCount = 1;
+ for (Prescription p : prescriptions) {
+ if (p.getPatientId().equals(prescription.getPatientId())) {
+ prescriptionCount++;
+ }
+ }
+
+ // Check for maximum prescription limit
+ final int MAX_PRESCRIPTIONS_PER_PATIENT = 100; // Reasonable upper limit
+ if (prescriptionCount > MAX_PRESCRIPTIONS_PER_PATIENT) {
+ throw new IllegalArgumentException("Maximum number of prescriptions (" +
+ MAX_PRESCRIPTIONS_PER_PATIENT +
+ ") reached for patient: " + prescription.getPatientId());
+ }
+
+ String prescriptionId = prescription.getPatientId() + "-" + prescriptionCount;
+
+ // Create a new prescription with updated ID
+ Prescription newPrescription = new Prescription(
+ prescription.getPatientId(),
+ prescriptionId,
+ prescription.getTimestamp(),
+ prescription.getSymptoms(),
+ prescription.getMedicines(),
+ prescription.getNotes()
+ );
+
+ prescriptions.add(newPrescription);
+
+ try {
+ Storage.savePrescriptions(prescriptions);
+ } catch (UnloadedStorageException e) {
+ // Roll back the addition if saving fails
+ prescriptions.remove(newPrescription);
+ throw e; // Re-throw to notify the caller
+ }
+
+ return newPrescription;
+ }
+
+ //@@author Basudeb2005
+
+ /**
+ * Retrieves all prescriptions for a specific patient.
+ * Filters the complete prescription list to find those matching the provided patient ID.
+ *
+ * @param patientId The unique identifier of the patient
+ * @return A list of prescriptions for the specified patient (may be empty if none found)
+ */
+ public List getPrescriptionsForPatient(String patientId) {
+ List patientPrescriptions = new ArrayList<>();
+ for (Prescription prescription : prescriptions) {
+ if (prescription.getPatientId().equals(patientId)) {
+ patientPrescriptions.add(prescription);
+ }
+ }
+ return patientPrescriptions;
+ }
+
+ //@@author Basudeb2005
+
+ /**
+ * Finds a specific prescription by its unique identifier.
+ *
+ * @param prescriptionId The unique ID of the prescription to find
+ * @return The prescription if found, or null if no matching prescription exists
+ */
+ public Prescription getPrescriptionById(String prescriptionId) {
+ for (Prescription prescription : prescriptions) {
+ if (prescription.getPrescriptionId().equals(prescriptionId)) {
+ return prescription;
+ }
+ }
+ return null;
+ }
+
+}
diff --git a/src/main/java/manager/Patient.java b/src/main/java/manager/Patient.java
new file mode 100644
index 0000000000..d9d7628bff
--- /dev/null
+++ b/src/main/java/manager/Patient.java
@@ -0,0 +1,360 @@
+package manager;
+
+import exception.InvalidInputFormatException;
+
+import java.time.LocalDate;
+import java.time.format.DateTimeFormatter;
+import java.time.format.DateTimeParseException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * Represents a patient in the clinic management system.
+ * Stores patient details such as NRIC, name, date of birth, contact info, gender,
+ * address, medical history, and appointments.
+ */
+public class Patient {
+
+ private String id;
+ private String name;
+ private LocalDate dob;
+ private String contactInfo;
+ private String gender;
+ private String address;
+ private final List medicalHistory;
+ private final List appointments;
+
+ /**
+ * Constructs a new Patient object with the given details.
+ *
+ * @param id The NRIC of the patient.
+ * @param name The name of the patient.
+ * @param dobStr The date of birth in yyyy-MM-dd format.
+ * @param gender The gender (M or F).
+ * @param address The address.
+ * @param contactInfo The 8-digit contact number.
+ * @param medicalHistory A list of past medical history.
+ * @throws InvalidInputFormatException if any input format is invalid.
+ */
+ public Patient(String id, String name, String dobStr, String gender, String address,
+ String contactInfo, List medicalHistory) throws InvalidInputFormatException {
+ assert id != null && !id.isBlank() : "Patient ID cannot be null or blank";
+ assert name != null && !name.isBlank() : "Patient name cannot be null or blank";
+ assert dobStr != null : "Date of birth cannot be null";
+ assert gender != null : "Gender cannot be null";
+ assert address != null : "Address cannot be null";
+ assert contactInfo != null : "Contact info cannot be null";
+ assert medicalHistory != null : "Medical history list cannot be null";
+
+ this.id = parseValidIC(id);
+ this.name = name;
+ this.dob = parseAndValidateDob(dobStr);
+ this.gender = checkGender(gender);
+ this.address = address;
+ this.contactInfo = parseContactInfo(contactInfo);
+ this.medicalHistory = new ArrayList<>(medicalHistory);
+ this.appointments = new ArrayList<>();
+ }
+
+ /**
+ * Parses a pipe-delimited line into a Patient object.
+ * Accepts either 6 tokens (if medical history is empty) or 7 tokens.
+ *
+ * @param line The line to parse.
+ * @return A Patient object or null if the format is invalid.
+ * @throws InvalidInputFormatException if any of the fields are invalid.
+ */
+ public static Patient parseLoadPatient(String line) throws InvalidInputFormatException {
+ String[] tokens = line.split("\\|");
+ if (tokens.length < 6 || tokens.length > 7) {
+ return null;
+ }
+
+ String id = tokens[0];
+ String name = tokens[1];
+ String dobStr = tokens[2];
+ String gender = tokens[3];
+ String address = tokens[4];
+ String contact = tokens[5];
+ List medHistory = new ArrayList<>();
+
+ if (tokens.length == 7 && !tokens[6].isBlank()) {
+ medHistory = Arrays.stream(tokens[6].split(","))
+ .map(String::trim)
+ .collect(Collectors.toList());
+ }
+
+ return new Patient(id, name, dobStr, gender, address, contact, medHistory);
+ }
+
+ /**
+ * @return the patient NRIC
+ */
+ public String getId() {
+ return id;
+ }
+
+ /**
+ * @return the patient name
+ */
+ public String getName() {
+ return name;
+ }
+
+ /**
+ * @return the patient's date of birth
+ */
+ public LocalDate getDob() {
+ return dob;
+ }
+
+ /**
+ * @return the patient's gender
+ */
+ public String getGender() {
+ return gender;
+ }
+
+ /**
+ * @return the patient's address
+ */
+ public String getAddress() {
+ return address;
+ }
+
+ /**
+ * @return the patient's contact number
+ */
+ public String getContactInfo() {
+ return contactInfo;
+ }
+
+ /**
+ * @return the patient's medical history list
+ */
+ public List getMedicalHistory() {
+ return medicalHistory;
+ }
+
+ public void setName(String name) {
+ this.name = name;
+ }
+
+ public void setDob(LocalDate dob) {
+ this.dob = dob;
+ }
+
+ public void setContactInfo(String contactInfo) {
+ this.contactInfo = contactInfo;
+ }
+
+ public void setGender(String gender) {
+ this.gender = gender;
+ }
+
+ public void setAddress(String address) {
+ this.address = address;
+ }
+
+ /**
+ * @return the patient's list of appointments
+ */
+ public List getAppointments() {
+ return appointments;
+ }
+
+ /**
+ * Adds an appointment to the patient.
+ *
+ * @param appointment Appointment to be added.
+ */
+ public void addAppointment(Appointment appointment) {
+ assert appointment != null : "Appointment cannot be null";
+ assert appointment.getNric().equals(this.id) : "Appointment NRIC must match patient ID";
+ appointments.add(appointment);
+ }
+
+ /**
+ * Removes an appointment from the patient by appointment ID.
+ *
+ * @param apptId ID of the appointment to be removed.
+ */
+ public void deleteAppointment(String apptId) {
+ assert apptId != null && !apptId.isBlank() : "Appointment ID cannot be null or blank";
+ for (Appointment appt : appointments) {
+ if (appt.getId().equals(apptId)) {
+ appointments.remove(appt);
+ break;
+ }
+ }
+ }
+
+ /**
+ * Returns a string representation of the patient for display.
+ *
+ * @return Formatted patient details and appointments.
+ */
+ @Override
+ public String toString() {
+ String formattedMedicalHistory = medicalHistory.isEmpty() ? "None" : String.join(", ", medicalHistory);
+
+ String result = String.format(
+ "Patient NRIC: %s\n"
+ + "Name: %s\n"
+ + "Date of Birth: %s\n"
+ + "Gender: %s\n"
+ + "Address: %s\n"
+ + "Contact: %s\n"
+ + "Medical History: %s",
+ id, name, dob.format(DateTimeFormatter.ofPattern("yyyy-MM-dd")),
+ gender, address, contactInfo, formattedMedicalHistory);
+
+ if (appointments.isEmpty()) {
+ result += "\nAppointments: None";
+ } else {
+ result += "\nAppointments:";
+ for (Appointment appt : appointments) {
+ result += String.format(
+ "\n- [%s][%s]: %s (%s)",
+ appt.getId(),
+ appt.getStatusIcon(),
+ appt.getDateTime().format(Appointment.OUTPUT_FORMAT),
+ appt.getDescription());
+ }
+ }
+ return result;
+ }
+
+ /**
+ * Returns a formatted string for list display.
+ *
+ * @return Compact patient details for list view.
+ */
+ public String toStringForListView() {
+ String result = String.format(
+ "Patient NRIC: %s\n "
+ + "Name: %s\n "
+ + "Date of Birth: %s\n "
+ + "Gender: %s\n "
+ + "Address: %s\n "
+ + "Contact: %s",
+ id, name, dob.format(DateTimeFormatter.ofPattern("yyyy-MM-dd")), gender, address, contactInfo);
+
+ if (medicalHistory.isEmpty()) {
+ result += "\n Medical History: None";
+ } else {
+ result += "\n Medical History:";
+ for (String h : medicalHistory) {
+ result += "\n - " + h;
+ }
+ }
+
+ if (appointments.isEmpty()) {
+ result += "\n Appointments: None";
+ } else {
+ result += "\n Appointments:";
+ for (Appointment appt : appointments) {
+ result += String.format(
+ "\n - [%s][%s]: %s (%s)",
+ appt.getId(),
+ appt.getStatusIcon(),
+ appt.getDateTime().format(Appointment.OUTPUT_FORMAT),
+ appt.getDescription());
+ }
+ }
+ return result;
+ }
+
+ /**
+ * Returns a pipe-delimited string for file storage.
+ *
+ * @return File format string.
+ */
+ public String toFileFormat() {
+ String history = String.join(", ", this.medicalHistory);
+ return this.id + "|" + this.name + "|" + dob.format(DateTimeFormatter.ofPattern("yyyy-MM-dd"))
+ + "|" + this.gender + "|" + this.address + "|" + this.contactInfo + "|" + history;
+ }
+
+ /**
+ * Validates and parses the NRIC format.
+ *
+ * @param ic The NRIC string to validate.
+ * @return A validated NRIC string.
+ * @throws InvalidInputFormatException If the NRIC format is invalid.
+ */
+ private String parseValidIC(String ic) throws InvalidInputFormatException {
+ if (ic == null || ic.length() != 9) {
+ throw new InvalidInputFormatException("IC must be exactly 9 characters long.");
+ }
+ String prefix = ic.substring(0, 1).toUpperCase();
+ String numberPart = ic.substring(1, 8);
+ String suffix = ic.substring(8).toUpperCase();
+
+ if (!prefix.matches("[STFGM]")) {
+ throw new InvalidInputFormatException("IC must start with S, T, F, G, or M.");
+ }
+ if (!numberPart.matches("\\d{7}")) {
+ throw new InvalidInputFormatException("IC must contain 7 digits after the prefix.");
+ }
+ if (!suffix.matches("[A-Z]")) {
+ throw new InvalidInputFormatException("IC must end with an uppercase letter.");
+ }
+ return ic;
+ }
+
+ /**
+ * Validates the gender input.
+ *
+ * @param gender Gender string to validate.
+ * @return Validated gender.
+ * @throws InvalidInputFormatException If the gender is not M or F.
+ */
+ private String checkGender(String gender) throws InvalidInputFormatException {
+ if (gender.equals("M") || gender.equals("F")) {
+ return gender;
+ } else {
+ throw new InvalidInputFormatException("The gender must be either M (male) or F (female)");
+ }
+ }
+
+ /**
+ * Parses and validates the date of birth string.
+ *
+ * @param dobStr Date of birth in yyyy-MM-dd format.
+ * @return Parsed LocalDate object.
+ * @throws InvalidInputFormatException If format is incorrect or date is in the future.
+ */
+ private LocalDate parseAndValidateDob(String dobStr) throws InvalidInputFormatException {
+ DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
+ try {
+ LocalDate dob = LocalDate.parse(dobStr, formatter);
+ if (dob.isAfter(LocalDate.now())) {
+ throw new InvalidInputFormatException("Date of birth must be before the current date.");
+ }
+ return dob;
+ } catch (DateTimeParseException e) {
+ throw new InvalidInputFormatException("Invalid date format. Use yyyy-MM-dd.");
+ }
+ }
+
+ /**
+ * Validates and parses the contact number.
+ *
+ * @param contactInfo Contact number string.
+ * @return Validated contact number.
+ * @throws InvalidInputFormatException If not an 8-digit number.
+ */
+ private String parseContactInfo(String contactInfo) throws InvalidInputFormatException {
+ try {
+ if (contactInfo.length() != 8 || !contactInfo.matches("\\d+")) {
+ throw new InvalidInputFormatException("Contact number must be 8 digits.");
+ }
+ return contactInfo;
+ } catch (NullPointerException e) {
+ throw new InvalidInputFormatException("Contact number cannot be null.");
+ }
+ }
+}
diff --git a/src/main/java/manager/Prescription.java b/src/main/java/manager/Prescription.java
new file mode 100644
index 0000000000..de2b54344c
--- /dev/null
+++ b/src/main/java/manager/Prescription.java
@@ -0,0 +1,288 @@
+package manager;
+
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * Represents a medical prescription in the clinic management system.
+ * Contains information about the patient, symptoms, prescribed medicines,
+ * and additional notes provided by the doctor.
+ */
+//@@author Basudeb2005
+public class Prescription {
+ private static final DateTimeFormatter DATE_TIME_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm");
+
+ private final String patientId;
+ private final LocalDateTime timestamp;
+ private final String prescriptionId;
+ private final List symptoms;
+ private final List medicines;
+ private final String notes;
+
+ /**
+ * Constructs a new Prescription with the current timestamp.
+ * This constructor is used when creating a new prescription in the system.
+ *
+ * @param patientId The ID of the patient this prescription is for
+ * @param symptoms List of patient symptoms
+ * @param medicines List of prescribed medicines
+ * @param notes Additional instructions or notes for the patient
+ */
+ public Prescription(String patientId, List symptoms, List medicines, String notes) {
+ this.patientId = patientId;
+ this.timestamp = LocalDateTime.now();
+ this.prescriptionId = patientId + "-" + "1"; // Will be updated to handle numbering
+ this.symptoms = new ArrayList<>(symptoms);
+ this.medicines = new ArrayList<>(medicines);
+ this.notes = notes;
+ }
+
+ /**
+ * Constructs a Prescription with specified prescriptionId and timestamp.
+ * This constructor is primarily used when loading prescriptions from storage.
+ *
+ * @param patientId The ID of the patient this prescription is for
+ * @param prescriptionId The unique identifier for this prescription
+ * @param timestamp The date and time when the prescription was created
+ * @param symptoms List of patient symptoms
+ * @param medicines List of prescribed medicines
+ * @param notes Additional instructions or notes for the patient
+ */
+ public Prescription(String patientId, String prescriptionId, LocalDateTime timestamp,
+ List symptoms, List medicines, String notes) {
+ this.patientId = patientId;
+ this.timestamp = timestamp;
+ this.prescriptionId = prescriptionId;
+ this.symptoms = new ArrayList<>(symptoms);
+ this.medicines = new ArrayList<>(medicines);
+ this.notes = notes;
+ }
+
+ /**
+ * Gets the patient ID associated with this prescription.
+ *
+ * @return The patient's unique identifier
+ */
+ public String getPatientId() {
+ return patientId;
+ }
+
+ /**
+ * Gets the unique identifier for this prescription.
+ *
+ * @return The prescription's ID in format "patientID-number"
+ */
+ public String getPrescriptionId() {
+ return prescriptionId;
+ }
+
+ /**
+ * Gets the timestamp when this prescription was created.
+ *
+ * @return LocalDateTime representing when the prescription was written
+ */
+ public LocalDateTime getTimestamp() {
+ return timestamp;
+ }
+
+ /**
+ * Gets the list of symptoms recorded for this prescription.
+ *
+ * @return List of symptom descriptions
+ */
+ public List getSymptoms() {
+ return symptoms;
+ }
+
+ /**
+ * Gets the list of medicines prescribed.
+ *
+ * @return List of medicine names and dosage instructions
+ */
+ public List getMedicines() {
+ return medicines;
+ }
+
+ /**
+ * Gets any additional notes or instructions for this prescription.
+ *
+ * @return Notes string or empty if no notes were provided
+ */
+ public String getNotes() {
+ return notes;
+ }
+
+ /**
+ * Returns a string representation of the prescription with formatted details.
+ * Includes prescription ID, timestamp, patient ID, and lists of symptoms and medicines.
+ *
+ * @return A formatted multi-line string representation of the prescription
+ */
+ @Override
+ public String toString() {
+ StringBuilder symptomsStr = new StringBuilder();
+ for (String symptom : symptoms) {
+ symptomsStr.append("- ").append(symptom).append("\n");
+ }
+
+ StringBuilder medicinesStr = new StringBuilder();
+ for (String medicine : medicines) {
+ medicinesStr.append("- ").append(medicine).append("\n");
+ }
+
+ return String.format(
+ "Prescription [%s] (%s)\n"
+ + "Patient ID: %s\n"
+ + "Symptoms: \n%s"
+ + "Medicines: \n%s"
+ + "Notes: %s",
+ prescriptionId, timestamp.format(DATE_TIME_FORMATTER),
+ patientId, symptomsStr.toString(), medicinesStr.toString(), notes);
+ }
+
+ /**
+ * Converts the prescription to a storage-friendly string format.
+ * Uses pipe-delimited format to store all prescription attributes.
+ *
+ * @return A string representation suitable for file storage
+ */
+ public String toFileFormat() {
+ return String.join("|",
+ prescriptionId,
+ patientId,
+ timestamp.format(DATE_TIME_FORMATTER),
+ String.join(",", symptoms),
+ String.join(",", medicines),
+ notes);
+ }
+
+ /**
+ * Creates a Prescription object from a storage file entry.
+ * Parses the pipe-delimited string from storage into a Prescription object.
+ *
+ * @param fileEntry The string from the storage file
+ * @return A new Prescription object with the stored data
+ */
+ public static Prescription fromFileFormat(String fileEntry) {
+ String[] parts = fileEntry.split("\\|");
+
+ // Check if we have sufficient parts to create a valid prescription
+ if (parts.length < 5) {
+ System.out.println("Warning: Invalid prescription format: " + fileEntry);
+ return null;
+ }
+
+ String prescriptionId = parts[0];
+ String patientId = parts[1];
+ LocalDateTime timestamp = LocalDateTime.parse(parts[2], DATE_TIME_FORMATTER);
+ List symptoms = parts[3].isEmpty() ? new ArrayList<>() : Arrays.asList(parts[3].split(","));
+ List medicines = parts[4].isEmpty() ? new ArrayList<>() : Arrays.asList(parts[4].split(","));
+ String notes = parts.length > 5 ? parts[5] : ""; // Default to empty string if notes aren't provided
+
+ return new Prescription(patientId, prescriptionId, timestamp, symptoms, medicines, notes);
+ }
+
+ /**
+ * Generates a formatted HTML document for the prescription.
+ * Creates a professional-looking prescription that can be printed.
+ * Includes patient details if provided, symptoms, medicines, and notes.
+ *
+ * @param patient The Patient object (can be null if patient details unavailable)
+ * @return A string containing HTML markup for the prescription
+ */
+ public String generateHtml(Patient patient) {
+ StringBuilder html = new StringBuilder();
+ html.append("\n")
+ .append("\n")
+ .append("\n")
+ .append(" \n")
+ .append(" \n")
+ .append(" Prescription ").append(prescriptionId).append("\n")
+ .append(" \n")
+ .append("\n")
+ .append("\n")
+ .append(" \n")
+ .append(" \n");
+
+ if (patient != null) {
+ html.append("
\n")
+ .append("
Patient Information
\n")
+ .append("
\n")
+ .append(" | Patient ID: | ").append(patient.getId()).append(" |
\n")
+ .append(" | Name: | ").append(patient.getName()).append(" |
\n")
+ .append(" | Gender: | ").append(patient.getGender()).append(" |
\n")
+ .append(" | Date of Birth: | ").append(patient.getDob()).append(" |
\n")
+ .append(" | Contact: | ").append(patient.getContactInfo()).append(" |
\n")
+ .append("
\n")
+ .append("
\n");
+ } else {
+ html.append("
\n")
+ .append("
Patient Information
\n")
+ .append("
\n")
+ .append(" | Patient ID: | ").append(patientId).append(" |
\n")
+ .append("
\n")
+ .append("
\n");
+ }
+
+ html.append("
\n")
+ .append("
Symptoms
\n")
+ .append("
\n");
+
+ for (String symptom : symptoms) {
+ html.append(" - ").append(symptom).append("
\n");
+ }
+
+ html.append("
\n")
+ .append("
\n")
+ .append("
\n")
+ .append("
Prescribed Medications
\n")
+ .append("
\n");
+
+ for (String medicine : medicines) {
+ html.append(" - ").append(medicine).append("
\n");
+ }
+
+ html.append("
\n")
+ .append("
\n");
+
+ if (notes != null && !notes.isEmpty()) {
+ html.append("
\n")
+ .append("
Special Instructions
\n")
+ .append("
").append(notes).append("
\n")
+ .append("
\n");
+ }
+
+ html.append(" \n")
+ .append("