[Wang Guanlin] iP

.gitignore

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

src/main/java/Deadline.java

@@ -0,0 +1,19 @@
+import java.time.LocalDate;
+import java.time.format.DateTimeFormatter;
+
+public class Deadline extends Task {
+
+    protected String by;
+    protected LocalDate date;
+
+    public Deadline(String description, String by) {
+        super(description);
+        this.by = by;
+        this.date = LocalDate.parse(by);
+    }
+
+    @Override
+    public String toString() {
+        return "[D]" + super.toString() + " (by: " + date.format(DateTimeFormatter.ofPattern("yyyy MM dd")) + ")";
+    }
+}

src/main/java/Duke.java

@@ -1,10 +1,66 @@
+import java.util.Scanner;
+import java.util.ArrayList;
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+
+/**
+ * This class encapsulates a Duke chat-bot.
+ */
 public class Duke {
-    public static void main(String[] args) {
-        String logo = " ____        _        \n"
-                + "|  _ \\ _   _| | _____ \n"
-                + "| | | | | | | |/ / _ \\\n"
-                + "| |_| | |_| |   <  __/\n"
-                + "|____/ \\__,_|_|\\_\\___|\n";
-        System.out.println("Hello from\n" + logo);
+    private static final int lv = 8;
+    private static final String[] features = {
+            "",
+            "Greet, Echo, Exit",
+            ", Add, List",
+            ", Mark as Done",
+            ", ToDos, Events, Deadlines",
+            ", Handle Errors",
+            ", Delete",
+            ", Save",
+            ", Dates and Times"
+    };
+    private static ArrayList<Task> taskArrayList = new ArrayList<>();
+    private static final String dukeFilePath = "./data/duke.txt";
+    private Storage storage;
+    private TaskList tasks;
+    private Ui ui;
+
+    public Duke(String dukeFilePath) {
+        ui = new Ui();
+        storage = new Storage(dukeFilePath);
+        try {
+            tasks = new TaskList(storage.load());
+        } catch (DukeException | IOException e) {
+            ui.showLoadingError();
+            tasks = new TaskList();
+        }
     }
-}
+
+    public void run() throws IOException {
+        ui.showWelcome();
+        boolean canExit = false;
+        // Scanner to read user inputs
+        Scanner scanner = new Scanner(System.in);
+
+        while (!canExit) {
+            String userInput = scanner.next();
+            try {
+                if (userInput.equals("bye")) { // user inputs "bye", set canExit to true and Exit
+                    canExit = true;
+                    String temp = tasks.listBeautify(taskArrayList);
+                    storage.overwriteFile(dukeFilePath, temp);
+                    ui.showGoodbye();
+                } else { // check first input
+                    ui.handleInput(scanner, userInput, tasks);
+                }
+            } catch (DukeException | IOException e) {
+                e.printStackTrace(); // print stack trace for e
+            }
+        }
+    }
+
+    public static void main(String[] args) throws IOException, DukeException {
+        new Duke("data/duke.txt").run();
+    }
+}

src/main/java/DukeException.java

@@ -0,0 +1,13 @@
+public class DukeException extends Exception {
+    private static String msg;
+
+    public DukeException(String errorMessage) {
+        super(errorMessage);
+        msg = errorMessage;
+    }
+
+    @Override
+    public String toString() {
+        return ("Oh No! I do not understand your input due to the following problem:\n" + msg);
+    }
+}

src/main/java/DukeParser.java

@@ -0,0 +1,106 @@
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Scanner;
+
+public class DukeParser {
+    private String filePath;
+
+    public DukeParser(String dukeFilePath) {
+        this.filePath = dukeFilePath;
+    }
+
+    /**
+     * This method copies the contents of the file from filePath and
+     * converts them into Task objects into the taskArrayList with the
+     * help of the parse() method.
+     *
+     * @return taskArrayList the ArrayList to copy the information to
+     * @throws IOException if filePath does not exist
+     */
+    public ArrayList<Task> copyFileContents() throws IOException {
+        File f = new File(this.filePath); // create a File for the given file path
+        Scanner s = new Scanner(f); // create a Scanner using the File as the source
+        StringBuilder targetBuilder = new StringBuilder();
+        while (s.hasNext()) {
+            targetBuilder.append(s.nextLine()).append("\n");
+        }
+
+        return parse(targetBuilder.toString());
+    }
+
+    /**
+     * This method parses the string copied from duke.txt and converts them into task objects
+     * into the taskArrayList.
+     *
+     * @param toParse the string to parse
+     * @return a taskArrayList made up of tasks
+     */
+    public static ArrayList<Task> parse(String toParse) {
+        ArrayList<Task> result = new ArrayList<>();
+        Scanner ps = new Scanner(toParse); // passes whole file into the scanner
+//        [[T][ ] 1, [E][ ] 2 (at: 2), [D][ ] 3 (by: 3)]
+        while (ps.hasNextLine()) {
+            String nLine = ps.nextLine(); // parse one line at a time
+            int ref = 3; // reference point
+            char taskType = nLine.charAt(ref);
+            boolean isDone = nLine.charAt(ref + 3) == 'X';
+            int strLength = nLine.length();
+            switch (taskType) {
+            case 'T':
+                String todoName = nLine.substring(ref + 5, strLength);
+                Task newestTodo = new ToDo(todoName);
+                if (isDone) {
+                    newestTodo.markAsDone();
+                }
+                result.add(newestTodo);
+                break;
+            case 'D':
+                String deadlineInfo = nLine.substring(ref + 5, strLength);
+                String[] arrD = deadlineInfo.split("\\(by: ", 2);
+                String deadlineName = arrD[0];
+                String deadlineReminder = arrD[1].substring(0, arrD[1].length() - 1);
+                deadlineReminder = parseDate(deadlineReminder);
+                Task newestDeadline = new Deadline(deadlineName, deadlineReminder);
+                result.add(newestDeadline);
+                if (isDone) {
+                    newestDeadline.markAsDone();
+                }
+                break;
+            case 'E':
+                String eventInfo = nLine.substring(ref + 5, strLength);
+                String[] arrE = eventInfo.split("\\(at: ", 2);
+                String eventName = arrE[0];
+                String eventReminder = arrE[1].substring(0, arrE[1].length() - 1);
+                eventReminder = parseDate(eventReminder);
+                Task newestEvent = new Event(eventName, eventReminder);
+                result.add(newestEvent);
+                if (isDone) {
+                    newestEvent.markAsDone();
+                }
+                break;
+            default:
+                System.out.println("Unknown input");
+                break;
+            }
+        }
+        System.out.println("result is: " + result);
+        return result;
+    }
+
+    /**
+     * Parses input string in the format "yyyy MM dd" and returns it in the format
+     * "YYYY-MM-DD".
+     *
+     * @param input string in format "MMM d yyyy"
+     * @return string in format "YYYY-MM-DD"
+     */
+    public static String parseDate(String input) {
+        String year = input.substring(0, 4);
+        String month = input.substring(5, 7);
+        String day = input.substring(8, 10);
+
+        return year + "-" + month + "-" + day;
+    }
+
+}

