[Quek Sze Long] iP

.gitignore

@@ -15,3 +15,4 @@ bin/
 
 /text-ui-test/ACTUAL.txt
 text-ui-test/EXPECTED-UNIX.TXT
+data/duke.txt

src/main/java/duke/CommandType.java

@@ -0,0 +1,5 @@
+package duke;
+
+public enum CommandType {
+    EXIT, LIST, ADD_TASK, COMPLETE_TASK, DELETE_TASK, FIND_TASK
+}

src/main/java/duke/Deadline.java

@@ -0,0 +1,28 @@
+package duke;
+
+import java.time.LocalDate;
+import java.time.format.DateTimeFormatter;
+
+public class Deadline extends Task{
+    private LocalDate taskDate;
+    private DateTimeFormatter formatter = DateTimeFormatter.ofPattern("dd/MM/yyyy");
+
+    public Deadline(String taskName, LocalDate taskDate, boolean isDone) {
+        super(taskName, TaskType.DEADLINE, isDone);
+        this.taskDate = taskDate;
+    }
+
+    public Deadline(String taskName, LocalDate taskDate) {
+        this(taskName, taskDate, false);
+    }
+
+    @Override
+    public String toSaveFormat() {
+        return String.format("D, %d, %s, %s", isDone() ? 1 : 0, getTaskName(), taskDate);
+    }
+
+    @Override
+    public String toString() {
+        return String.format("[D]%s (by: %s)", super.toString(), taskDate.format(formatter));
+    }
+}

src/main/java/duke/Duke.java

@@ -0,0 +1,102 @@
+package duke;
+
+import java.util.Scanner;
+
+public class Duke {
+
+    private Ui ui;
+    private Storage storage;
+    private TaskList tasks;
+
+    public Duke(String filepath) {
+        ui = new Ui();
+        storage = new Storage(filepath);
+
+        try {
+            tasks = new TaskList(storage.load());
+            if (tasks.getSize() > 0) {
+                ui.printLoadTasks(tasks);
+            }
+        } catch (DukeException e) {
+            ui.printErrorMessage(e.getMessage());
+            tasks = new TaskList();
+        }
+    }
+
+    public void run() {
+        ui.printStartInteractionsMessage();
+
+        Scanner scanner = new Scanner(System.in);
+        String userInput;
+
+        do {
+            ui.printWaitingUserInput();
+            userInput = scanner.nextLine();
+
+            try {
+                executeCommand(userInput);
+            } catch (DukeException e) {
+                ui.printErrorMessage(e.getMessage());
+            }
+        // Duke will keep accepting user input until user inputs "bye",
+        // which will lead to executeCommand() exiting the program.
+        } while (true);
+    }
+
+    public static void main(String[] args) {
+        new Duke("data/duke.txt").run();
+    }
+
+    private void executeCommand(String userInput) throws DukeException {
+        // First, extract the command type inputted by the user.
+        // parseCommandType() will throw an UnsupportedOperationException if
+        // no valid command types was inputted by the user.
+        CommandType commandType = Parser.parseCommandType(userInput);
+
+        // Decide the action to take depending on command type given.
+        // parseNewTask() and parseTaskNum() will throw MissingInputException
+        // if no valid further input is entered by the user.
+        switch (commandType) {
+        case EXIT:
+            ui.printExitMessage();
+            System.exit(0);
+        case LIST:
+            ui.printTaskList(tasks);
+            break;
+        case ADD_TASK:
+            addNewTask(Parser.parseNewTask(userInput));
+            break;
+        case COMPLETE_TASK:
+            completeTask(Parser.parseTaskNum(userInput));
+            break;
+        case DELETE_TASK:
+            deleteTask(Parser.parseTaskNum(userInput));
+            break;
+        case FIND_TASK:
+            findTask(Parser.parseSearchSubject(userInput));
+            break;
+        }
+    }
+
+    private void addNewTask(Task newTask) {
+        tasks.addTask(newTask);
+        storage.saveTasks(tasks);
+        ui.printAddTask(tasks, newTask);
+    }
+
+    private void completeTask(int taskNum) {
+        tasks.completeTask(taskNum);
+        storage.saveTasks(tasks);
+        ui.printCompleteTask(tasks.getTask(taskNum));
+    }
+
+    private void deleteTask(int taskNum) {
+        Task deletedTask = tasks.deleteTask(taskNum);
+        storage.saveTasks(tasks);
+        ui.printDeleteTask(tasks, deletedTask);
+    }
+
+    private void findTask(String subject) {
+        ui.printTasksWithSubject(tasks, subject);
+    }
+}

src/main/java/duke/DukeException.java

@@ -0,0 +1,16 @@
+package duke;
+
+/**
+ * DukeException is the class that represents exceptions in the
+ * logic of the script components in Duke.
+ */
+public class DukeException extends Exception {
+    /**
+     * Class constructor.
+     *
+     * @param message the message describing the error that occurred.
+     */
+    public DukeException(String message) {
+        super(message);
+    }
+}

