Merge pull request #11 from weixue123/branch-B-Reminders

Branch b reminders

Author: weixue123

data/test.txt

@@ -1,3 +1,3 @@
-T | 0 | CS2103 Quiz 1 | 
-D | 1 | BT4013 Quiz 2 | 2021-02-06 23:30
-E | 0 | CS2103 Quiz 3 | 2021-02-06 23:30
+T | 0 | CS2103 Quiz | 
+D | 0 | CS2103 Quiz | 2021-02-12 00:19
+E | 0 | CS2103 Quiz | 2021-02-12 00:19

src/main/java/duke/commands/ListCommand.java

@@ -16,7 +16,7 @@ public void execute(TaskList tasks) {
     }
 
     /**
-     * Returns false as searching for tasks should not terminate the application.
+     * Returns false as listing tasks should not terminate the application.
      *
      * @return false
      */

src/main/java/duke/commands/ReminderCommand.java

@@ -0,0 +1,128 @@
+package duke.commands;
+
+import duke.tasks.Deadline;
+import duke.tasks.Event;
+import duke.tasks.Task;
+import duke.tasks.TaskList;
+
+/**
+ * Handles the logic of generating reminders w.r.t. the tasks in the to-do list.
+ */
+public class ReminderCommand extends Command {
+    private final int urgencyDays;
+
+    /**
+     * Initializes a command to list out the overdue and urgent tasks in the to-do list.
+     *
+     * @param urgencyDays Number of days to use when determining if a <code>Deadline</code>
+     *                    or an <code>Event</code> is urgent.
+     */
+    public ReminderCommand(int urgencyDays) {
+        this.urgencyDays = urgencyDays;
+    }
+
+    /**
+     * Does nothing.
+     *
+     * @param tasks A collection of <code>Task</code> objects representing the application's state.
+     */
+    public void execute(TaskList tasks) {
+    }
+
+    /**
+     * Returns false as listing reminders should not terminate the application.
+     *
+     * @return false
+     */
+    public boolean isExit() {
+        return false;
+    }
+
+    /**
+     * Creates a response to display the existing tasks to the users. The output will
+     * take the form of a multi-line string, with each row displaying one task with its
+     * index, description and status.
+     *
+     * @param tasks A collection of <code>Task</code> objects representing the application's state.
+     * @return A <code>String</code> displaying the existing tasks.
+     */
+    public String getResponse(TaskList tasks) {
+        return this.getOverdueTasksResponse(tasks) + "\n" + this.getUrgentTasksResponse(tasks, this.urgencyDays);
+    }
+
+    private String getOverdueTasksResponse(TaskList tasks) {
+        TaskList overdueTasks = this.getOverdueTasks(tasks);
+        int numOverdue = overdueTasks.getSize();
+
+        if (numOverdue == 0) {
+            return "You do not have any overdue tasks!\n";
+        } else {
+            return "Oh no... You have " + numOverdue + " overdue task(s):\n" + overdueTasks.getTaskListAsString();
+        }
+    }
+
+    private String getUrgentTasksResponse(TaskList tasks, int urgencyDays) {
+        TaskList urgentTasks = this.getUrgentTasks(tasks, urgencyDays);
+        int numUrgent = urgentTasks.getSize();
+
+        if (numUrgent == 0) {
+            return "You do not have any urgent tasks!\n";
+        } else {
+            return "You have " + numUrgent + " task(s) that are due in less than " + urgencyDays + " day(s):\n"
+                    + urgentTasks.getTaskListAsString();
+        }
+    }
+
+    /**
+     * Obtains a <code>TaskList</code> of overdue tasks.
+     *
+     * @param tasks A collection of <code>Task</code> objects representing the application's state.
+     * @return A filtered <code>TaskList</code> comprising only the overdue tasks.
+     */
+    private TaskList getOverdueTasks(TaskList tasks) {
+        TaskList overdueTasks = new TaskList();
+
+        for (Task task : tasks.getListOfTasks()) {
+            boolean overdue = false;
+
+            if (task instanceof Event) {
+                overdue = ((Event) task).isOverdue();
+            } else if (task instanceof Deadline) {
+                overdue = ((Deadline) task).isOverdue();
+            }
+
+            if (overdue) {
+                overdueTasks.addTask(task);
+            }
+        }
+
+        return overdueTasks;
+    }
+
+    /**
+     * Obtains a <code>TaskList</code> of urgent tasks.
+     *
+     * @param tasks A collection of <code>Task</code> objects representing the application's state.
+     * @return A filtered <code>TaskList</code> comprising only the urgent tasks.
+     */
+    private TaskList getUrgentTasks(TaskList tasks, int urgencyInDays) {
+        assert urgencyInDays > 0;
+        TaskList urgentTasks = new TaskList();
+
+        for (Task task : tasks.getListOfTasks()) {
+            boolean urgent = false;
+
+            if (task instanceof Event) {
+                urgent = ((Event) task).isUrgent(urgencyInDays);
+            } else if (task instanceof Deadline) {
+                urgent = ((Deadline) task).isUrgent(urgencyInDays);
+            }
+
+            if (urgent) {
+                urgentTasks.addTask(task);
+            }
+        }
+
+        return urgentTasks;
+    }
+}

