[Wang Haochen] iP

src/main/java/META-INF/MANIFEST.MF

@@ -0,0 +1,3 @@
+Manifest-Version: 1.0
+Main-Class: ssagit.Duke
+

src/main/java/ssagit/Duke.java

@@ -0,0 +1,36 @@
+package ssagit;
+
+import java.util.Locale;
+import java.time.format.DateTimeFormatter;
+
+import ssagit.parser.Parser;
+import ssagit.storage.Storage;
+import ssagit.ui.ConsoleUI;
+import ssagit.taskclass.*;
+import ssagit.datevalidator.DateValidator;
+import ssagit.datevalidator.DateValidatorLocalDate;
+
+public class Duke {
+
+    public static void main(String[] args) {
+            /** Create validator for dates */
+            DateTimeFormatter dateFormatter = DateTimeFormatter.ofPattern("d/MM/yyyy HHmm", Locale.ENGLISH);
+            DateValidator validator = new DateValidatorLocalDate(dateFormatter);
+            /** Handler for all UI stuff. */
+            ConsoleUI ui = new ConsoleUI(System.in);
+            ui.introduction();
+            /** Parser for user inputs */
+            Parser parser = new Parser(ui, validator);
+            /** Create tasks */
+            Task[] tasks = new Task[100];
+            /** Initialize file IO */
+            Storage storage = new Storage("./ssagit/data/taskList.txt");
+            int taskIterator = storage.readTaskListToArray(tasks, validator);
+
+            while (parser.getIsBye() == false) {
+                parser.parseInput(tasks, taskIterator);
+            }
+            storage.writeTasks(tasks);
+            ui.bye();
+    }
+}

src/main/java/ssagit/changelog.txt

@@ -0,0 +1 @@
+restore branch-Level-9 (from Level-9)

src/main/java/ssagit/data/taskList.txt

@@ -0,0 +1,4 @@
+deadline | not done | return book  | 2/12/2019 1800
+deadline | not done | return book  | 2/12/2019 1800
+todo | not done | 1
+todo | not done | 2

src/main/java/ssagit/data/taskListBackup.txt

@@ -0,0 +1,5 @@
+todo | not done | a
+todo | not done | b
+todo | not done | c
+deadline | not done | return book  | 2/12/2019 1800
+deadline | not done | return book  | 2/12/2019 1800

src/main/java/ssagit/datevalidator/DateValidator.java

@@ -0,0 +1,8 @@
+package ssagit.datevalidator;
+
+/**
+ * Interface to validate String date input
+ */
+public interface DateValidator {
+    boolean isValid(String dateStr);
+}

src/main/java/ssagit/datevalidator/DateValidatorLocalDate.java

@@ -0,0 +1,53 @@
+package ssagit.datevalidator;
+
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+import java.time.format.DateTimeFormatter;
+import java.time.format.DateTimeParseException;
+
+public class DateValidatorLocalDate implements DateValidator {
+    private DateTimeFormatter dateFormatter;
+
+    /**
+     * DateValidatorLocalDate Constructor.
+     * @param df {@code dateFormatter} object
+     */
+    public DateValidatorLocalDate(DateTimeFormatter df) {
+        dateFormatter = df;
+    }
+
+    @Override
+    /**
+     * Checks if date given is valid, in the following order:
+     * date - time - locale;
+     * If all 3 fails, return with invalid, otherwise return results.
+     */
+    public boolean isValid(String dateStr) {
+        LocalDateTime ldt = null;
+
+        try {
+            ldt = LocalDateTime.parse(dateStr, this.dateFormatter);
+            String result = ldt.format(dateFormatter);
+            return result.equals(dateStr);
+        } catch (DateTimeParseException e) {
+            try {
+                LocalDate ld = LocalDate.parse(dateStr, dateFormatter);
+                String result = ld.format(dateFormatter);
+                return result.equals(dateStr);
+            } catch (DateTimeParseException exp) {
+                try {
+                    LocalTime lt = LocalTime.parse(dateStr, dateFormatter);
+                    String result = lt.format(dateFormatter);
+                    return result.equals(dateStr);
+                } catch (DateTimeParseException e2) {
+                    // Debugging purposes
+                    e2.printStackTrace();
+                }
+            }
+        }
+
+        return false;
+    }
+}
+

