[Brian Chow] iP

src/main/java/Deadline.java

@@ -0,0 +1,20 @@
+import java.util.Scanner;
+import java.util.ArrayList;
+import java.util.Arrays;
+
+
+/**
+ * Represents a Deadline which is a subclass of Task
+ * Includes a dueDate attribute. Overrides toString() from Task
+ */
+public class Deadline extends Task {
+    private String dueDate;
+    public Deadline(String name, String time) {super(name); this.dueDate = time;}
+
+    /**
+     * @override
+     * @return String of Deadline task, eg [D][X] Deadline (by:XX)
+     */
+
+    public String toString() { return "[D]" + super.toString() + "(by:" + this.dueDate + ")"; }
+}

src/main/java/Duke.java

@@ -1,10 +1,40 @@
+import java.util.Scanner; //import Scanner
+import java.util.ArrayList; //import ArrayList
+import java.util.Arrays; //import Arrays
+
 public class Duke {
     public static void main(String[] args) {
         String logo = " ____        _        \n"
                 + "|  _ \\ _   _| | _____ \n"
                 + "| | | | | | | |/ / _ \\\n"
                 + "| |_| | |_| |   <  __/\n"
                 + "|____/ \\__,_|_|\\_\\___|\n";
-        System.out.println("Hello from\n" + logo);
+        String dukeGreeting = "Hello! I'm Duke \nWhat can I do for you?";
+        String endMessage = "Bye. Hope to see you again soon!";
+
+        System.out.println(dukeGreeting);
+        Scanner sc = new Scanner(System.in);
+        InputHandler inputHandler = new InputHandler();
+        boolean isChatEnded = false;
+        while (!isChatEnded) {
+            try {
+                String input = sc.nextLine();
+                isChatEnded = inputHandler.handleInput(input);
+            } catch (DukeException e) {
+                System.out.println(e.getMessage());
+            }
+        }
+        System.out.println(endMessage);
     }
+
+
 }
+
+
+
+
+
+
+
+
+

src/main/java/DukeException.java

@@ -0,0 +1,12 @@
+public class DukeException extends Exception{
+    private String errorMessage;
+    public DukeException (String errorMessage) {
+        this.errorMessage = errorMessage;
+    }
+
+    /**
+     * @override
+     * @return String errorMessage
+     */
+    public String getMessage() {return this.errorMessage;}
+}

src/main/java/Event.java

@@ -0,0 +1,18 @@
+import java.util.Scanner;
+import java.util.ArrayList;
+import java.util.Arrays;
+
+/**
+ * Represents a Event which is a subclass of Task
+ * Overrides toString() from Task
+ */
+public class Event extends Task {
+    private String dueDate;
+    public Event (String name, String time) { super(name); this.dueDate = time;}
+
+    /**
+     * @override
+     * @return String of Event task, eg: [E][X] Event
+     */
+    public String toString() { return "[E]" + super.toString() + "(at:" + this.dueDate + ")"; }
+}

src/main/java/InputHandler.java

