[Toh Zhen Yu, Nicholas] iP

.gitignore

@@ -15,3 +15,5 @@ bin/
 
 /text-ui-test/ACTUAL.txt
 text-ui-test/EXPECTED-UNIX.TXT
+
+*.ser

src/main/java/Deadline.java

@@ -0,0 +1,23 @@
+import java.time.LocalDate;
+
+/**
+ * Represents a task to be completed by a certain time
+ */
+public class Deadline extends Task {
+
+    /**
+     * @param description Task description
+     * @param date Deadline for the task
+     */
+    public Deadline(String description, LocalDate date) {
+        super(description, date);
+    }
+
+    /**
+     * @return String representation of the task
+     */
+    @Override
+    public String toString() {
+        return "[D]" + super.toString() + " (by: " + date.toString() + ")\n";
+    }
+}

src/main/java/Duke.java

@@ -1,10 +1,34 @@
+/**
+ * Main class for Duke program.
+ */
 public class Duke {
-    public static void main(String[] args) {
-        String logo = " ____        _        \n"
-                + "|  _ \\ _   _| | _____ \n"
-                + "| | | | | | | |/ / _ \\\n"
-                + "| |_| | |_| |   <  __/\n"
-                + "|____/ \\__,_|_|\\_\\___|\n";
-        System.out.println("Hello from\n" + logo);
+
+    /**
+     * Entry point of the duke program. Read from storage and creates a UI class instance.
+     * Serves as intermediate between the UI and parser.
+     * @param args
+     * @throws DukeException
+     */
+    public static void main(String[] args) throws DukeException {
+        TaskList tasks = Storage.read();
+        UI ui = new UI();
+        ui.welcome(tasks);
+        String input = ui.getInput();
+        Parser parser = new Parser(tasks);
+        while (!input.equals("bye")) {
+            try {
+                if (input.isEmpty()) {
+                    input = ui.getInput();
+                    continue;
+                }
+                parser.parse(input);
+            } catch (DukeException e) {
+                UI.print(e.getMessage() + "\n");
+            }
+
+            input = ui.getInput();
+        }
+        ui.bye();
     }
+
 }

src/main/java/DukeException.java

@@ -0,0 +1,12 @@
+/**
+ * An exception class used for errors caused by inappropriate user input. Displays a message.
+ */
+public class DukeException extends Exception {
+    /**
+     * Constructor for DukeException.
+     * @param msg the message to be displayed.
+     */
+    DukeException(String msg) {
+        super("☹ OOPS!!! " + msg);
+    }
+}

src/main/java/Event.java

@@ -0,0 +1,23 @@
+import java.time.LocalDate;
+
+/**
+ * Represents a task occurring at a certain time
+ */
+public class Event extends Task {
+
+    /**
+     * @param description Task description
+     * @param date Date of the event
+     */
+    public Event(String description, LocalDate date) {
+        super(description, date);
+    }
+
+    /**
+     * @return String representation of the task
+     */
+    @Override
+    public String toString() {
+        return "[E]" + super.toString() + " (at: " + date.toString() + ")\n";
+    }
+}

src/main/java/META-INF/MANIFEST.MF

@@ -0,0 +1,3 @@
+Manifest-Version: 1.0
+Main-Class: Duke
+

src/main/java/Parser.java

@@ -0,0 +1,95 @@
+import java.time.LocalDate;
+import java.time.format.DateTimeParseException;
+
+/**
+ * Class that handles user input
+ */
+public class Parser {
+    TaskList tasks;
+
+    /**
+     * @param tasks TaskList to use
+     */
+    public Parser(TaskList tasks) {
+        this.tasks = tasks;
+    }
+
+    /**
+     * Parses the user command
+     * @param input input from the user
+     * @throws DukeException
+     */
+    void parse(String input) throws DukeException {
+        String[] words = input.split(" ");
+        String command = words[0];
+        Task newTask;
+        String[] subst;
+        LocalDate date;
+        switch (command) {
+            case "list":
+                tasks.print_tasks();
+                break;
+            case "done":
+            case "delete":
+                int i = Integer.parseInt(words[1]) - 1;
+                Task task = tasks.get(i);
+                if (command.equals("done")) {
+                    tasks.setDone(i, true);
+                    UI.print("Nice! I've marked this task as done: \n" + task);
+                } else if (command.equals("delete")) {
+                    tasks.remove(i);
+                    UI.print("Noted. I've removed this task: \n" + task + tasks.numTasks());
+                }
+                break;
+            case "todo":
+                if (input.length() < 6) {
+                    throw new DukeException("The description of a todo cannot be empty.");
+                }
+                String text = input.substring(5);
+                newTask = new Todo(text);
+                tasks.addTask(newTask);
+                break;
+            case "deadline":
+                if (input.length() < 10) {
+                    throw new DukeException("The description of a deadline cannot be empty.");
+                }
+                subst = input.substring(9).split(" /by ");
+                if (subst.length < 2) {
+                    throw new DukeException("The due date must be specified.");
+                }
+                try {
+                    date = LocalDate.parse(subst[1]);
+                    newTask = new Deadline(subst[0], date);
+                    tasks.addTask(newTask);
+                } catch (DateTimeParseException e) {
+                    throw new DukeException(e.getMessage());
+                }
+                break;
+            case "event":
+                if (input.length() < 7) {
+                    throw new DukeException("The description of an event cannot be empty.");
+                }
+                subst = input.substring(6).split(" /at ");
+                if (subst.length < 2) {
+                    throw new DukeException("The event date must be specified.");
+                }
+                try {
+                    date = LocalDate.parse(subst[1]);
+                    newTask = new Event(subst[0], date);
+                    tasks.addTask(newTask);
+                } catch (DateTimeParseException e) {
+                    throw new DukeException(e.getMessage());
+                }
+                break;
+            case "find":
+                if (input.length() < 6) {
+                    throw new DukeException("Text to search for cannot be empty.");
+                }
+                tasks.find(input.substring(5));
+                break;
+            default:
+                throw new DukeException("I'm sorry, but I don't know what that means :-(");
+//                        break;
+        }
+    }
+}

src/main/java/Storage.java

@@ -0,0 +1,55 @@
+import java.io.*;
+import java.nio.file.Paths;
+
+/**
+ * Class that provides file storage utilities
+ */
+public class Storage {
+    public static final File storage_file = Paths.get("tasks.ser").toFile();
+
+    public Storage() {
+    }
+
+    /**
+     * Serializes a TaskList and writes it to file
+     * @param t tasklist to be stored
+     */
+    public static void store(TaskList t) {
+        try {
+            //noinspection ResultOfMethodCallIgnored
+            storage_file.createNewFile(); //creates file if it does not exist
+            FileOutputStream fileOut = new FileOutputStream(storage_file);
+            ObjectOutputStream out = new ObjectOutputStream(fileOut);
+            out.writeObject(t);
+            out.close();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * Reads a serialized TaskList
+     * @return tasklisk read from file
+     */
+    public static TaskList read() {
+        try {
+            TaskList t;
+            FileInputStream fileIn = new FileInputStream(storage_file);
+            ObjectInputStream in = new ObjectInputStream(fileIn);
+            t = (TaskList) in.readObject();
+            in.close();
+            fileIn.close();
+            t.loadMessage = "Successfully loaded from storage. " + t.numTasks();
+            return t;
+        } catch (FileNotFoundException i) {
+            return new TaskList();
+        } catch (IOException i) {
+            i.printStackTrace();
+            return new TaskList();
+        } catch (ClassNotFoundException c) {
+            System.out.println("Employee class not found");
+            c.printStackTrace();
+            return new TaskList();
+        }
+    }
+}

src/main/java/Task.java

@@ -0,0 +1,26 @@
+import java.time.LocalDate;
+
+/**
+ * Represents a task
+ */
+public class Task implements java.io.Serializable {
+    String text;
+    boolean done;
+    LocalDate date;
+
+    /**
+     * @param text Task description
+     * @param date Date of the task
+     */
+    public Task(String text, LocalDate date) {
+        this.text = text;
+        this.date = date;
+    }
+
+    /**
+     * @return String representation of the task
+     */
+    public String toString() {
+        return "[" + (done ? "✓" : "✗") + "] " + text;
+    }
+}