Branch j unit

src/main/java/Duke.java

@@ -1,10 +1,93 @@
+import java.text.ParseException;
+
 public class Duke {
+    private Storage storage;
+    private Parser parser;
+    private TaskList tasks;
+    private Ui ui;
+
+    public Duke() {
+        ui = new Ui();
+        storage = new Storage();
+        parser = new Parser();
+        tasks = new TaskList(storage.load());
+    }
+
+    public void run() {
+        ui.showWelcome();
+        String day;
+
+        String userInput = ui.readUserInput();
+
+        while(!userInput.equals("bye")) {
+            String[] firstBox = parser.firstFilter(userInput); // return a string array with commands and description
+            String commands = firstBox[0];
+            try {
+                switch (commands) {
+                    case "list":
+                        ui.showTaskList(tasks.getTaskList());
+                        break;
+
+                    case "done":
+                        tasks.runDone(userInput);
+                        storage.save();
+                        break;
+
+                    case "delete":
+                        tasks.runDelete(userInput);
+                        storage.save();
+                        break;
+
+                    case "find":
+                        tasks.runFind(userInput);
+                        break;
+
+                    case "todo":
+                        try {
+                            if (firstBox[1].isBlank()){
+                                throw new DukeException("☹ OOPS!!! The description of a todo cannot be empty.");
+                            }else {
+                                tasks.runToDo(firstBox[1]);
+                            }
+                        }catch(DukeException e) {
+                            e.printStackTrace();
+                        }finally{
+                            storage.save();
+                            break;
+                        }
+
+                    case "deadline":
+                        String[] secondBox = parser.secondFilter(firstBox[1] , "deadline");
+                        day = parser.dayExtractor(secondBox);
+                        String timeInString = parser.timeFormatter(secondBox[1].trim() , day);
+                        tasks.runDeadline(secondBox[0] , timeInString);
+                        storage.save();
+                        break;
+
+                    case "event":
+                        secondBox = parser.secondFilter(firstBox[1] , "event");
+                        timeInString = parser.timeFormatter(secondBox[1] , parser.dayExtractor(secondBox));
+                        tasks.runEvent(secondBox[0] , timeInString);
+                        storage.save();
+                        break;
+
+                    default:
+                        throw new DukeException("☹ OOPS!!! I'm sorry, but I don't know what that means :-(");
+                }
+
+
+            }catch(DukeException | ParseException e) {
+                e.printStackTrace();
+            }finally {
+                userInput = ui.readUserInput().trim();
+            }
+
+        }
+        ui.showExit();
+    }
+
     public static void main(String[] args) {
-        String logo = " ____        _        \n"
-                + "|  _ \\ _   _| | _____ \n"
-                + "| | | | | | | |/ / _ \\\n"
-                + "| |_| | |_| |   <  __/\n"
-                + "|____/ \\__,_|_|\\_\\___|\n";
-        System.out.println("Hello from\n" + logo);
+        new Duke().run();
+
     }
 }

src/main/java/DukeException.java

@@ -0,0 +1,6 @@
+public class DukeException extends Exception {
+    public DukeException(){}
+    public DukeException(String msg){
+        super(msg);
+    }
+}

src/main/java/Parser.java

@@ -0,0 +1,94 @@
+import duke.Deadline;
+import duke.Event;
+import duke.Task;
+import duke.ToDo;
+
+import java.text.DateFormat;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Date;
+
+public class Parser {
+    private static final String WHITESPACE = " ";
+
+    public void loadParse(ArrayList<Task> taskList , String input) {
+        String[] arr =  input.split(" \\| ");
+        String taskType = arr[0].trim();
+        String taskStatus = arr[1].trim();
+        String taskDescription = arr[2].trim();
+        String taskTime = "";
+
+        if (taskType.equals("T")) {
+            Task todo = new ToDo(taskDescription);
+            if (taskStatus.equals("\u2713")) {
+                todo.markAsDone();
+            }
+            taskList.add(todo);
+        }else if (taskType.equals("D")) {
+            taskTime = arr[3].trim();
+            Task deadline = new Deadline(taskDescription , taskTime);
+            if (taskStatus.equals("\u2713")) {
+                deadline.markAsDone();
+            }
+            taskList.add(deadline);
+        }else {
+            taskTime = arr[3].trim();
+            Task event = new Event(taskDescription , taskTime);
+            if (taskStatus.equals("\u2713")) {
+                event.markAsDone();
+            }
+            taskList.add(event);
+        }
+    }
+
+    public String dayExtractor(String[] secondBox) {
+        String day = secondBox[1].trim().split("/")[0];
+        return day;
+    }
+
+    public String timeFormatter(String dateInString , String day) throws ParseException {
+        DateFormat parser = new SimpleDateFormat("dd/M/yyyy HHmm");
+        DateFormat stFormatter = new SimpleDateFormat("d'st of' MMMM yyyy , ha");
+        DateFormat ndFormatter = new SimpleDateFormat("d'nd of' MMMM yyyy , ha");
+        DateFormat rdFormatter = new SimpleDateFormat("d'rd of' MMMM yyyy , ha");
+        DateFormat thFormatter = new SimpleDateFormat("d'th of' MMMM yyyy , ha");
+
+        String output;
+
+        Date convertedDate = parser.parse(dateInString);
+        if (day.equals("1")){
+            output = stFormatter.format(convertedDate);
+        }else if (day.equals("2")) {
+            output = ndFormatter.format(convertedDate);
+        }else if (day.equals("3")) {
+            output = rdFormatter.format(convertedDate);
+        }else{
+            output = thFormatter.format(convertedDate);
+        }
+        return output;
+    }
+
+    public String[] firstFilter(String userInput) {
+        String[] filter = userInput.split(" ");
+        String firstWord = filter[0];
+        StringBuilder str = new StringBuilder();
+        for (int i = 1 ; i < filter.length ; i++) {
+            str.append(filter[i]);
+            str.append(WHITESPACE);
+        }
+        String[] result = {firstWord , str.toString().trim()};
+
+        return result;
+    }
+
+    public String[] secondFilter(String newString , String firstWord) {
+        String[] filter;
+        if (firstWord.equals("deadline")) {
+            filter = newString.split(" /by ");
+        }else{
+            filter = newString.split(" /at ");
+        }
+        return filter;
+    }
+}