@@ -0,0 +1,127 @@
+import java.util.ArrayList;
+import java.util.Arrays;
+
+/**
+ * Handles input in main in Duke.java. Receives String from Scanner in main
+ * Processes the input into 7 categories: Todo, Event, Deadline, list, mark, unmark, bye and throws error
+ */
+public class InputHandler {
+    private ArrayList<Task> arr;
+    public InputHandler() {
+        this.arr = new ArrayList<>();
+    }
+
+
+    /**
+     *
+     * @param input String input from main in Duke.java, from user input
+     * @return boolean representing isChatEnded variable in main. If "bye" command is given, a true boolean is returned, else false is returned
+     * @throws DukeException Invalid input types, or unrecognisable commands
+     */
+    public boolean handleInput(String input) throws DukeException {
+        String[] splitInput = input.split(" ");
+        String inputCommand = splitInput[0];
+        switch (inputCommand) {
+            case "todo":
+                if (splitInput.length > 1) {
+                    String[] nameArray = Arrays.copyOfRange(splitInput, 1, splitInput.length);
+                    String name = String.join(" ", nameArray);
+                    Todo newTodo = new Todo(name);
+                    arr.add(newTodo);
+                    printAddTaskMessage(newTodo);
+                    return false;
+                } else {
+                    throw new DukeException(":( OOPS!!! The description of a todo cannot be empty. Correct usage: todo [task]");
+                }
+            case "event":
+                if (splitInput.length > 3) {
+                    String[] stringArrayExcludingEvent = Arrays.copyOfRange(splitInput, 1, splitInput.length);
+                    String stringExcludingEvent = String.join(" ", stringArrayExcludingEvent);
+                    String[] nameAndTimeArray = stringExcludingEvent.split("/at");
+                    String name = nameAndTimeArray[0];
+                    String time = nameAndTimeArray[1];
+                    Event newEvent = new Event(name, time);
+                    arr.add(newEvent);
+                    printAddTaskMessage(newEvent);
+                    return false;
+                } else {
+                    throw new DukeException(":( OOPS!!! The description of a event cannot be empty. Correct usage: event [task] /at [time]");
+                }
+            case "deadline":
+                if (splitInput.length > 3) {
+                    String[] stringArrayExcludingDeadline = Arrays.copyOfRange(splitInput, 1, splitInput.length);
+                    String stringExcludingDeadline = String.join(" ", stringArrayExcludingDeadline);
+                    String[] nameAndTimeArray = stringExcludingDeadline.split("/by");
+                    String name = nameAndTimeArray[0];
+                    String time = nameAndTimeArray[1];
+                    Deadline newDeadline = new Deadline(name, time);
+                    arr.add(newDeadline);
+                    printAddTaskMessage(newDeadline);
+                    return false;
+                } else {
+                    throw new DukeException(":( OOPS!!! The description of a deadline cannot be empty. Correct usage: deadline [task] /by [time]");
+                }
+            case "list":
+                if (splitInput.length == 1) {
+                    System.out.println("Here are the tasks in your list:");
+                    int i = 0;
+                    for (Task item : arr) {
+                        i += 1;
+                        if (item.isMark()) {
+                            System.out.println(i + ". " + item);
+                        } else {
+                            System.out.println(i + ". " + item);
+                        }
+                    }
+                    return false;
+                } else {
+                    throw new DukeException("Wrong usage of list! Correct usage: list");
+                }
+            case "mark":
+                if (splitInput.length == 2) {
+                    System.out.println("Nice! I've marked this task as done:\n");
+                    int idx = Integer.parseInt(splitInput[1]) - 1;
+                    Task taskToBeMarked = arr.get(idx);
+                    taskToBeMarked.markTask();
+                    return false;
+                } else {
+                    throw new DukeException("Wrong usage of mark! Correct usage: mark [index]");
+                }
+            case "unmark":
+                if (splitInput.length == 2) {
+                    System.out.println("OK, I've marked this task as not done yet:\n");
+                    int idx = Integer.parseInt(splitInput[1]) - 1;
+                    Task taskToBeUnmarked = arr.get(idx);
+                    taskToBeUnmarked.unmarkTask();
+                    return false;
+                } else {
+                    throw new DukeException("Wrong usage of unmark! Correct usage: unmark [index]");
+                }
+            case "delete":
+                if (splitInput.length == 2) {
+                    int idx = Integer.parseInt(splitInput[1]) - 1;
+                    Task taskToBeDeleted = arr.get(idx);
+                    arr.remove(idx);
+                    System.out.println("Noted. I've removed this task:\n" + taskToBeDeleted + "\nNow you have " + arr.size() + " tasks in the list");
+                    return false;
+                } else {
+                    throw new DukeException("Wrong usage of delete! Correct usage: delete [index]");
+                }
+            case "bye":
+                return true;
+            default:
+                throw new DukeException(":( OOPS!!! I'm sorry, but I don't know what that means! Possible commands: todo [task], event [task] /at [time],"
+                + " deadline [task] /by [time], mark [index], unmark [index], delete [index], bye");
+        }
+
+    }
+
+    /**
+     * Prints out the task name that has been added as well as the number of tasks in the list
+     * @param task The task that has been added
+     */
+    public void printAddTaskMessage(Task task) {
+        System.out.println("Got it. I've added this task:\n" + task + "\nNow you have " + arr.size() + " tasks in the list." );
+    }
+}
+

src/main/java/Task.java

@@ -0,0 +1,60 @@
+import java.util.Scanner;
+import java.util.ArrayList;
+import java.util.Arrays;
+
+/**
+ * Represents a Task. Contains a Task constructor, two methods to mark and unmark tasks, toString() method as well as a isMark() method to check if Task is marked
+ */
+public class Task {
+    private boolean mark;
+    public String name;
+
+    /**
+     * Constructor
+     * @param name name of the task
+     */
+    public Task (String name) {
+        this.name = name;
+        this.mark = false;
+    }
+
+    /**
+     * markTask as done
+     */
+    public void markTask () {
+        String markedMessage = "Nice! I've marked this task as done:\n";
+        this.mark = true;
+        System.out.println(markedMessage + "  " + this);
+    }
+
+    /**
+     * unmarkTask
+     */
+    public void unmarkTask() {
+        String unmarkedMessage = "OK, I've marked this task as not done yet:\n";
+        this.mark = false;
+        System.out.println(unmarkedMessage + "  " + this);
+    }
+
+    /**
+     *
+     * @return boolean on whether task is marked
+     */
+    public boolean isMark() {
+        return this.mark;
+    }
+
+    /**
+     * @override
+     * @return String version of task, with marked and name. E.g. [X] Task
+     */
+    public String toString() {
+        if (this.mark) {
+            String marked = "[X] ";
+            return marked + this.name;
+        } else {
+            String unmarked = "[ ] ";
+            return unmarked + this.name;
+        }
+    }
+}

src/main/java/Todo.java

@@ -0,0 +1,23 @@
+import java.util.Scanner;
+import java.util.ArrayList;
+import java.util.Arrays;
+
+/**
+ * Represents a Todo which is a subclass of Task
+ * Includes a dueDate attribute. Overrides toString() from Task
+ */
+
+public class Todo extends Task {
+    public Todo (String name) {
+        super(name);
+    }
+
+    /**
+     * @override
+     * @return String of Todo task, eg: [T][X] Todo
+     */
+    public String toString() {
+        return "[T]" + super.toString();
+    }
+
+}