[Chen Jiehan] Duke Increments

src/main/java/Command/AddCommand.java

@@ -0,0 +1,41 @@
+package Command;
+
+import Storage.Storage;
+import TaskList.TaskList;
+import TaskList.Task;
+import Ui.Ui;
+
+import java.io.IOException;
+
+public class AddCommand extends Command {
+
+    protected Task task;
+
+    public AddCommand(Task task) {
+        this.task = task;
+    }
+
+    /**
+     * execute the command of adding task
+     * @param taskList
+     * @param ui
+     * @param storage
+     * @throws IOException
+     */
+    @Override
+    public void execute(TaskList taskList, Ui ui, Storage storage) throws IOException {
+        taskList.addList(task);
+        ui.showAddedMessage(taskList, task);
+        storage.save(taskList);
+    }
+
+    /**
+     *
+     * @return boolean
+     *
+     */
+    @Override
+    public boolean isExit() {
+        return isExit;
+    }
+}

src/main/java/Command/ByeCommand.java

@@ -0,0 +1,20 @@
+package Command;
+
+import Storage.Storage;
+import TaskList.TaskList;
+import Ui.Ui;
+
+public class ByeCommand extends Command {
+
+    public ByeCommand() {}
+
+    @Override
+    public void execute(TaskList t, Ui ui, Storage storage) {
+        ui.showGoodbye();
+    }
+
+    @Override
+    public boolean isExit() {
+        return isExit;
+    }
+}

src/main/java/Command/Command.java

@@ -0,0 +1,18 @@
+package Command;
+
+import Storage.Storage;
+import TaskList.TaskList;
+import Ui.Ui;
+
+import java.io.IOException;
+
+public abstract class Command {
+
+    protected boolean isExit = false;
+
+    public Command() {}
+
+    public abstract void execute(TaskList t, Ui ui, Storage storage) throws IOException;
+
+    public abstract boolean isExit();
+}

src/main/java/Command/DeleteCommand.java

@@ -0,0 +1,39 @@
+package Command;
+
+import Storage.Storage;
+import TaskList.TaskList;
+import Ui.Ui;
+
+import java.io.IOException;
+
+public class DeleteCommand extends Command {
+
+    private int taskNo;
+
+    public DeleteCommand(int taskNo) {
+        this.taskNo = taskNo;
+    }
+
+    /**
+     * execute the command of deleting the task
+     * @param taskList
+     * @param ui
+     * @param storage
+     * @throws IOException
+     */
+    @Override
+    public void execute(TaskList taskList, Ui ui, Storage storage) throws IOException {
+        ui.showDeleteMessage(taskList, taskList.list.get(taskNo - 1));
+        taskList.delete(taskNo);
+        storage.save(taskList);
+    }
+
+    /**
+     * check if it is exited
+     * @return boolean
+     */
+    @Override
+    public boolean isExit() {
+        return isExit;
+    }
+}

src/main/java/Command/DoneCommand.java

@@ -0,0 +1,35 @@
+package Command;
+
+import Storage.Storage;
+import TaskList.TaskList;
+import Ui.Ui;
+
+import java.io.IOException;
+
+public class DoneCommand extends Command {
+
+    private int taskNo;
+
+    public DoneCommand(int taskNo) {
+        this.taskNo = taskNo;
+    }
+
+    /**
+     * execute the command of marking a task as done
+     * @param taskList
+     * @param ui
+     * @param storage
+     * @throws IOException
+     */
+    @Override
+    public void execute(TaskList taskList, Ui ui, Storage storage) throws IOException {
+        taskList.list.get(taskNo - 1).markAsDone();
+        ui.showDoneMessage(taskList.list.get(taskNo - 1));
+        storage.save(taskList);
+    }
+
+    @Override
+    public boolean isExit() {
+        return isExit;
+    }
+}

src/main/java/Command/FindCommand.java

@@ -0,0 +1,29 @@
+package Command;
+
+import Storage.Storage;
+import TaskList.TaskList;
+import Ui.Ui;
+import TaskList.Task;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Scanner;
+
+public class FindCommand extends Command{
+    private String word;
+
+    public FindCommand(String word) {
+        this.word = word;
+    }
+
+    @Override
+    public void execute(TaskList taskList, Ui ui, Storage storage) throws IOException {
+        ui.showFindMessage(taskList.contains(word));
+    }
+
+    @Override
+    public boolean isExit() {
+        return false;
+    }
+
+}

src/main/java/Command/ListCommand.java

@@ -0,0 +1,30 @@
+package Command;
+
+import Storage.Storage;
+import TaskList.TaskList;
+import Ui.Ui;
+
+import java.io.IOException;
+
+public class ListCommand extends Command {
+
+    public ListCommand() {
+    }
+
+    /**
+     * execute the command of listing out all the task
+     * @param taskList
+     * @param ui
+     * @param storage
+     * @throws IOException
+     */
+    @Override
+    public void execute(TaskList taskList, Ui ui, Storage storage) throws IOException {
+        ui.showListMessage(taskList);
+    }
+
+    @Override
+    public boolean isExit() {
+        return isExit;
+    }
+}

