[Caesar Pang] Duke Increments

src/main/java/Deadline.java

@@ -0,0 +1,32 @@
+public class Deadline extends Task {
+
+    protected String by;
+
+    /**
+     * Constructor for Deadline task.
+     *
+     * @param description Deadline task to be added.
+     * @param by Date of the deadline task.
+     */
+    public Deadline(String description, String by) {
+        super(description);
+        this.by = by;
+    }
+
+    /**
+     * Method to give the string that is to be
+     * added to the list of tasks.
+     *
+     * @return Returns the string to be loaded into
+     * the file and printed out.
+     */
+    @Override
+    public String toString() {
+        String date = formatDate(by);
+        if (getIsCorrectFormat()) {
+            return "[D]" + super.toString() + description + " (by: " + date + ")";
+        } else {
+            return "Invalid date format!";
+        }
+    }
+}

src/main/java/Duke.java

@@ -1,10 +1,47 @@
+import java.io.IOException;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.util.ArrayList;
+import java.util.Scanner;
+
 public class Duke {
-    public static void main(String[] args) {
-        String logo = " ____        _        \n"
-                + "|  _ \\ _   _| | _____ \n"
-                + "| | | | | | | |/ / _ \\\n"
-                + "| |_| | |_| |   <  __/\n"
-                + "|____/ \\__,_|_|\\_\\___|\n";
-        System.out.println("Hello from\n" + logo);
+
+    private Storage storage;
+    private TaskList tasks;
+    private Ui ui;
+
+    /**
+     * Constructor for Duke that takes in a file to add text into.
+     *
+     * @param filepath File that the task is added to.
+     * @throws IOException If the named file exists but is a directory rather than a regular file,
+     * does not exist but cannot be created, or cannot be opened for any other reason.
+     */
+    public Duke(String filepath) throws IOException {
+        ui = new Ui();
+        storage = new Storage(filepath);
+        try {
+            tasks = new TaskList(storage.load());
+        } catch (DukeException | FileNotFoundException e) {
+            ui.showLoadingError();
+            tasks = new TaskList();
+        }
     }
+
+    /**
+     * Contains the methods to start the bot and
+     * start to take in inputs for the bot
+     */
+    public void run() {
+        ui.greeting();
+        ui.nextCommand();
+    }
+
+    /**
+     * Main method.
+     */
+    public static void main(String[] args) throws IOException{
+        new Duke("todo.txt").run();
+    }
+
 }

src/main/java/DukeException.java

@@ -0,0 +1,12 @@
+public class DukeException extends Exception {
+
+    /**
+     * Constructor for Duke Exceptions.
+     *
+     * @param message takes in the error and
+     * prints it out to the user.
+     */
+    public DukeException(String message) {
+        super(message);
+    }
+}

src/main/java/Event.java

@@ -0,0 +1,36 @@
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+public class Event extends Task {
+
+    protected String when;
+    protected boolean isValid;
+
+    /**
+     * Constructor for Event task.
+     *
+     * @param description Event task to be attended.
+     * @param when Date of the event.
+     */
+    public Event(String description, String when) {
+        super(description);
+        this.when = when;
+    }
+
+    /**
+     * Method to give the string that is to be
+     * added to the list of tasks.
+     *
+     * @return Returns the string to be loaded into
+     * the file and printed out.
+     */
+    @Override
+    public String toString() {
+        String date = formatDate(when);
+        if (getIsCorrectFormat()) {
+            return "[E]" + super.toString() + description + " (at: " + date + ")";
+        } else {
+            return "Invalid date format!";
+        }
+    }
+}

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,13 @@
+import java.util.Scanner;
+
+public class Parser {
+
+    Scanner sc = new Scanner(System.in);
+
+    /**
+     * Constructor for Parser class.
+     */
+    public Parser() {
+
+    }
+}

src/main/java/Storage.java

@@ -0,0 +1,135 @@
+import java.io.*;
+import java.io.BufferedReader;
+import java.util.ArrayList;
+import java.util.Scanner;
+
+public class Storage {
+    protected static ArrayList<Task> taskList = new ArrayList<Task>();
+    protected static String file = "todo.txt";
+
+    public Storage(String file) {
+
+    }
+
+    /**
+     * Adds tasks to the file.
+     *
+     * @param filepath File that the task is added to.
+     * @param textToAdd Tasks that needs to be added.
+     * @throws IOException If the named file exists but
+     * is a directory rather than a regular file,
+     * does not exist but cannot be created, or
+     * cannot be opened for any other reason.
+     */
+    public void addToFile(String filepath, String textToAdd) throws IOException {
+            FileWriter typer = new FileWriter(filepath, true);
+            typer.write(textToAdd + System.lineSeparator());
+            typer.close();
+    }
+
+    /**
+     * Writes task to a file.
+     * Can be used as a way to overwrite tasks in the file as well.
+     *
+     * @param filepath File that the task is added to.
+     * @param textToAdd Tasks that needs to be added.
+     * @throws IOException If the named file exists but
+     * is a directory rather than a regular file,
+     * does not exist but cannot be created, or
+     * cannot be opened for any other reason.
+     */
+    public void writeToFile(String filepath, String textToAdd) throws IOException {
+        FileWriter typer = new FileWriter(filepath);
+        typer.write(textToAdd);
+        typer.close();
+    }
+
+    /**
+     * Counts the number of tasks in the list.
+     *
+     * @param filename File that the tasks are in.
+     * @return Returns the number of tasks.
+     * @throws IOException If the named file exists but
+     * is a directory rather than a regular file,
+     * does not exist but cannot be created, or
+     * cannot be opened for any other reason.
+     */
+    public static int countLines(String filename) throws IOException {
+        try (InputStream inputs = new BufferedInputStream(new FileInputStream(filename))) {
+            byte[] characters = new byte[1024];
+            int readCharacters = inputs.read(characters);
+            if (readCharacters == -1) {
+                // no lines to read
+                return 0;
+            }
+            int count = 0;
+            while (readCharacters == 1024) {
+                for (int i = 0; i < 1024; ) {
+                    if (characters[i++] == '\n') {
+                        ++count;
+                    }
+                }
+                readCharacters = inputs.read(characters);
+            }
+            // count remaining characters
+            while (readCharacters != -1) {
+                for (int i = 0; i < readCharacters; ++i) {
+                    if (characters[i] == '\n') {
+                        ++count;
+                    }
+                }
+                readCharacters = inputs.read(characters);
+            }
+
+            return count == 0 ? 1 : count;
+        }
+    }
+
+    /**
+     * Loads the task into the tasklist
+     * in TaskList from the file.
+     *
+     * @return ArrayList that has been copied from the file.
+     * @throws IOException If the named file exists but is a directory rather than a regular file,
+     * does not exist but cannot be created, or cannot be opened for any other reason.
+     * @throws DukeException If there is nothing in the file to be loaded,
+     * this exception will be thrown.
+     */
+    public ArrayList<Task> load() throws IOException, DukeException {
+        File f = new File(file);
+        Scanner sc = new Scanner(f);
+        ArrayList<Task> tempList;
+        if (countLines(file) == 0) {
+            throw new DukeException("Woahsies wavy! There is nothing in this file!");
+        } else {
+            while (sc.hasNext()) {
+                String task = sc.nextLine();
+                int index = task.indexOf("[");
+                String taskType = task.substring(index + 1, index + 2);
+                int spaceIndex = task.indexOf(" ");
+                switch (taskType) {
+                    case "T":
+                        Task toDo = new Todo(task.substring(spaceIndex));
+                        taskList.add(toDo);
+                        break;
+                    case "D":
+                        int byIndex = task.indexOf("(");
+                        Task deadline = new Deadline(task.substring(spaceIndex, byIndex - 1),
+                                task.substring(byIndex + 4));
+                        taskList.add(deadline);
+                        break;
+                    case "E":
+                        int atIndex = task.indexOf("(");
+                        Task event = new Event(task.substring(spaceIndex, atIndex - 1),
+                                task.substring(atIndex + 4));
+                        taskList.add(event);
+                        break;
+                }
+            }
+            Ui.printIndent();
+            System.out.println("Your file has been loaded! :)");
+            tempList = new ArrayList<Task>(taskList);
+            return tempList;
+        }
+    }
+}