src/main/java/ssagit/parser/Parser.java

@@ -0,0 +1,132 @@
+package ssagit.parser;
+
+import ssagit.datevalidator.DateValidator;
+import ssagit.taskclass.DeadlineTask;
+import ssagit.taskclass.EventTask;
+import ssagit.taskclass.Task;
+import ssagit.ui.ConsoleUI;
+
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+public class Parser {
+    ConsoleUI ui;
+    boolean isBye;
+    DateValidator validator;
+
+    public Parser(ConsoleUI ui, DateValidator validator) {
+        this.ui = ui;
+        this.isBye = false;
+        this.validator = validator;
+    }
+
+    /**
+     * Exception class for missing todoTask descriptor.
+     */
+    static class MissingTodoDescriptorException extends Exception {
+        public MissingTodoDescriptorException(String errorMessage) {
+            super(errorMessage);
+        }
+    }
+
+    /**
+     * Exception class for unknown input parameters.
+     */
+    static class UnknownInputParamException extends Exception {
+        public UnknownInputParamException(String errorMessage) {
+            super(errorMessage);
+        }
+    }
+
+    public boolean getIsBye() {
+        return this.isBye;
+    }
+
+    /**
+     * Parses lines of user input and outputs corresponding command.
+     * @param tasks List of tasks from file.
+     * @param taskIterator Integer to count number of tasks at a time.
+     */
+    public void parseInput(Task[] tasks, int taskIterator) {
+        String input = ui.nextLine();
+        String inputArr[] = input.split(" ", 2);
+
+        try {
+            switch (inputArr[0]) {
+            case "bye":
+                this.isBye = true;
+                break;
+            case "list":
+                ui.list(tasks);
+                break;
+            case "done":
+                int taskNum = Integer.parseInt(inputArr[1]) - 1;
+                tasks[taskNum].markDone();
+                ui.markDone(tasks[taskNum].toFormattedString());
+                break;
+            case "todo":
+            case "event":
+            case "deadline":
+                // add to list
+                String[] inputArrTasks = input.split("/", 2);
+                String[] firstHalf = inputArrTasks[0].split(" ", 2);
+                if (inputArrTasks.length != 1) {
+                    // create Deadline/Event
+                    String[] secondHalf = inputArrTasks[1].split(" ", 2);
+                    if (validator.isValid(secondHalf[1])) {
+                        Date date = new SimpleDateFormat("d/MM/yyyy HHmm").parse(secondHalf[1]);
+                        if (inputArr[0].equals("event")) {
+                            tasks[taskIterator] = new EventTask(firstHalf[1], false, secondHalf[1].trim(), date);
+                        } else if (inputArr[0].equals("deadline")) {
+                            tasks[taskIterator] = new DeadlineTask(firstHalf[1], false, secondHalf[1].trim(), date);
+                        }
+                    } else {
+                        System.out.println("Invalid date format for timed Task");
+                    }
+                } else {
+                    // create todoTask
+                    if (firstHalf.length == 1) {
+                        throw new MissingTodoDescriptorException("------------------------------------\n" +
+                                ":( OOPS!!! The description of a todo cannot be empty\n" +
+                                "------------------------------------");
+                    } else {
+                        tasks[taskIterator] = new Task(firstHalf[1], false);
+                    }
+                }
+                break;
+            case "delete":
+                int removeIndex = Integer.parseInt(inputArr[1]);
+                taskIterator--; // reduce task count in list
+                ui.deleteTaskMessage(tasks[removeIndex - 1].toFormattedString(), taskIterator);
+                // actually delete the task and move all other tasks forward
+                for (int i = removeIndex - 1; i < tasks.length - 1; i++) {
+                    tasks[i] = tasks[i + 1];
+                }
+                break;
+            case "find":
+                String toFind = inputArr[1];
+                String output = "Here are the matching tasks in your list:\n";
+                for (Task t : tasks) {
+                    if (t != null) {
+                        if (t.getTaskName().contains(toFind)) {
+                            output = output + t.toFormattedString() + "\n";
+                        }
+                    }
+                }
+                ui.formatBox(output);
+                break;
+            default:
+                throw new UnknownInputParamException("------------------------------------\n" +
+                        ":( OOPS!!! I'm sorry, but I don't know what that means :-(\n" +
+                        "------------------------------------");
+            }
+        } catch (MissingTodoDescriptorException e) {
+            System.out.println(e.getMessage());
+        } catch (UnknownInputParamException e) {
+            System.out.println(e.getMessage());
+        } catch (ParseException e) {
+            System.out.println(e.getMessage());
+        }
+    }
+}

