[Sng Jia Ming Fadi Faris] Duke Increments

src/main/java/AddCommand.java

@@ -0,0 +1,54 @@
+/**
+ * Represents the command to add a task into the arraylist.
+ */
+
+import java.text.ParseException;
+
+public class AddCommand extends Command {
+    private String[] arr;
+
+    public AddCommand(String[] arr) {
+        this.arr = arr;
+    }
+
+    @Override
+    public void execute(TaskList tasks, Ui ui, Storage storage){
+        String description = "";
+        Task t;
+        String next = arr[0];
+        try {
+            if (next.equals("todo") || next.equals("deadline") || next.equals("event")) {
+                if (arr.length == 1) {
+                    throw new EmptyDescriptionException("☹ OOPS!!! The description of a " + next + " cannot be empty.");
+                } else {
+                    for (int i = 1; i < arr.length; i++) {
+                        description += " " + arr[i];
+                    }
+                }
+            } else {
+                throw new UnknownTaskException("☹ OOPS!!! I'm sorry, but I don't know what that means :-(");
+            }
+            System.out.println("Got it. I've added this task:");
+            if (next.equals("todo")) {
+                t = new Todos(description.trim());
+            } else if (next.equals("deadline")) {
+                int index = description.indexOf("/");
+                String byWhen = description.substring(index + 4);
+                String desc = description.substring(1, index - 1);
+                t = new Deadline(desc, byWhen);
+            } else {
+                int index = description.indexOf("/");
+                String at = description.substring(index + 4);
+                String desc = description.substring(1, index - 1);
+                t = new Event(desc, at);
+            }
+            tasks.getList().add(t);
+            ui.printTask(tasks.getList().size(), t);
+        } catch (DukeException e) {
+            System.out.println(e.getMessage());
+        } catch (ParseException e) {
+            System.out.println("Date in wrong format");
+        }
+        storage.writeFile(tasks.getList());
+    }
+}

src/main/java/Command.java

@@ -0,0 +1,15 @@
+/**
+ * Abstract class to represent the possible commands given to Duke.
+ */
+
+public abstract class Command {
+
+    /**
+     * Executes the different commands respectively.
+     * @param tasks Arraylist of tasks.
+     * @param ui User interaction that comes with the command.
+     * @param storage To deal with saving tasks into the file after executing the command.
+     */
+    public abstract void execute(TaskList tasks, Ui ui, Storage storage);
+
+}

src/main/java/Deadline.java

@@ -0,0 +1,41 @@
+/**
+ * Deadline class to represent a task with a date to be done by.
+ */
+
+import java.text.ParseException;
+import java.util.Date;
+import java.text.SimpleDateFormat;
+
+public class Deadline extends Task {
+
+    protected String by;
+    protected Date date;
+
+    public Deadline(String description, String by) throws ParseException {
+        super(description);
+        this.by = by;
+        this.date = new SimpleDateFormat("dd/MM/yyyy HHmm").parse(by);
+    }
+
+    public Deadline(String description, boolean isDone, String by) throws ParseException {
+        super(description, isDone);
+        this.by = by;
+        this.date = new SimpleDateFormat("dd/MM/yyyy HHmm").parse(by);
+    }
+
+    @Override
+    public String toString() {
+        SimpleDateFormat formatter = new SimpleDateFormat("d MMMM yyyy, hmma");
+        String formattedDate = formatter.format(this.date);
+        return "[D]" + super.toString() + " (by: " + formattedDate + ")";
+    }
+
+    @Override
+    public String print() {
+        if (this.isDone) {
+            return "D @ 1 @ " + this.description + " @ " + this.by;
+        } else {
+            return "D @ 0 @ " + this.description + " @ " + this.by;
+        }
+    }
+}

src/main/java/DeleteCommand.java

@@ -0,0 +1,19 @@
+/**
+ * Represents a command to remove a task from the arraylist.
+ */
+
+public class DeleteCommand extends Command {
+    private int taskNumber;
+
+    public DeleteCommand(int taskNumber) {
+        this.taskNumber = taskNumber;
+    }
+
+    @Override
+    public void execute(TaskList tasks, Ui ui, Storage storage) {
+        Task taskRemoved = tasks.getList().remove(taskNumber);
+        System.out.println("Noted. I've removed this task:");
+        ui.printTask(tasks.getList().size(), taskRemoved);
+        storage.writeFile(tasks.getList());
+    }
+}

src/main/java/DoneCommand.java

@@ -0,0 +1,35 @@
+/**
+ * Represents a command that ticks off a task.
+ */
+
+public class DoneCommand extends Command {
+    private int taskNumber;
+
+    public DoneCommand(int taskNumber) {
+        this.taskNumber = taskNumber;
+    }
+    @Override
+    public void execute(TaskList tasks, Ui ui, Storage storage) {
+        Task taskDone = tasks.getList().get(taskNumber);
+        taskDone.markAsDone();
+        System.out.println("Nice! I've marked this task as done:\n  " + taskDone);
+        storage.writeFile(tasks.getList());
+    }
+
+   public int getTaskNumber() {
+        return taskNumber;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == this) {
+            return true;
+        } else if (obj == null || obj.getClass() != this.getClass()) {
+            return false;
+        } else {
+            DoneCommand command = (DoneCommand) obj;
+            return taskNumber == command.getTaskNumber();
+        }
+
+    }
+}

src/main/java/Duke.java