src/main/java/Event.java

@@ -0,0 +1,19 @@
+import java.time.LocalDate;
+import java.time.format.DateTimeFormatter;
+
+public class Event extends Task {
+
+    protected String at;
+    protected LocalDate date;
+
+    public Event(String description, String at) {
+        super(description);
+        this.at = at;
+        this.date = LocalDate.parse(at);
+    }
+
+    @Override
+    public String toString() {
+        return "[E]" + super.toString() + " (at: " + date.format(DateTimeFormatter.ofPattern("yyyy MM dd")) + ")";
+    }
+}

src/main/java/Storage.java

@@ -0,0 +1,59 @@
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.io.File;
+
+public class Storage {
+    private static ArrayList<Task> taskArrayList = new ArrayList<>();
+    private final String filePath;
+
+    public Storage(String dukeFilePath) {
+        this.filePath = dukeFilePath;
+    }
+
+    public ArrayList<Task> load() throws IOException {
+        // load the data from the hard disk for dukeFile
+        File dukeFile = new File(filePath);
+
+        // creates directory if it does not exist
+        if (dukeFile.mkdir()) {
+            System.out.println("folder: 'data/' has been created");
+        }
+        // creates file if it does not exist
+        if (dukeFile.createNewFile()) {
+            System.out.println("'duke.txt' has been created in the 'data/' folder ");
+        }
+
+        DukeParser p = new DukeParser(filePath);
+        return p.copyFileContents();
+    }
+
+    /**
+     * This method overwrites the file.
+     *
+     * @param filePath     the path to the file to append to
+     * @param textToAppend the text to append
+     * @throws IOException if filePath does not exist
+     */
+
+    public void overwriteFile(String filePath, String textToAppend) throws IOException {
+        FileWriter fw = new FileWriter(filePath, false); // create a FileWriter in append mode
+        fw.write(textToAppend);
+        fw.close();
+    }
+
+    /**
+     * This method appends to the file instead of overwrites.
+     *
+     * @param filePath     the path to the file to append to
+     * @param textToAppend the text to append
+     * @throws IOException if filePath does not exist
+     */
+
+    public void appendToFile(String filePath, String textToAppend) throws IOException {
+        FileWriter fw = new FileWriter(filePath, true); // create a FileWriter in append mode
+        fw.write(textToAppend);
+        fw.close();
+    }
+
+}

src/main/java/Task.java

@@ -0,0 +1,65 @@
+/**
+ * This class encapsulates a Task object.
+ */
+
+public class Task {
+    protected String description;
+    protected boolean isDone;
+    protected String taskType;
+    protected String reminder;
+
+    /**
+     * Creates a task with the specified description, isDone false by default.
+     *  @param description description of task
+     *
+     */
+    public Task(String description) {
+        this.description = description;
+        this.isDone = false;
+    }
+
+    /**
+     * Getter method for status using isDone
+     *
+     * @return an icon 'X' if complete, space if otherwise
+     */
+    public String getStatusIcon() {
+        return (isDone ? "X" : " "); // mark done task with X
+    }
+
+    /**
+     * Getter method for type of task using taskType.
+     *
+     * @return an icon representing the type of the task (T, D, E)
+     */
+    public String getTypeIcon() {
+        return (this.taskType == "todo" ? "T" :
+                this.taskType == "deadline" ? "D" :
+                        this.taskType == "event" ? "E" : "NONE");
+    }
+
+    /**
+     * Getter method for task reminder
+     *
+     * @return the string reminder for the task
+     */
+    public String getReminder() {
+        return this.reminder;
+    }
+
+    /**
+     * Setter method for isDone of a Task object
+     */
+    public void markAsDone() {
+        this.isDone = true;
+    }
+
+    /**
+     * Returns string representation of Task.
+     *
+     * @return string representation of Task
+     */
+    public String toString() {
+        return ("[" + getStatusIcon() + "]" + description);
+    }
+}