src/main/java/ssagit/storage/Storage.java

@@ -0,0 +1,111 @@
+package ssagit.storage;
+
+import ssagit.datevalidator.DateValidator;
+import ssagit.taskclass.DeadlineTask;
+import ssagit.taskclass.EventTask;
+import ssagit.taskclass.Task;
+
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.List;
+
+public class Storage {
+    Path relativePath;
+    Path absolutePath;
+    File taskText;
+
+    /**
+     * Constructor, creates a file of the searched file if it doesn't exist.
+     * Afterwards, create a {@code FileWriter} which is used to write to the file.
+     * @param relativePath relative path of file to be searched for.
+     */
+    public Storage (String relativePath) {
+        this.relativePath = Paths.get(relativePath);
+        absolutePath = this.relativePath.toAbsolutePath();
+        taskText = new File(absolutePath.toString());
+
+        try {
+            if (!taskText.exists()) {
+                System.out.println("new file created");
+                taskText.createNewFile(); // creates the file if it doesn't exist
+            }
+        } catch (IOException e) {
+            System.out.println("IOException has occurred");
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * Reads a file into the program and parses each line into a Task and puts it into taskArr.
+     * @param taskArr array of Task objects.
+     * @return number of tasks currently available in list (1 index).
+     */
+    public int readTaskListToArray(Task[] taskArr, DateValidator validator) {
+        int taskIterator = 0;
+        try {
+            List<String> list = Files.readAllLines(Paths.get(relativePath.toString()), Charset.defaultCharset());
+            String[] taskListStr = list.toArray(new String[list.size()]);
+            for (String str : taskListStr) {
+                String[] strArr = str.split(" \\| ");
+                String taskType = strArr[0];
+                String isDoneStr = strArr[1];
+                String taskName = strArr[2];
+
+                if (taskType.equals("todo")) {
+                    taskArr[taskIterator] = new Task(taskName, isDoneStr.equals("done"));
+                } else if (taskType.equals("event")) {
+                    if (validator.isValid(strArr[3].trim())) {
+                        Date eventDate = new SimpleDateFormat("d/MM/yyyy HHmm").parse(strArr[3].trim());
+                        taskArr[taskIterator] = new EventTask(taskName, isDoneStr.equals("done"), strArr[3].trim(), eventDate);
+                    } else {
+                        System.out.println("Invalid date format for timed Task");
+                    }
+                } else if (taskType.equals("deadline")) {
+                    if (validator.isValid(strArr[3].trim())) {
+                        Date deadlineDate = new SimpleDateFormat("d/MM/yyyy HHmm").parse(strArr[3].trim());
+                        taskArr[taskIterator] = new DeadlineTask(taskName, isDoneStr.equals("done"), strArr[3].trim(), deadlineDate);
+                    } else {
+                        System.out.println("Invalid date format for timed Task");
+                    }
+                }
+                taskIterator++;
+            }
+            return taskIterator;
+        } catch (IOException e) {
+            System.out.println("IOException has occurred");
+            e.printStackTrace();
+        } catch (ParseException e) {
+            System.out.println("ParseException has occurred");
+            e.printStackTrace();
+        }
+        return taskIterator;
+    }
+
+    /**
+     * Writes all tasks from an array of {@code Task} objects to file output.
+     * @param taskArr Array of {@code Task} objects.
+     */
+    public void writeTasks(Task[] taskArr) {
+        try {
+            FileWriter fw = new FileWriter(absolutePath.toString());
+            for (Task t : taskArr) {
+                if (t != null) {
+                    fw.write(t.toOutputFileString() + "\n");
+                    fw.flush();
+                }
+            }
+            fw.close();
+        } catch (IOException e) {
+            System.out.println("IOException has occurred");
+            e.printStackTrace();
+        }
+    }
+}