[Chan Jing Rong] Duke Increments

src/main/java/Deadline.java

@@ -0,0 +1,74 @@
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+
+import java.util.Date;
+
+/**
+ * Encapsulates a deadline to be stored in Duke.
+ */
+public class Deadline extends Task {
+    private String name;
+    private boolean done;
+    private Date by;
+    private SimpleDateFormat format = new SimpleDateFormat("dd/MM/yyyy kkmm");
+
+    /**
+     * Creates a Deadline object tagged with name, whether it is completed, and task deadline.
+     *
+     * @param name Name of event.
+     * @param by Deadline by when task is due.
+     */
+    public Deadline(String name, String by) {
+        super(name);
+        try {
+            this.by = format.parse(by);
+        } catch (ParseException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * Returns name of deadline.
+     *
+     * @return Name of deadline.
+     */
+    public String getName() {
+        return super.getName();
+    }
+
+    /**
+     * Returns "y" or "n" based on completion of deadline.
+     *
+     * @return String "y" or "n".
+     */
+    public String isDone() {
+        return super.isDone();
+    }
+
+    /**
+     * Returns deadline of task.
+     *
+     * @return Deadline of task in String format.
+     */
+    public String getBy() {
+        return format.format(by);
+    }
+
+    /**
+     * Marks deadline as done.
+     */
+    public void setDone() {
+        super.setDone();
+    }
+
+    /**
+     * Overrides the original toString method.
+     * Returns description of deadline as `[D][isDone] name (by: date)`.
+     *
+     * @return Formatted description of deadline.
+     */
+    @Override
+    public String toString() {
+        return String.format("[D]%s (by: %s)", super.toString(), format.format(by));
+    }
+}

src/main/java/Duke.java

@@ -1,10 +1,57 @@
+import java.io.FileNotFoundException;
+import java.io.IOException;
+
+/**
+ * Encapsulates a Duke object for the execution of the Duke program.
+ */
 public class Duke {
+
+    private Storage storage;
+    private TaskList tasks;
+    private Ui ui;
+
+    /**
+     * Creates a Duke object tagged with ui, storage and list of tasks.
+     *
+     * @param filePath path of file to be used as storage.
+     */
+    public Duke(String filePath) {
+        ui = new Ui();
+        try {
+            storage = new Storage(filePath);
+        } catch (FileNotFoundException e) {
+            ui.showError("filepath");
+            return;
+        }
+        try {
+            tasks = new TaskList(storage.load());
+        } catch (IOException e) {
+            ui.showError("load");
+            tasks = new TaskList();
+        }
+    }
+
+    /**
+     * Runs the Duke program.
+     */
+    public void run() {
+        ui.showWelcome();
+        boolean isExit = false;
+        while (!isExit) {
+            ui.execute(tasks);
+            isExit = ui.isExit();
+        }
+
+        try {
+            storage.store();
+        } catch (IOException e) {
+            ui.showError("store");
+        }
+
+        ui.exit();
+    }
+
     public static void main(String[] args) {
-        String logo = " ____        _        \n"
-                + "|  _ \\ _   _| | _____ \n"
-                + "| | | | | | | |/ / _ \\\n"
-                + "| |_| | |_| |   <  __/\n"
-                + "|____/ \\__,_|_|\\_\\___|\n";
-        System.out.println("Hello from\n" + logo);
+        new Duke("/Users/jingrong/duke/duke.txt").run();
     }
 }

src/main/java/Event.java

@@ -0,0 +1,69 @@
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+
+import java.util.Date;
+
+/**
+ * Encapsulates an event to be stored in Duke.
+ */
+public class Event extends Task {
+    private String name;
+    private boolean done;
+    private Date at;
+    private SimpleDateFormat format = new SimpleDateFormat("dd/MM/yyyy kkmm");
+
+    /**
+     * Creates an Event object tagged with name, whether it is completed, and event time.
+     *
+     * @param name Name of event.
+     * @param at Date of event.
+     */
+    public Event(String name, String at) {
+        super(name);
+        try {
+            this.at = format.parse(at);
+        } catch (ParseException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public String getName() {
+        return super.getName();
+    }
+
+    /**
+     * Returns "y" or "n" based on completion of event.
+     *
+     * @return String "y" or "n".
+     */
+    public String isDone() {
+        return super.isDone();
+    }
+
+    /**
+     * Returns date of event.
+     *
+     * @return Date of event in String format.
+     */
+    public String getAt() {
+        return format.format(at);
+    }
+
+    /**
+     * Marks event as done.
+     */
+    public void setDone() {
+        super.setDone();
+    }
+
+    /**
+     * Overrides the original toString method.
+     * Returns description of event as `[E][isDone] name (at: date)`.
+     *
+     * @return Formatted description of event.
+     */
+    @Override
+    public String toString() {
+        return String.format("[E]%s (at: %s)", super.toString(), format.format(at));
+    }
+}

src/main/java/Parser.java

@@ -0,0 +1,23 @@
+/**
+ * Encapsulates a parser used to understand user commands.
+ */
+public class Parser {
+    private String[] commands;
+
+    /**
+     * Creates a Parser object.
+     */
+    public Parser() {
+    }
+
+    /**
+     * Returns user commands parsed as a String array.
+     *
+     * @param command Command from user input.
+     * @return String array of split commands.
+     */
+    public String[] parse(String command) {
+        commands = command.split(" ");
+        return commands;
+    }
+}

src/main/java/Storage.java

@@ -0,0 +1,85 @@
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+
+import java.util.ArrayList;
+
+/**
+ * Encapsulates a Storage object to load and save tasks from and to file.
+ */
+public class Storage {
+    private String filePath;
+    private FileReader reader;
+    private BufferedReader bufferedReader;
+    private ArrayList<Task> tasks;
+
+    /**
+     * Creates a Storage object tagged with path of file, file reader, buffered reader, and list of tasks.
+     *
+     * @param filePath path of file for loading and saving of tasks.
+     * @throws FileNotFoundException If file is not found at specified location.
+     */
+    public Storage(String filePath) throws FileNotFoundException {
+        this.filePath = filePath;
+        this.reader = new FileReader(this.filePath);
+        this.bufferedReader = new BufferedReader(reader);
+        this.tasks = new ArrayList<>();
+    }
+
+    /**
+     * Returns ArrayList of tasks loaded from file.
+     *
+     * @return ArrayList of tasks.
+     * @throws IOException If tasks failed to be retrieved.
+     */
+    public ArrayList<Task> load() throws IOException {
+        String line = bufferedReader.readLine();
+        while (! (line == null)) {
+            String[] words = line.split(" , ");
+            Task task;
+            if (words[0].equals("T")) {
+                task = new Todo(words[2]);
+            } else if (words[0].equals("D")) {
+                task = new Deadline(words[2], words[3]);
+            } else {
+                task = new Event(words[2], words[3]);
+            }
+
+            if (words[1].equals("y")) {
+                task.setDone();
+            }
+
+            tasks.add(task);
+            line = bufferedReader.readLine();
+        }
+
+        return tasks;
+    }
+
+    /**
+     * Stores tasks in file.
+     *
+     * @throws IOException If tasks failed to be stored.
+     */
+    public void store() throws IOException {
+        FileWriter writer = new FileWriter(this.filePath, false);
+        BufferedWriter bufferedWriter = new BufferedWriter(writer);
+
+        for (Task item : tasks) {
+            if (item instanceof Todo) {
+                bufferedWriter.write(String.format("T , %s , %s", item.isDone(), item.getName()));
+            } else if (item instanceof Deadline) {
+                bufferedWriter.write(String.format("D , %s , %s , %s", item.isDone(), item.getName(), ((Deadline) item)
+                        .getBy()));
+            } else {
+                bufferedWriter.write(String.format("D , %s , %s , %s", item.isDone(), item.getName(), ((Event) item)
+                        .getAt()));
+            }
+            bufferedWriter.newLine();
+        }
+        bufferedWriter.close();
+    }
+}

src/main/java/Task.java

@@ -0,0 +1,57 @@
+/**
+ * Encapsulates a task to be stored in Duke.
+ */
+public abstract class Task {
+    private String name;
+    private boolean isDone;
+
+    /**
+     * Creates a Task object tagged with name and whether it is completed.
+     *
+     * @param name Name of task.
+     */
+    public Task(String name) {
+        this.name = name;
+        this.isDone = false;
+    }
+
+    /**
+     * Returns "y" or "n" based on completion of task.
+     *
+     * @return String "y" or "n".
+     */
+    public String isDone() {
+        if (isDone) {
+            return "y";
+        } else {
+            return "n";
+        }
+    }
+
+    /**
+     * Returns name of task.
+     *
+     * @return Name of task.
+     */
+    public String getName() {
+        return name;
+    }
+
+    /**
+     * Marks task as done.
+     */
+    public void setDone() {
+        isDone = true;
+    }
+
+    /**
+     * Overrides the original toString method.
+     * Returns description of task as `[isDone] name`.
+     *
+     * @return Formatted description of task.
+     */
+    @Override
+    public String toString() {
+        return String.format("[%s] %s", isDone(), name);
+    }
+}