@@ -1,10 +1,37 @@
+/**
+ * Main driving class for Duke.
+ */
+
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.text.ParseException;
+
 public class Duke {
+
+    private Storage storage;
+    private TaskList list;
+    private Ui ui;
+
+    public Duke(String file) {
+        ui = new Ui();
+        storage = new Storage(file);
+        list = new TaskList(storage.load());
+    }
+
+    public void run() {
+        ui.showWelcome();
+        boolean isExit = false;
+        while (!isExit) {
+            String fullCommand = ui.readCommand();
+            Command c = Parser.parse(fullCommand);
+            c.execute(list, ui, storage);
+            isExit = c instanceof ExitCommand;
+        }
+    }
+
+
     public static void main(String[] args) {
-        String logo = " ____        _        \n"
-                + "|  _ \\ _   _| | _____ \n"
-                + "| | | | | | | |/ / _ \\\n"
-                + "| |_| | |_| |   <  __/\n"
-                + "|____/ \\__,_|_|\\_\\___|\n";
-        System.out.println("Hello from\n" + logo);
+        Duke duke = new Duke("Duke_List.txt");
+        duke.run();
     }
-}
+}

src/main/java/DukeException.java

@@ -0,0 +1,9 @@
+/**
+ * Represents exceptions specific to Duke.
+ */
+
+public class DukeException extends Exception {
+    public DukeException(String message) {
+        super(message);
+    }
+}

src/main/java/Duke_List.txt

@@ -0,0 +1,2 @@
+D @ 1 @ art project @ 04/04/2009 1600
+T @ 1 @ borrow book

src/main/java/EmptyDescriptionException.java

@@ -0,0 +1,9 @@
+/**
+ * An exception that occurs when a task has no description.
+ */
+
+public class EmptyDescriptionException extends DukeException {
+    public EmptyDescriptionException(String message) {
+        super(message);
+    }
+}

src/main/java/Event.java

@@ -0,0 +1,40 @@
+/**
+ * Event class to represent a task that occurs on a certain date.
+ */
+
+import java.text.ParseException;
+import java.util.Date;
+import java.text.SimpleDateFormat;
+
+public class Event extends Task {
+    protected Date date;
+    protected String at;
+
+    public Event(String description, String at) throws ParseException {
+        super(description);
+        this.at = at;
+        this.date = new SimpleDateFormat("dd/MM/yyyy HHmm").parse(at);
+    }
+
+    public Event(String description, boolean isDone, String at) throws ParseException {
+        super(description, isDone);
+        this.at = at;
+        this.date = new SimpleDateFormat("dd/MM/yyyy HHmm").parse(at);
+    }
+
+    @Override
+    public String toString() {
+        SimpleDateFormat formatter = new SimpleDateFormat("d MMMM yyyy, hmma");
+        String formattedDate = formatter.format(this.date);
+        return "[E]" + super.toString() + " (at: " + formattedDate + ")";
+    }
+
+    @Override
+    public String print() {
+        if (this.isDone) {
+            return "E @ 1 @ " + this.description + " @ " + this.at;
+        } else {
+            return "E @ 0 @ " + this.description + " @ " + this.at;
+        }
+    }
+}

src/main/java/ExitCommand.java

@@ -0,0 +1,10 @@
+/**
+ * Represents the command for Duke to terminate.
+ */
+
+public class ExitCommand extends Command {
+    @Override
+    public void execute(TaskList tasks, Ui ui, Storage storage) {
+        System.out.println("Bye. Hope to see you again soon!");
+    }
+}

src/main/java/FindCommand.java

@@ -0,0 +1,24 @@
+import java.util.ArrayList;
+
+public class FindCommand extends Command {
+    private String description;
+
+    public FindCommand(String description) {
+        this.description = description;
+    }
+    @Override
+    public void execute(TaskList tasks, Ui ui, Storage storage) {
+        System.out.println("Here are the matching tasks in your list:");
+        ArrayList<Task> matchingTasks = new ArrayList<>();
+        int count = 1;
+        for (Task task : tasks.getList()) {
+            if (task.getDescription().contains(description)) {
+                matchingTasks.add(task);
+            }
+        }
+        for (Task task : matchingTasks) {
+            System.out.println(count + "." + task);
+            count++;
+        }
+    }
+}

src/main/java/ListCommand.java

@@ -0,0 +1,16 @@
+/**
+ * Represents a command to print out the tasks in the arraylist.
+ */
+
+public class ListCommand extends Command {
+
+    @Override
+    public void execute(TaskList tasks, Ui ui, Storage storage) {
+        System.out.println("Here are the tasks in your list:");
+        int listCount = 1;
+        for (Task task : tasks.getList()) {
+            System.out.println(listCount + "." + task);
+            listCount++;
+        }
+    }
+}

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,37 @@
+/**
+ * Parser class to handle user input.
+ */
+public class Parser {
+
+    /**
+     * Parses the input string and determines the type of command given.
+     * @param str The input string supplied to Duke.
+     * @return Returns the corresponding command depending on the first word of the input string.
+     */
+    public static Command parse(String str) {
+        String[] arr = str.split(" ");
+        String next = arr[0];
+        Command c;
+        switch (next) {
+        case "find":
+            c = new FindCommand(arr[1]);
+            break;
+        case "bye":
+            c = new ExitCommand();
+            break;
+        case "list":
+            c = new ListCommand();
+            break;
+        case "done":
+            c = new DoneCommand(Integer.parseInt(arr[1]) - 1);
+            break;
+        case "delete":
+            c = new DeleteCommand(Integer.parseInt(arr[1]) - 1);
+            break;
+        default:
+            c = new AddCommand(arr);
+            break;
+            }
+            return c;
+    }
+}