src/main/java/duke/exceptions/InvalidUrgencyDaysException.java

@@ -0,0 +1,8 @@
+package duke.exceptions;
+
+public class InvalidUrgencyDaysException extends Exception {
+
+    public InvalidUrgencyDaysException() {
+        super("You need to input a positive integer to specify the urgency level :O");
+    }
+}

src/main/java/duke/tasks/Deadline.java

@@ -20,13 +20,22 @@ public Deadline(String description, LocalDateTime byDateTime) {
         this.byDateTime = byDateTime;
     }
 
+    /**
+     * Retrieves the task's deadline time.
+     *
+     * @return The task's deadline.
+     */
+    public LocalDateTime getByDateTime() {
+        return this.byDateTime;
+    }
+
     /**
      * Converts the task's deadline to a <code>String</code>.
      *
      * @return A formatted date string corresponding to the task's deadline.
      */
     public String getByDateTimeString() {
-        return this.byDateTime.format(DateTimeFormatter.ofPattern("uuuu-MM-dd HH:mm"));
+        return this.getByDateTime().format(DateTimeFormatter.ofPattern("uuuu-MM-dd HH:mm"));
     }
 
     /**
@@ -37,4 +46,33 @@ public String getByDateTimeString() {
     public String getStatusString() {
         return "[D]" + super.getStatusString() + " (by: " + this.getByDateTimeString() + ")";
     }
+
+    /**
+     * Determines if the <code>Deadline</code> is overdue.
+     *
+     * @return True if the deadline is later than the current time, and false otherwise.
+     */
+    public boolean isOverdue() {
+        if (this.isDone()) {
+            return false;
+        }
+
+        return LocalDateTime.now().isAfter(this.getByDateTime());
+    }
+
+    /**
+     * Determines if the <code>Deadline</code> is urgent.
+     *
+     * @param urgencyInDays Number of days to use when determining if the <code>Deadline</code>
+     *                      is urgent.
+     * @return True if the deadline is within <code>urgencyInDays</code> of the current time.
+     */
+    public boolean isUrgent(int urgencyInDays) {
+        if (this.isDone()) {
+            return false;
+        }
+
+        LocalDateTime urgencyMark = this.getByDateTime().minusDays(urgencyInDays);
+        return LocalDateTime.now().isAfter(urgencyMark) && !this.isOverdue();
+    }
 }

src/main/java/duke/tasks/Event.java

@@ -20,13 +20,22 @@ public Event(String description, LocalDateTime atDateTime) {
         this.atDateTime = atDateTime;
     }
 
+    /**
+     * Retrieves the event's time.
+     *
+     * @return The event's time.
+     */
+    public LocalDateTime getAtDateTime() {
+        return this.atDateTime;
+    }
+
     /**
      * Converts the event's time to a <code>String</code>.
      *
      * @return A formatted date string corresponding to the event's time.
      */
     public String getAtDateTimeString() {
-        return this.atDateTime.format(DateTimeFormatter.ofPattern("uuuu-MM-dd HH:mm"));
+        return this.getAtDateTime().format(DateTimeFormatter.ofPattern("uuuu-MM-dd HH:mm"));
     }
 
     /**
@@ -37,4 +46,33 @@ public String getAtDateTimeString() {
     public String getStatusString() {
         return "[E]" + super.getStatusString() + " (at: " + this.getAtDateTimeString() + ")";
     }
+
+    /**
+     * Determines if the <code>Event</code> is overdue.
+     *
+     * @return True if the deadline is later than the current time, and false otherwise.
+     */
+    public boolean isOverdue() {
+        if (this.isDone()) {
+            return false;
+        }
+
+        return LocalDateTime.now().isAfter(this.getAtDateTime());
+    }
+
+    /**
+     * Determines if the <code>Event</code> is urgent.
+     *
+     * @param urgencyInDays Number of days to use when determining if the <code>Deadline</code>
+     *                      is urgent.
+     * @return True if the deadline is within <code>urgencyInDays</code> of the current time.
+     */
+    public boolean isUrgent(int urgencyInDays) {
+        if (this.isDone()) {
+            return false;
+        }
+
+        LocalDateTime urgencyMark = this.getAtDateTime().minusDays(urgencyInDays);
+        return LocalDateTime.now().isAfter(urgencyMark) && !this.isOverdue();
+    }
 }