src/main/java/Duke.java

@@ -1,10 +1,59 @@
+import Command.Command;
+import Parser.Parser;
+import Storage.Storage;
+import TaskList.TaskList;
+import Ui.Ui;
+
+import java.io.IOException;
+
 public class Duke {
-    public static void main(String[] args) {
-        String logo = " ____        _        \n"
-                + "|  _ \\ _   _| | _____ \n"
-                + "| | | | | | | |/ / _ \\\n"
-                + "| |_| | |_| |   <  __/\n"
-                + "|____/ \\__,_|_|\\_\\___|\n";
-        System.out.println("Hello from\n" + logo);
+
+        private Storage storage;
+        private TaskList tasks;
+        private Ui ui;
+
+        public Duke(String filePath) {
+            ui = new Ui();
+            storage = new Storage(filePath);
+            try {
+                tasks = new TaskList(storage.load());
+            } catch (IOException e) {
+                ui.showLoadingError();
+                tasks = new TaskList();
+            }
+        }
+
+        public void run() {
+            ui.showWelcome();
+            boolean isExit = false;
+            while (!isExit) {
+                try {
+                    String fullCommand = ui.readCommand();
+                    ui.showLine(); // show the divider line ("_______")
+                    Command c = Parser.parse(fullCommand);
+                    c.execute(tasks, ui, storage);
+                    isExit = c.isExit();
+                } catch (IOException e) {
+                    ui.showError(e.getMessage());
+                } finally {
+                    ui.showLine();
+                }
+            }
+        }
+
+        public static void main(String[] args) {
+            new Duke("/Users/jhchen/Documents/GitHub/duke/src/main/java/duke.txt").run();
+        }
     }
-}
+
+
+
+
+
+
+
+
+
+
+
+

src/main/java/Duke/DukeException.java

@@ -0,0 +1,10 @@
+package Duke;
+
+public class DukeException extends Exception {
+    public DukeException(String s) {
+        super(s);
+    }
+
+    public DukeException() {
+    }
+}

src/main/java/Parser/Parser.java

@@ -0,0 +1,86 @@
+package Parser;
+
+import TaskList.Deadlines;
+import TaskList.Events;
+import TaskList.ToDos;
+import Command.Command;
+import Command.AddCommand;
+import Command.ByeCommand;
+import Command.DeleteCommand;
+import Command.DoneCommand;
+import Command.ListCommand;
+import Command.FindCommand;
+
+public class Parser {
+    public Parser() {}
+
+    /**
+     * Parse in the full command and return the command accordingly
+     * @param fullCommand
+     * @return Command
+     */
+    public static Command parse(String fullCommand) {
+        int i = fullCommand.indexOf(' ');
+        String first = getFirstWord(fullCommand);
+        switch (first) {
+            case "delete":
+                return new DeleteCommand(Integer.parseInt(fullCommand.substring(i + 1)));
+            case "done":
+                return new DoneCommand(Integer.parseInt(fullCommand.substring(i + 1)));
+            case "list":
+                return new ListCommand();
+            case "bye":
+                return new ByeCommand();
+            case "find":
+                return new FindCommand(fullCommand.substring((i + 1)));
+            case "todo":
+                if (fullCommand.length() == 4) {
+                    System.out.println("OOPS!!! The description of a todo cannot be empty.");
+                } else {
+                    ToDos taskTodo = new ToDos(fullCommand.substring(i + 1));
+                    taskTodo.setTaskType("T");
+                    return new AddCommand(taskTodo);
+                }
+            case "deadline":
+                int j = fullCommand.indexOf("/");
+                int k = fullCommand.indexOf(" ");
+
+                if (fullCommand.length() == 8) {
+                    System.out.println("OOPS!!! The description of a deadline cannot be empty.");
+                } else {
+                    Deadlines taskDeadline = new Deadlines(fullCommand.substring(k + 1, j - 1));
+                    taskDeadline.setTime(fullCommand.substring(j + 4));
+                    taskDeadline.setTaskType("D");
+                    return new AddCommand(taskDeadline);
+                }
+            case "event":
+                int p = fullCommand.indexOf("/");
+                int q = fullCommand.indexOf(" ");
+
+                if (fullCommand.length() == 5) {
+                    System.out.println("OOPS!!! The description of an event cannot be empty.");
+                } else {
+                    Events taskEvent = new Events(fullCommand.substring(q + 1, p - 1));
+                    taskEvent.setTime(fullCommand.substring(p + 4));
+                    taskEvent.setTaskType("E");
+                    return new AddCommand(taskEvent);
+                }
+            default:
+                System.out.println("OOPS!!! I'm sorry, but I don't know what that means :-()");
+                return null;
+        }
+    }
+
+    /**
+     * to get the first word in a string of input
+     * @param input
+     * @return  String
+     */
+        public static String getFirstWord(String input) {
+            if (input.indexOf(" ") > -1) {
+                return input.substring(0, input.indexOf(" "));
+            } else {
+                return input;
+            }
+        }
+    }