src/main/java/duke/Event.java

@@ -0,0 +1,28 @@
+package duke;
+
+import java.time.LocalDate;
+import java.time.format.DateTimeFormatter;
+
+public class Event extends Task {
+    private LocalDate taskDate;
+    private DateTimeFormatter formatter = DateTimeFormatter.ofPattern("dd LLLL yyyy");
+
+    public Event(String taskName, LocalDate taskDate, boolean isDone) {
+        super(taskName, TaskType.EVENT, isDone);
+        this.taskDate = taskDate;
+    }
+
+    public Event(String taskName, LocalDate taskDate) {
+        this(taskName, taskDate, false);
+    }
+
+    @Override
+    public String toSaveFormat() {
+        return String.format("E, %d, %s, %s", isDone() ? 1 : 0, getTaskName(), taskDate);
+    }
+
+    @Override
+    public String toString() {
+        return String.format("[E]%s (at: %s)", super.toString(), taskDate.format(formatter));
+    }
+}

src/main/java/duke/LoadingException.java

@@ -0,0 +1,7 @@
+package duke;
+
+public class LoadingException extends DukeException{
+    public LoadingException() {
+        super("An error with loading has occurred");
+    }
+}

src/main/java/duke/MissingInputException.java

@@ -0,0 +1,7 @@
+package duke;
+
+public class MissingInputException extends DukeException {
+    public MissingInputException(TaskType taskType) {
+        super("The description for " + taskType + " cannot be empty");
+    }
+}

src/main/java/duke/Parser.java

@@ -0,0 +1,112 @@
+package duke;
+
+import java.time.LocalDate;
+import java.util.Scanner;
+
+/**
+ * Parser is the class that deals with making sense of the user commands.
+ */
+public class Parser {
+
+    /**
+     * Returns type of command given in the specified user input.
+     *
+     * @param userInput the whole line of command from the user.
+     * @return the type of command requested.
+     * @throws UnsupportedOperationException  if the user entered a
+     *                command that is not recognized.
+     */
+    public static CommandType parseCommandType(String userInput)
+            throws UnsupportedOperationException {
+
+        Scanner userInputScanner = new Scanner(userInput);
+        String operation = userInputScanner.next();
+
+        switch (operation.toLowerCase()) {
+        case "bye":
+            return CommandType.EXIT;
+        case "list":
+            return CommandType.LIST;
+        case "done":
+            return CommandType.COMPLETE_TASK;
+        case "todo":
+            // Fallthrough
+        case "deadline":
+            // Fallthrough
+        case "event":
+            return CommandType.ADD_TASK;
+        case "delete":
+            return CommandType.DELETE_TASK;
+        case "find":
+            return CommandType.FIND_TASK;
+        default:
+            throw new UnsupportedOperationException();
+        }
+    }
+
+    /**
+     * Creates a new task based on the user's inputs.
+     * The user command given is expected to be "todo", "deadline"
+     * or "event".
+     *
+     * @param userInput the whole line of command from the user.
+     * @return the new task that was requested.
+     * @throws MissingInputException  if the user did not enter any
+     *                other task details after the command word.
+     */
+    public static Task parseNewTask(String userInput) throws MissingInputException {
+        Scanner userInputScanner = new Scanner((userInput));
+        TaskType taskType = null;
+        switch (userInputScanner.next().toLowerCase()) {
+        case "todo":
+            taskType = TaskType.TODO;
+            break;
+        case "deadline":
+            taskType = TaskType.DEADLINE;
+            break;
+        case "event":
+            taskType = TaskType.EVENT;
+            break;
+        default:
+            return null;    // Invalid input
+        }
+
+        if (!userInputScanner.hasNext()) {
+            throw new MissingInputException(taskType);
+        }
+
+        switch (taskType) {
+        case TODO:
+            return new ToDo(userInputScanner.nextLine().trim());
+        case DEADLINE:
+            userInputScanner.useDelimiter(" /by ");
+            return new Deadline(userInputScanner.next().trim(),
+                    LocalDate.parse(userInputScanner.next().trim()));
+        case EVENT:
+            userInputScanner.useDelimiter(" /at ");
+            return new Event(userInputScanner.next().trim(),
+                    LocalDate.parse(userInputScanner.next().trim()));
+        default:
+            return null;    // Error
+        }
+    }
+
+    /**
+     * Returns the task number specified in the user command.
+     * The user command given is expected to be "done" or "delete".
+     *
+     * @param userInput the whole line of command from the user.
+     * @return the number of the task to execute the command on.
+     */
+    public static int parseTaskNum(String userInput) {
+        Scanner userInputScanner = new Scanner(userInput);
+        userInputScanner.next();
+        return userInputScanner.nextInt();
+    }
+
+    public static String parseSearchSubject(String userInput) {
+        Scanner userInputScanner = new Scanner(userInput);
+        userInputScanner.next();
+        return userInputScanner.nextLine().trim();
+    }
+}