src/main/java/duke/ui/Parser.java

@@ -16,8 +16,10 @@
 import duke.commands.FindCommand;
 import duke.commands.InvalidInputCommand;
 import duke.commands.ListCommand;
+import duke.commands.ReminderCommand;
 import duke.exceptions.InvalidActionException;
 import duke.exceptions.InvalidDateTimeFormatException;
+import duke.exceptions.InvalidUrgencyDaysException;
 import duke.exceptions.MissingDeadlineException;
 import duke.exceptions.MissingDescriptionException;
 import duke.exceptions.MissingEventTimeException;
@@ -39,26 +41,27 @@ public class Parser {
     private static final String TODO = "TODO";
     private static final String DEADLINE = "DEADLINE";
     private static final String EVENT = "EVENT";
+    private static final String REMINDER = "REMINDER";
 
     private static final ArrayList<String> validActions =
-            new ArrayList<>(Arrays.asList(BYE, LIST, DONE, DELETE, FIND, TODO, DEADLINE, EVENT));
-
-    public static ArrayList<String> getValidActions() {
-        return validActions;
-    }
+            new ArrayList<>(Arrays.asList(BYE, LIST, DONE, DELETE, FIND, REMINDER, TODO, DEADLINE, EVENT));
 
     /**
      * Parses a line of raw user input, converting it into a <code>Command</code> object that
      * handles all of the application's logic. Accordingly, the output <code>Command</code> object
-     * will be used to (1) alter the application's state, (2) computes responses to the users, and
-     * (3) determine whether to terminate the application.
+     * will be used to:
+     * (1) alter the application's state
+     * (2) computes responses to the users
+     * (3) determine whether to terminate the application
      *
      * @param input A line of raw user input.
      * @return Returns a <code>Command</code> object which will be used to execute the desired responses.
      */
     public static Command parse(String input) {
+        // If the input is valid, getExceptionMessage will return null.
+        // If the input is invalid, getExceptionMessage will return an appropriate message to be displayed.
         String exceptionMessage = getExceptionMessage(input);
-        if (!exceptionMessage.equals("")) {
+        if (exceptionMessage != null) {
             return new InvalidInputCommand(exceptionMessage);
         }
 
@@ -76,6 +79,8 @@ public static Command parse(String input) {
             return new DoneCommand(Integer.parseInt(description));
         case DELETE:
             return new DeleteCommand(Integer.parseInt(description));
+        case REMINDER:
+            return new ReminderCommand(Integer.parseInt(description));
         case FIND:
             return new FindCommand(description);
         case TODO:
@@ -184,6 +189,13 @@ private static boolean isInteger(String str) {
         return true;
     }
 
+    private static boolean isPositiveInteger(String str) {
+        if (!isInteger(str)) {
+            return false;
+        }
+        return Integer.parseInt(str) > 0;
+    }
+
     /**
      * Converts an input date or datetime string into a <code>LocalDateTime</code> object.
      *
@@ -238,6 +250,10 @@ private static String getExceptionMessage(String input) {
                 throw new TaskNumberNotIntException();
             }
 
+            if (action.equals(REMINDER) && (!isPositiveInteger(description))) {
+                throw new InvalidUrgencyDaysException();
+            }
+
             if (action.equals(DEADLINE) && byDateTimeString.length() == 0) {
                 throw new MissingDeadlineException();
             }
@@ -259,10 +275,11 @@ private static String getExceptionMessage(String input) {
                 | TaskNumberNotIntException
                 | MissingDeadlineException
                 | MissingEventTimeException
-                | InvalidDateTimeFormatException e) {
+                | InvalidDateTimeFormatException
+                | InvalidUrgencyDaysException e) {
             return e.getMessage();
         }
 
-        return "";
+        return null;
     }
 }