[ChangruHenryQian] iP

src/main/java/duke/Deadline.java

@@ -0,0 +1,30 @@
+package duke;
+
+import java.time.LocalDate;
+import java.time.format.DateTimeFormatter;
+import java.util.Locale;
+
+public class Deadline extends Task {
+    private LocalDate by;
+    public Deadline(String description, LocalDate by) {
+        super(description);
+        this.by = by;
+    }
+
+    public Deadline(String description, boolean isDone, LocalDate by) {
+        super(description, isDone);
+        this.by = by;
+    }
+
+    @Override
+    public String toString() {
+        return "[D]" + super.toString() + " (by: "
+                + this.by.format(DateTimeFormatter.ofPattern("MMM dd yyyy", Locale.ENGLISH)) + ")";
+    }
+
+    @Override
+    public String toTxt() {
+        return "D | " + super.toTxt()
+                + " | " + this.by.format(DateTimeFormatter.ofPattern("MMM dd yyyy", Locale.ENGLISH));
+    }
+}

src/main/java/duke/Duke.java

@@ -0,0 +1,43 @@
+package duke;
+
+import java.util.Scanner;
+
+import java.io.IOException;
+
+public class Duke {
+
+    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(), storage);
+        } catch (DukeException e) {
+            ui.printException(e);
+            tasks = new TaskList(storage);
+        } catch (IOException e) {
+            ui.printException(new DukeException("Unable to find storage file."));
+            tasks = new TaskList(storage);
+        }
+    }
+
+    public void run() {
+        Ui.welcomeMessage();
+        Scanner userInput = new Scanner(System.in);
+        while (true) {
+            String command = userInput.nextLine();
+            Parser p = new Parser(command, this.storage, this.tasks);
+            p.parse();
+            if (p.isEnd()) {
+                break;
+            }
+        }
+    }
+
+    public static void main(String[] args) {
+        new Duke("data/tasks.txt").run();
+    }
+}

src/main/java/duke/DukeException.java

@@ -0,0 +1,7 @@
+package duke;
+
+public class DukeException extends RuntimeException{
+    public DukeException(String message) {
+        super(message);
+    }
+}

src/main/java/duke/Event.java

@@ -0,0 +1,33 @@
+package duke;
+
+import java.time.LocalDate;
+import java.time.format.DateTimeFormatter;
+import java.util.Locale;
+
+public class Event extends Task{
+    private LocalDate startTime;
+    private LocalDate endTime;
+    public Event(String description, LocalDate startTime, LocalDate endTime) {
+        super(description);
+        this.startTime = startTime;
+        this.endTime = endTime;
+    }
+
+    public Event(String description, boolean isDone, LocalDate startTime, LocalDate endTime) {
+        super(description, isDone);
+        this.startTime = startTime;
+        this.endTime = endTime;
+    }
+
+    @Override
+    public String toString() {
+        return "[E]" + super.toString() + " (from: " + startTime.format(DateTimeFormatter.ofPattern("MMM dd yyyy", Locale.ENGLISH))
+                + " to: " + endTime.format(DateTimeFormatter.ofPattern("MMM dd yyyy", Locale.ENGLISH)) + ")";
+    }
+
+    @Override
+    public String toTxt() {
+        return "E | " + super.toTxt() + " | " + this.startTime.format(DateTimeFormatter.ofPattern("MMM dd yyyy", Locale.ENGLISH))
+                + " | " + this.endTime.format(DateTimeFormatter.ofPattern("MMM dd yyyy", Locale.ENGLISH));
+    }
+}

src/main/java/duke/Parser.java

@@ -0,0 +1,57 @@
+package duke;
+
+import java.time.LocalDate;
+
+public class Parser {
+    private String command;
+    private Storage storage;
+    private TaskList taskList;
+    private boolean isEnd = false;
+
+    public Parser(String command, Storage storage, TaskList taskList) {
+        this.command = command;
+        this.storage = storage;
+        this.taskList = taskList;
+    }
+
+    public void parse() {
+        try{
+            if (command.startsWith("list")) {
+                this.taskList.listTasks();
+            } else if (command.startsWith("mark")) {
+                this.taskList.markTask(Integer.valueOf(command.split(" ")[1]) - 1);
+            } else if (command.startsWith("todo")) {
+                if (command.split(" ", 2).length == 1) {
+                    throw new DukeException(" OOPS!!! The description of a todo cannot be empty.");
+                }
+                ToDo newToDo = new ToDo(command.split(" ", 2)[1]);
+                this.taskList.addTask(newToDo);
+            } else if (command.startsWith("deadline")) {
+                LocalDate deadline = LocalDate.parse(command.split(" /by ", 2)[1]);
+                String name = command.split(" /by ", 2)[0].split(" ", 2)[1];
+                Deadline newDeadline = new Deadline(name, deadline);
+                this.taskList.addTask(newDeadline);
+            } else if (command.startsWith("event")) {
+                LocalDate startTime = LocalDate.parse(command.split(" /from ", 2)[1]
+                        .split(" /to ", 2)[0]);
+                LocalDate endTime = LocalDate.parse(command.split(" /to ", 2)[1]);
+                String name = command.split(" /from ", 2)[0].split(" ", 2)[1];
+                Event newEvent = new Event(name, startTime, endTime);
+                this.taskList.addTask(newEvent);
+            } else if (command.startsWith("delete")) {
+                this.taskList.deleteTask(Integer.valueOf(command.split(" ")[1]) - 1);
+            } else if (command.startsWith("bye")) {
+                this.isEnd = true;
+                Ui.farewellMessage();
+            } else {
+                throw new DukeException(" OOPS!!! I'm sorry, but I don't know what that means :-(");
+            }
+        } catch (DukeException e) {
+            Ui.printException(e);
+        }
+    }
+
+    public boolean isEnd() {
+        return this.isEnd;
+    }
+}

