Added recurring tasks

.gitignore

@@ -16,3 +16,5 @@ bin/
 #data files from program
 /data.txt/
 data.txt
+/recurringData.txt/
+recurringData.txt

src/main/java/Duke.java

@@ -1,6 +1,7 @@
 import CustomExceptions.DukeException;
 import Enums.ExceptionType;
-import Enums.Tasktype;
+import Enums.RecurTaskType;
+import Enums.TaskType;
 import Model_Classes.*;
 import Operations.*;
 
@@ -15,7 +16,7 @@ public class Duke {
     private Storage storage;
     private TaskList taskList;
     private Parser parser;
-
+    private RecurHandler recurHandler;
     /**
      * Constructor of a Duke class. Creates all necessary objects and collections for Duke to run
      * Also loads the ArrayList of tasks from the data.txt file
@@ -26,22 +27,34 @@ public Duke() {
         storage = new Storage();
         parser = new Parser();
         try {
-            taskList = new TaskList(storage.loadFile());
+            taskList = new TaskList(storage.loadFile("data.txt"));
         } catch (DukeException e) {
             ui.showLoadError();
             ArrayList<Task> emptyList = new ArrayList<>();
             taskList = new TaskList(emptyList);
         }
+        recurHandler = new RecurHandler(taskList);
+        if (recurHandler.checkRecurrence(taskList)) {
+            ui.showChangeInTaskList();
+            taskList.list();
+        }
+
     }
 
     /**
      * Deals with the operation flow of Duke.
      */
     public void run() {
         boolean isExit = false;
+        boolean isExitRecur = false;
         while (!isExit) {
             String command = parser.getCommand();
-            Tasktype type = Tasktype.valueOf(command);
+            TaskType type;
+            try {
+                type = TaskType.valueOf(command);
+            } catch (IllegalArgumentException e) {
+                type = TaskType.others;
+            }
             switch (type) {
                 case list :
                     ui.showList();
@@ -51,12 +64,11 @@ public void run() {
                 case bye :
                     isExit = true;
                     try {
-                        storage.writeFile(taskList.currentList());
-                        ui.showBye();
+                        storage.writeFile(TaskList.currentList(), "data.txt");
                     } catch (DukeException e) {
                         ui.showWriteError();
-                        ui.showBye();
                     }
+                    ui.showBye();
                     break;
 
                 case done :
@@ -121,6 +133,38 @@ public void run() {
                     }
                     break;
 
+                case recur:
+                    ui.promptRecurringActions();
+                    while (!isExitRecur) {
+                        String temp = parser.getCommand();
+                        RecurTaskType recurType;
+                        try {
+                            recurType = RecurTaskType.valueOf(temp);
+                        } catch (IllegalArgumentException e) {
+                            recurType = RecurTaskType.others;
+                        }
+                        switch (recurType) {
+                            case list:
+                                recurHandler.listRecurring();
+                                break;
+                            case find:
+                                recurHandler.findRecurring(parser.getKey());
+                                break;
+                            case exit:
+                                isExitRecur = true;
+                                ui.showExit();
+                                break;
+                            case add:
+                                recurHandler.addBasedOnOperation();
+                                break;
+                            default:
+                                ui.showCommandError();
+                                break;
+                        }
+                    }
+                    isExitRecur = false;
+                    break;
+
                 default:
                     ui.showCommandError();
                     break;

src/main/java/Enums/RecurTaskType.java

@@ -0,0 +1,5 @@
+package Enums;
+
+public enum RecurTaskType {
+     list, find, others, add, exit
+}

src/main/java/Enums/RecurrenceScheduleType.java

@@ -0,0 +1,5 @@
+package Enums;
+
+public enum RecurrenceScheduleType {
+    day, week, month
+}

src/main/java/Enums/SaveType.java

@@ -0,0 +1,5 @@
+package Enums;
+
+public enum SaveType {
+    T, E, D, empty
+}

src/main/java/Enums/TaskType.java

@@ -0,0 +1,5 @@
+package Enums;
+
+public enum TaskType {
+    list, bye, find, done , delete, todo, deadline, other, event, recur, timer, snooze, others
+}

src/main/java/Model_Classes/Event.java

@@ -34,5 +34,4 @@ public Event(String description, Date at) {
     public String toString() {
         return "[E]" + super.toString() + " (on: " + at + ")";
     }
-
 }

src/main/java/Model_Classes/RecurringDeadline.java

@@ -0,0 +1,23 @@
+package Model_Classes;
+
+import java.util.Date;
+
+public class RecurringDeadline extends Deadline {
+    private String recurrence;
+    /**
+     * Constructor for the Deadline object.
+     * Takes in inputs for description and date/time the tasks should be done by.
+     *
+     * @param description Description of the task
+     * @param by          The time the tasks should be done by.
+     */
+    public RecurringDeadline(String description, Date by, String recurrence) {
+        super(description, by);
+        this.recurrence = recurrence;
+    }
+
+    @Override
+    public String toString() {
+        return super.toString() + " (R: " + recurrence + ")";
+    }
+}

src/main/java/Model_Classes/RecurringEvent.java

@@ -0,0 +1,23 @@
+package Model_Classes;
+
+import java.util.Date;
+
+public class RecurringEvent extends Event {
+    private String recurrence;
+    /**
+     * Constructor for Event object
+     * Takes in inputs for description of the event and the time the event occurs
+     *
+     * @param description Description of the event
+     * @param at          Time the event happens
+     */
+    public RecurringEvent(String description, Date at, String recurrence) {
+        super(description, at);
+        this.recurrence = recurrence;
+    }
+
+    @Override
+    public String toString() {
+        return super.toString() + " (R: " + recurrence + ")";
+    }
+}

src/main/java/Model_Classes/RecurringToDo.java

@@ -0,0 +1,19 @@
+package Model_Classes;
+
+public class RecurringToDo extends ToDo {
+    private String recurrence;
+    /**
+     * Constructor of the class. Takes in the description of the task
+     *
+     * @param description Description of the task.
+     */
+    public RecurringToDo(String description, String recurrence) {
+        super(description);
+        this.recurrence = recurrence;
+    }
+
+    @Override
+    public String toString() {
+        return super.toString() + " (R: " + recurrence + ")";
+    }
+}

src/main/java/Model_Classes/Task.java

@@ -1,11 +1,16 @@
 package Model_Classes;
 
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.Date;
+
 /**
  * Parent class for all other types of tasks
  */
 public class Task{
     private String description;
     private boolean isDone;
+    private String created;
 
     /**
      * Constructor for the task object. takes in the description of the task
@@ -14,6 +19,13 @@ public class Task{
     public Task(String description) {
         this.description = description;
         this.isDone = false;
+        DateTimeFormatter dateTimeFormatterNow = DateTimeFormatter.ofPattern("dd/MM/yyyy HH:mm");
+        LocalDateTime now = LocalDateTime.now();
+        this.created = now.format(dateTimeFormatterNow);
+    }
+
+    public String getCreated() {
+        return this.created;
     }
 
     /**
@@ -48,6 +60,10 @@ public void setDone() {
         isDone = true;
     }
 
+    public void setNotDone() {
+        isDone = false;
+    }
+
     /**
      * Returns both the status icon and the description of the task.
      * @return

src/main/java/Operations/Parser.java

@@ -87,4 +87,8 @@ public String getKey() {
         String key = scanner.nextLine().toLowerCase();
         return key;
     }
+
+    public String getRecurrence() {
+        return scanner.nextLine().trim().toLowerCase();
+    }
 }