src/main/java/Storage.java

@@ -0,0 +1,96 @@
+import duke.Task;
+
+import java.io.*;
+import java.util.ArrayList;
+
+public class Storage {
+
+    private ArrayList<Task> taskList = new ArrayList<>();
+    Parser parser = new Parser();
+
+    public ArrayList<Task> load() {
+        File file = new File("/Users/qianjie/Desktop/duke/src/main/java/data/duke.txt");
+        FileReader fileReader = null;
+        BufferedReader bufferedReader = null;
+        try {
+            fileReader = new FileReader(file);
+            bufferedReader = new BufferedReader(fileReader);
+
+            String input = bufferedReader.readLine();
+
+            while (input != null) {
+                parser.loadParse(taskList , input);
+                input = bufferedReader.readLine();
+            }
+
+        } catch (FileNotFoundException e) {
+            e.printStackTrace();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }finally {
+            try {
+                if (fileReader != null) {
+                    fileReader.close();
+                }
+            }catch (IOException e) {
+                e.printStackTrace();
+            }
+            try {
+                if (bufferedReader != null) {
+                    bufferedReader.close();
+                }
+            }catch (IOException e) {
+                e.printStackTrace();
+            }
+            return taskList;
+
+        }
+    }
+
+    public void save () {
+        FileWriter fileWriter = null;
+        BufferedWriter bufferedWriter = null;
+        try{
+            File file = new File("/Users/qianjie/Desktop/duke/src/main/java/data/duke.txt");
+            fileWriter = new FileWriter(file , false);
+            bufferedWriter = new BufferedWriter(fileWriter);
+            for (Task t : taskList) {
+                String taskType = t.getType();
+                String taskStatus = t.getStatusIcon();
+                String taskDescription = t.getDescription();
+                String taskTime = t.getTime();
+
+                if (taskType.equals("T")) {
+                    bufferedWriter.write(taskType + " | " + taskStatus + " | " + taskDescription);
+                    bufferedWriter.newLine();
+
+                }else{
+                    bufferedWriter.write(taskType + " | " + taskStatus + " | " + taskDescription + " | " + taskTime);
+                    bufferedWriter.newLine();
+                }
+
+
+                bufferedWriter.flush();
+            }
+
+        } catch (IOException e) {
+            e.printStackTrace();
+        } finally {
+            try {
+                if (fileWriter != null) {
+                    fileWriter.close();
+                }
+            }catch (IOException e) {
+                e.printStackTrace();
+            }
+            try {
+                if (bufferedWriter != null) {
+                    bufferedWriter.close();
+                }
+            }catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+
+    }
+}

src/main/java/TaskList.java

@@ -0,0 +1,81 @@
+import duke.Deadline;
+import duke.Event;
+import duke.Task;
+import duke.ToDo;
+
+import java.util.ArrayList;
+
+public class TaskList {
+    public TaskList() {}
+    public TaskList(ArrayList<Task> taskList) {
+        this.taskList = taskList;
+    }
+
+    private ArrayList<Task> taskList = new ArrayList<>();
+    Ui ui = new Ui();
+    //Storage storage = new Storage();
+
+    public ArrayList<Task> getTaskList() {
+        return taskList;
+    }
+
+    public void runDone(String userInput) {
+        int index = Integer.parseInt(userInput.split(" ")[1]);
+        Task chosenTask = taskList.get(index - 1);
+        chosenTask.markAsDone();
+        ui.showDone(taskList , index);
+        //storage.save();
+    }
+
+    public void runDelete(String userInput) {
+        int index = Integer.parseInt(userInput.split(" ")[1]);
+        ui.showDelete(taskList , index);
+        taskList.remove(index - 1);
+        ui.showTaskListSize(taskList);
+        //storage.save();
+    }
+
+    public void runFind(String userInput) {
+        int index = 0 ;
+        ArrayList<Task> searchResults = new ArrayList<>();
+        String keyword = userInput.split(" ")[1];
+        for (Task task : taskList) {
+            String description = task.getDescription();
+            if (description.contains(keyword)) {
+                searchResults.add(task);
+            }
+        }
+        ui.showMatchTasks(searchResults , index);
+    }
+
+    public void runToDo(String description) {
+        Task toDoTask = new ToDo(description);
+        taskList.add(toDoTask);
+        ui.showAddTodoTask(taskList , toDoTask);
+        //storage.save();
+    }
+
+    public void runDeadline(String description , String time) {
+
+        Task deadlineTask = new Deadline(description , time);
+        taskList.add(deadlineTask);
+        ui.showAddDeadlineTask(taskList , deadlineTask);
+        //storage.save();
+    }
+
+    public void runEvent(String description , String time) {
+        Task eventTask = new Event(description , time);
+        taskList.add(eventTask);
+        ui.showAddEventTask(taskList , eventTask);
+        //storage.save();
+    }
+
+
+
+
+
+
+
+
+
+}