src/main/java/duke/Storage.java

@@ -0,0 +1,83 @@
+package duke;
+
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+
+import java.util.Locale;
+import java.time.LocalDate;
+import java.time.format.DateTimeFormatter;
+
+import java.util.ArrayList;
+import java.util.Scanner;
+
+public class Storage {
+    private final String filePath;
+
+    public Storage(String filePath) {
+        this.filePath = filePath;
+    }
+
+    public ArrayList<Task> load() throws IOException {
+        File dir = new File("./data");
+        if (!dir.exists()) {
+            dir.mkdir();
+        }
+        File f = new File(filePath);
+        f.createNewFile();
+        Scanner s = new Scanner(f);
+        ArrayList<Task> tasks = new ArrayList<>();
+        while (s.hasNext()) {
+            tasks.add(addTask(s.nextLine()));
+        }
+        return tasks;
+    }
+
+    private Task addTask(String input) {
+        String taskType = input.split(" \\| ")[0];
+        boolean isComplete = input.split(" \\| ")[1].equals("1");
+        String description = input.split(" \\| ")[2];
+        if (taskType.equals("T")) {
+            return new ToDo(description, isComplete);
+        } else if (taskType.equals("D")) {
+            LocalDate d = LocalDate.parse(input.split(" \\| ")[3], DateTimeFormatter.ofPattern("MMM dd yyyy", Locale.ENGLISH));
+            return new Deadline(description, isComplete, d);
+        } else {
+            LocalDate start = LocalDate.parse(input.split(" \\| ")[3], DateTimeFormatter.ofPattern("MMM dd yyyy", Locale.ENGLISH));
+            LocalDate end = LocalDate.parse(input.split(" \\| ")[4], DateTimeFormatter.ofPattern("MMM dd yyyy", Locale.ENGLISH));
+            return new Event(description, isComplete, start, end);
+        }
+    }
+
+
+    public void addOneLineToFile(ArrayList<Task> list) throws DukeException {
+        try {
+            FileWriter fw = new FileWriter(filePath, true);
+            if (list.size() == 1) {
+                fw.write(list.get(0).toTxt());
+            } else {
+                fw.write("\n" + list.get(list.size() - 1).toTxt());
+            }
+            fw.close();
+        } catch (IOException e) {
+            throw new DukeException("Unable to write to file.");
+        }
+    }
+
+    public void rewriteFile(ArrayList<Task> list) throws DukeException {
+        try {
+            FileWriter fw = new FileWriter(filePath);
+            for (int i = 0; i < list.size(); i++) {
+                if (i == list.size() - 1) {
+                    fw.write(list.get(i).toTxt());
+                } else {
+                    fw.write(list.get(i).toTxt() + "\n");
+                }
+            }
+            fw.close();
+        } catch (IOException e) {
+            throw new DukeException("Unable to write to file.");
+        }
+    }
+}
+

src/main/java/duke/Task.java

@@ -0,0 +1,34 @@
+package duke;
+
+public class Task {
+    protected String description;
+    protected boolean isDone;
+
+    public Task(String description) {
+        this.description = description;
+        this.isDone = false;
+    }
+
+    public Task(String description, boolean isDone) {
+        this.description = description;
+        this.isDone = isDone;
+    }
+
+    public String getStatusIcon() {
+        return (isDone ? "X" : " "); // mark done task with X
+    }
+
+    public void markAsDone() {
+        this.isDone = true;
+    }
+
+    @Override
+    public String toString() {
+        return "[" + this.getStatusIcon() + "] " + this.description;
+    }
+
+    public String toTxt() {
+        return (this.isDone ? "1" : "0") + " | " + this.description;
+    }
+
+}

src/main/java/duke/TaskList.java

@@ -0,0 +1,44 @@
+package duke;
+
+import java.util.ArrayList;
+
+public class TaskList {
+    protected ArrayList<Task> tasks;
+    private Storage storage;
+
+    public TaskList(Storage storage) {
+        this.tasks = new ArrayList<>();
+        this.storage = storage;
+    }
+
+    public TaskList(ArrayList<Task> tasks, Storage storage) {
+        this.tasks = tasks;
+        this.storage = storage;
+    }
+
+    public boolean isEmpty() {
+        return tasks.isEmpty();
+    }
+    public void listTasks() {
+        Ui.listTasks(this.tasks);
+    }
+
+    public void addTask(Task t) {
+        this.tasks.add(t);
+        Ui.addTask(t, this.tasks);
+        this.storage.addOneLineToFile(this.tasks);
+    }
+
+    public void deleteTask(int num) {
+        Task re = tasks.remove(num);
+        this.storage.rewriteFile(tasks);
+        Ui.deleteTask(re, tasks);
+    }
+
+    public void markTask(int num) {
+        Task t = tasks.get(num);
+        t.markAsDone();
+        Ui.markTask(t);
+        this.storage.rewriteFile(tasks);
+    }
+}

src/main/java/duke/ToDo.java

@@ -0,0 +1,21 @@
+package duke;
+
+public class ToDo extends Task {
+    public ToDo(String description) {
+        super(description);
+    }
+
+    public ToDo(String description, boolean isDone) {
+        super(description, isDone);
+    }
+
+    @Override
+    public String toString() {
+        return "[T]" + super.toString();
+    }
+
+    @Override
+    public String toTxt() {
+        return "T | " + super.toTxt();
+    }
+}