Merge pull request #327 from codebreaker64/branch-PED-bugs

Branch ped bugs

Author: codebreaker64

docs/DeveloperGuide.md

@@ -16,6 +16,7 @@
   - [Storage component](#storage-component)
   - [Common classes](#common-classes)
 - [Implementation](#implementation)
+  - [Delete](#Delete-feature)
   - [Add Reservation Feature](#add-reservation-feature)
   - [[proposed] Undo/Redo](#proposed-undoredo-feature)
 - [Documentation, logging, testing, configuration, dev-ops](#documentation-logging-testing-configuration-dev-ops)
@@ -274,6 +275,50 @@ add occasions when not needed, it was made optional to improve user experience.
 
 --------------------------------------------------------------------------------------------------------------------
 
+### Delete feature
+
+The delete feature allows restaurant managers to delete any unwanted or accidental reservations via the command `delete
+<INDEX> cfm`.
+
+#### How is it implemented
+
+The delete functionality is implemented through the `DeleteCommand` class. The feature is primarily made up of the
+following components:
+
+1. `DeleteCommand` - Delete the reservation based on index shown on the list.
+2. `DeleteCommandParser` - Parses and validates the user input into a `DeleteCommand` object
+
+#### Parsing the user input
+
+1. The user enters a command in the format `delete 1 cfm`.
+2. The `LogicManager` passes the command string to `ReserveMateParser`.
+3. `ReserveMateParser` identifies the command as a `delete` command and delegates to `DeleteCommandParser`.
+4. `DeleteCommandParser` extracts and validates the index. If the index or `cfm` is missing, a parse
+exception will be thrown.
+5. `DeleteCommandParser` will create `DeleteCommand` object with the index. 
+
+#### Command execution
+
+1. `LogicManager` calls the `execute()` method of the `DeleteCommand` object.
+2. The `DeleteCommand` will delete the reservation based on the index from the `Model`.
+
+#### Displaying the result
+
+A new `commandResult` with the success message is created and is returned to the `LogicManager`. The GUI would be
+updated.
+
+![DeleteCommandResult](images/deleteCommandResult.png)
+
+The following sequence diagram shows how the delete command works:
+![DeleteSequenceDiagram](images/DeleteSequenceDiagram.png)
+
+#### Design Considerations
+
+##### Making user type `cfm`
+
+To prevent accidental deletions due to typing the wrong index, users are required to confirm their action by entering
+an additional 'cfm'. This extra step gives them time to double-check the index they’ve entered.
+
 ### [Proposed] Undo/redo feature
 
 The proposed undo/redo mechanism is facilitated by `VersionedReserveMate`. It extends `ReserveMate` with an undo/redo
@@ -663,7 +708,7 @@ Priorities: High (Must have) - `* * *`, Medium (Good to have) - `* *`, Low (Exte
     Use Case ends.
 
 * 2a. The reservation list is empty.
-
+ 
   * 2a1. ReserveMate shows an error message.
 
     Use case ends.
@@ -1114,15 +1159,13 @@ and inefficiency. <br>
 e.g., `d/2025-04-20 1800-2000`, allowing users to create a single reservation for multiple hours. Internally, the system
 will auto-allocate the necessary consecutive slots without requiring the user to enter multiple commands.
 
-
 2. **Simplify preference saving by removing redundant 'save' keyword in `pref` command**: <br>
 **Current Issue**: The `pref` command currently requires users to type `pref save [index] [preference]`,
 e.g., `pref save 1 sitting outdoors`. Since the `pref` command only supports saving preferences, the inclusion of the
 `save` keyword is redundant and adds unnecessary typing for users. <br>
 **Planned Enhancement**: We plan to simplify the command format by removing the need for the `save` keyword.
 Users will be able to directly type `pref [index] [preference]`.
 
-
 3. **Prevents accidental updates due to shifting list indexes after sorting**: <br>
    **Current Issue**: After executing `pref save` or `edit` for a reservation at a given index, the list re-sorts
    (by date, time and last insertion), which might cause indexes to change. If the user tries to update the same reservation
@@ -1153,7 +1196,6 @@ to within the next 60 days**. The inconsistency may mislead users into thinking
 `Note: Reservations can only exist within 60 days from today. Filtering beyond this range will not return future
 reservations.`
 
-
 6. **Display preference and occasion tags in customer reservation details to differentiate similar reservations**: <br>
 **Current Issues**: Currently, users have to manually type `show INDEX` each time they want to check the preferences
 and occasions associated with a reservation. This process can be time-consuming and inefficient, especially for
@@ -1163,3 +1205,34 @@ make it difficult to differentiate between them. <br>
 directly** in the reservation information. This allows users to quickly see preferences and occasions without having to
 run an addition command. By incorporating **preferences and occasions**, reservations with similar names can be easily
 differentiated. <br>
+
+7. **Let users define the maximum number of reservations per hourly slot**: <br>
+**Current Issue**: ReserveMate currently does not enforce a maximum number of reservations per time slot, which may not
+fit the needs of all use cases. For instance, a venue with limited capacity might want to only allow a certain number 
+of concurrent reservations during peak hours. <br>
+**Planned Enhancement**: We plan to introduce a configurable setting that allows admins or users (with the right 
+permissions) to define the maximum number of reservations allowed per hour slot. This offers greater flexibility for 
+different reservation scenarios and business rules.
+
+8. **Change free command output format to show each available hour instead of a continuous range**: <br>
+**Current Issue**: The `free` command currently displays available time in continuous ranges, e.g., `2025-04-28 0000 to
+2025-04-28 1800`. While concise, this format may confuse users. They might interpret it as a single large continuous
+block rather than individual 1-hour slots, or be uncertain whether a reservation can be made at the ending time. <br>
+**Planned Enhancement**: We plan to revise the output format of the free command to explicitly show each available 
+starting reservation slot. For example:
+```
+Available free time slots:
+- 2025-04-28 0000
+- 2025-04-28 0100
+  ...
+- 2025-04-28 1700
+```
+
+9. **Relax phone number constraints to support international numbers for tourists**: <br>
+**Current Issue**: The current phone number validation only accepts Singaporean numbers (8-digit numbers starting with
+8 or 9), which excludes valid international phone numbers commonly used by tourists. This limitation may prevent
+tourists from making reservations using the system. <br> 
+**Planned Enhancement**: We plan to relax the phone number 
+format to allow valid international formats, such as +44 7123 456789 or +1-202-555-0191. Validation will ensure proper
+structure but allow flexibility in country codes. This makes the system more inclusive and tourist-friendly.
+

docs/UserGuide.md

@@ -589,10 +589,9 @@ Format: `delete <INDEX> cfm`
 > **Use Case #1**: Deleting the 2nd reservation after listing all.
 >
 > **Input:**
-> 
-> `list`
-> 
-> `delete 2 cfm`
+>
+> <br> 1. `list`
+> <br> 2. `delete 2 cfm`
 >
 > **Output:**
 > ```
@@ -605,9 +604,9 @@ Format: `delete <INDEX> cfm`
 >
 > **Input:**
 > 
-> `find Jane`
-> 
-> `delete 1 cfm`
+> <br> 1. `find Jane`
+> <br> 2. `delete 1 cfm`
+>
 >
 > **Output:**
 > ```
@@ -1158,6 +1157,11 @@ Format: `free <DATE>`
 **Constraints**
 - Date must be in `YYYY-MM-DD` format. Do not include `HHmm`.
 
+**Note**
+- Each reservation is 1 hour long. For example, if a time slot ends at `2025-04-28 1800`, 
+it means the available <br> time is from `2025-04-28 1700` to `2025-04-28 1800`. 
+So, you can add a reservation at `2025-04-28 1700`.
+
 ---
 
 - **Successful Execution:**
@@ -1172,7 +1176,7 @@ Format: `free <DATE>`
 > ```
 > Available free time slots:
 > - 2025-04-28 0000 to 2025-04-28 1800
-> - 2025-04-28 1900 to 2025-04-28 2300
+> - 2025-04-28 1900 to 2025-04-29 0000
 > ```
 >
 > ---

docs/diagrams/tracing/LogicSequenceDiagram.puml

@@ -3,7 +3,7 @@
 skinparam ArrowFontStyle plain
 
 Participant ":LogicManager" as logic LOGIC_COLOR
-Participant ":AddressBookParser" as abp LOGIC_COLOR
+Participant ":ReserveMateParser" as abp LOGIC_COLOR
 Participant ":EditCommandParser" as ecp LOGIC_COLOR
 Participant "command:EditCommand" as ec LOGIC_COLOR
 
@@ -14,7 +14,7 @@ create ecp
 abp -> ecp
 abp -> ecp ++: parse(arguments)
 create ec
-ecp -> ec ++: index, editCustomerDescriptor
+ecp -> ec ++: index, editReservationDescriptor
 ec --> ecp --
 ecp --> abp --: command
 abp --> logic --: command

src/main/java/seedu/reserve/logic/commands/FreeCommand.java

@@ -32,6 +32,8 @@ public class FreeCommand extends Command {
     public static final String MESSAGE_ALL_FREE_SLOTS = "All timings are available on this date.";
     private static final Logger logger = LogsCenter.getLogger(FreeCommand.class);
     private static final DateTimeFormatter FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HHmm");
+    private static final int MIN_SLOT_DURATION_HOURS = 1;
+    private static final int DAYS_TO_ADD = 1;
 
     private final ReservationBetweenDatePredicate predicate;
     private final LocalDateTime searchStart;
@@ -45,7 +47,7 @@ public class FreeCommand extends Command {
     public FreeCommand(DateTime date) {
         requireNonNull(date);
         this.searchStart = date.value;
-        this.searchEnd = date.value.plusHours(23);
+        this.searchEnd = date.value.plusDays(DAYS_TO_ADD);
         this.predicate = new ReservationBetweenDatePredicate(date,
                 new DateTime(this.searchEnd.format(FORMATTER)));
         logger.fine("Created FreeCommand for date: " + date);
@@ -90,7 +92,7 @@ private List<TimeSlot> getAllFreeSlots(List<Reservation> reservations) {
         addSlotIfValid(freeSlots, searchStart, firstReservationStart);
 
         // Check slots between reservations
-        LocalDateTime previousEnd = firstReservationStart.plusHours(1);
+        LocalDateTime previousEnd = firstReservationStart.plusHours(MIN_SLOT_DURATION_HOURS);
         for (int i = 1; i < reservations.size(); i++) {
             LocalDateTime currentStart = reservations.get(i).getDateTime().value;
             addSlotIfValid(freeSlots, previousEnd, currentStart);

src/main/java/seedu/reserve/logic/parser/FreeCommandParser.java

@@ -45,10 +45,5 @@ public FreeCommand parse(String args) throws ParseException {
         }
 
         return new FreeCommand(date);
-
     }
-
-
-
-
 }

src/main/java/seedu/reserve/logic/parser/ShowCommandParser.java

@@ -15,7 +15,6 @@
  * Parses input arguments and creates a new ShowCommand object
  */
 public class ShowCommandParser implements Parser<ShowCommand> {
-
     private static final Logger logger = LogsCenter.getLogger(ShowCommandParser.class);
 
     /**

src/test/java/seedu/reserve/logic/commands/FreeCommandTest.java

@@ -42,7 +42,7 @@ public void execute_hasFreeSlots_showsFreeSlots() {
         String expectedMessage = "Available free time slots:"
                 + "\n- 2025-05-01 0000 to 2025-05-01 1000"
                 + "\n- 2025-05-01 1100 to 2025-05-01 1400"
-                + "\n- 2025-05-01 1500 to 2025-05-01 2300";
+                + "\n- 2025-05-01 1500 to 2025-05-02 0000";
 
         assertCommandSuccess(freeCommand, model, expectedMessage, model);
     }
@@ -72,7 +72,7 @@ public void execute_freeSlotBeforeFirstReservation_showsEarlySlot() {
         FreeCommand freeCommand = new FreeCommand(new DateTime(TEST_DATE.toString()));
         String expectedMessage = "Available free time slots:"
                 + "\n- 2025-05-01 0000 to 2025-05-01 1200"
-                + "\n- 2025-05-01 1300 to 2025-05-01 2300";
+                + "\n- 2025-05-01 1300 to 2025-05-02 0000";
 
         assertCommandSuccess(freeCommand, model, expectedMessage, model);
     }
@@ -87,7 +87,55 @@ public void execute_freeSlotAfterLastReservation_showsLateSlot() {
         FreeCommand freeCommand = new FreeCommand(new DateTime(TEST_DATE.toString()));
         String expectedMessage = "Available free time slots:"
                 + "\n- 2025-05-01 0000 to 2025-05-01 0800"
-                + "\n- 2025-05-01 0900 to 2025-05-01 2300";
+                + "\n- 2025-05-01 0900 to 2025-05-02 0000";
+
+        assertCommandSuccess(freeCommand, model, expectedMessage, model);
+    }
+
+    @Test
+    public void execute_singleReservationAtStartOfDay_showsCorrectSlots() {
+        Reservation r1 = new ReservationBuilder()
+                .withDateTime(TEST_DATE.value.format(FORMATTER)) // Exactly at start of day
+                .build();
+        model.addReservation(r1);
+
+        FreeCommand freeCommand = new FreeCommand(new DateTime(TEST_DATE.toString()));
+        String expectedMessage = "Available free time slots:"
+                + "\n- 2025-05-01 0100 to 2025-05-02 0000";
+
+        assertCommandSuccess(freeCommand, model, expectedMessage, model);
+    }
+
+    @Test
+    public void execute_singleReservationAtEndOfDay_showsCorrectSlots() {
+        Reservation r1 = new ReservationBuilder()
+                .withDateTime(TEST_DATE.value.plusHours(23).format(FORMATTER)) // Last hour of day
+                .build();
+        model.addReservation(r1);
+
+        FreeCommand freeCommand = new FreeCommand(new DateTime(TEST_DATE.toString()));
+        String expectedMessage = "Available free time slots:"
+                + "\n- 2025-05-01 0000 to 2025-05-01 2300";
+
+        assertCommandSuccess(freeCommand, model, expectedMessage, model);
+    }
+
+    @Test
+    public void execute_consecutiveReservations_showsSingleGap() {
+        // 10-11 and 11-12 (should show as one continuous free slot after)
+        Reservation r1 = new ReservationBuilder()
+                .withDateTime(TEST_DATE.value.plusHours(10).format(FORMATTER))
+                .build();
+        Reservation r2 = new ReservationBuilder()
+                .withDateTime(TEST_DATE.value.plusHours(11).format(FORMATTER))
+                .build();
+        model.addReservation(r1);
+        model.addReservation(r2);
+
+        FreeCommand freeCommand = new FreeCommand(new DateTime(TEST_DATE.toString()));
+        String expectedMessage = "Available free time slots:"
+                + "\n- 2025-05-01 0000 to 2025-05-01 1000"
+                + "\n- 2025-05-01 1200 to 2025-05-02 0000";
 
         assertCommandSuccess(freeCommand, model, expectedMessage, model);
     }

src/test/java/seedu/reserve/logic/parser/FreeCommandParserTest.java

@@ -5,13 +5,19 @@
 import static seedu.reserve.logic.parser.CommandParserTestUtil.assertParseFailure;
 import static seedu.reserve.logic.parser.CommandParserTestUtil.assertParseSuccess;
 
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+
 import org.junit.jupiter.api.Test;
 
 import seedu.reserve.logic.Messages;
 import seedu.reserve.logic.commands.FreeCommand;
 import seedu.reserve.model.reservation.DateTime;
 
 public class FreeCommandParserTest {
+    private static final DateTimeFormatter FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd");
+
     private FreeCommandParser parser = new FreeCommandParser();
 
     @Test
@@ -47,6 +53,49 @@ public void parse_invalidArgs_throwsParseException() {
                 String.format(MESSAGE_INVALID_COMMAND_FORMAT, FreeCommand.MESSAGE_USAGE));
     }
 
+    @Test
+    public void parse_whitespaceOnly_throwsParseException() {
+        // Various whitespace patterns
+        assertParseFailure(parser, "   ",
+                String.format(MESSAGE_INVALID_COMMAND_FORMAT, FreeCommand.MESSAGE_USAGE));
+
+        assertParseFailure(parser, " d/    ",
+                DateTime.MESSAGE_CONSTRAINTS_FREE);
+    }
+
+    @Test
+    public void parse_withExplicitTime_throwsParseException() {
+        // Should reject if time is explicitly specified
+        assertParseFailure(parser, " d/2025-05-01 1200",
+                DateTime.MESSAGE_CONSTRAINTS_FREE);
+
+        assertParseFailure(parser, " d/2025-05-01 0000",
+                DateTime.MESSAGE_CONSTRAINTS_FREE);
+    }
+
+    @Test
+    public void parse_caseInsensitivePrefix_validCommand() {
+        // Should work with different prefix cases
+        assertParseSuccess(parser, " D/2025-05-01",
+                new FreeCommand(new DateTime("2025-05-01 0000")));
+    }
+
+    @Test
+    public void parse_dateBeyond60Days_throwsParseException() {
+        LocalDateTime today = LocalDate.now().atStartOfDay();
+
+        String invalidDateStr = today.plusDays(61).format(FORMATTER);
+        String boundaryDateStr = today.plusDays(59).format(FORMATTER);
+
+        // Test invalid case (61 days)
+        assertParseFailure(parser, " d/" + invalidDateStr,
+                DateTime.MESSAGE_CONSTRAINTS_FREE);
+
+        // Test boundary case (60 days)
+        assertParseSuccess(parser, " d/" + boundaryDateStr,
+                new FreeCommand(new DateTime(boundaryDateStr + " 0000")));
+    }
+
     @Test
     public void parse_multipleDates_throwsParseException() {
         // Multiple dates