[KristopherPTaslim] iP

src/main/java/duke/Deadline.java

@@ -0,0 +1,21 @@
+package duke;
+
+class Deadline extends Task {
+
+    protected String by;
+
+    public Deadline(String description, String by) {
+        super(description);
+        this.by = by;
+    }
+
+    @Override
+    public String toString() {
+        return "[D]" + super.toString() + "(by: " + by + ")";
+    }
+
+    @Override
+    public String getInitial() {
+        return "[D]";
+    }
+}

src/main/java/duke/Duke.java

@@ -0,0 +1,47 @@
+package duke;
+
+import java.io.IOException;
+import java.util.Scanner;
+
+public class Duke {
+
+    private Storage storage;
+    private TaskList taskList;
+    private Ui ui;
+
+    public Duke(String filePath) {
+        this.ui = new Ui();
+        this.storage = new Storage(filePath);
+        this.taskList = new TaskList(storage);
+    }
+
+    public void run() {
+        ui.showWelcomeMessage();
+        try {
+            Scanner sc = new Scanner(storage.load());
+            String input = sc.nextLine();
+            Parser parser = new Parser(taskList);
+
+            while (sc.hasNextLine()) {
+                parser.execute(input);
+                if (input.toLowerCase().equals("bye")) {
+                    break;
+                }
+                input = sc.nextLine();
+            }
+
+        } catch (IOException e) {
+            System.out.println("File is not found :(!");
+        }
+
+        storage.writeFile();
+    }
+
+    public static void main(String[] args) {
+        Duke duke = new Duke("/data/tasks.txt");
+        duke.run();
+    }
+
+}
+
+

src/main/java/duke/DukeException.java

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

src/main/java/duke/Event.java

@@ -0,0 +1,21 @@
+package duke;
+
+class Event extends Task {
+
+    protected String at;
+
+    public Event(String description, String at) {
+        super(description);
+        this.at = at;
+    }
+
+    @Override
+    public String toString() {
+        return "[E]" + super.toString() + "(at: " + at + ")";
+    }
+
+    @Override
+    public String getInitial() {
+        return "[E]";
+    }
+}

src/main/java/duke/FileClass.java

@@ -0,0 +1,42 @@
+package duke;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Paths;
+import java.io.FileWriter;
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+class FileClass {
+
+    public void createFile(String filePath) {
+        File f = new File(filePath); //initialise the file
+        if (!f.exists()) { //meaning f doesnt exist
+            try {
+                f.createNewFile();
+            } catch (IOException e) {
+                System.out.println("Path Directory is invalid!");
+            }
+        }
+    } 
+    //taken from W3.3c File Access
+    public void writeFile(String filePath, String textToAdd) throws IOException { 
+        FileWriter fw = new FileWriter(filePath, true); // initialise the filewriter
+        fw.write(textToAdd + "\r\n");
+        fw.close();
+    }
+
+    public void createDirectory(String filePath) {
+        File f = new File(filePath); //initialise the file
+        Path path = Paths.get(filePath);
+        if (!f.exists()) { //meaning f doesnt exist
+            try {
+                Files.createDirectory(path);
+            } catch (IOException e) {
+                System.out.println("Path Directory cannot be created!");
+            }
+        }
+
+
+    }
+}

src/main/java/duke/Parser.java

@@ -0,0 +1,131 @@
+package duke;
+
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+
+class Parser {
+    public TaskList taskList;
+    private Ui ui;
+
+    Parser(TaskList taskList) {
+        this.taskList = taskList;
+        this.ui = new Ui();
+    }
+
+    public void execute(String input) {
+        String[] checkCase = input.split(" ");
+        switch (checkCase[0].toLowerCase()) {
+
+            case ("list"): 
+                ui.showListMessage(taskList);
+                break;
+
+            case ("mark"):
+                try {
+                    int index = Integer.parseInt(checkCase[1]) - 1;
+                    Task tasks = taskList.getTaskArray().get(index);
+                    System.out.println(tasks.marking(checkCase[0].toLowerCase()));
+                    taskList.getTaskArray().set(index, tasks);
+                } catch (ArrayIndexOutOfBoundsException e) {
+                    ui.showInvalidInput();
+                }
+                break;
+
+            case ("unmark"):
+                try {
+                    int index = Integer.parseInt(checkCase[1]) - 1;
+                    Task tasks = taskList.getTaskArray().get(index);
+                    System.out.println(tasks.marking(checkCase[0].toLowerCase()));
+                    taskList.getTaskArray().set(index, tasks);
+                } catch (ArrayIndexOutOfBoundsException e) {
+                    ui.showInvalidInput();
+                }
+                break;
+
+            case ("todo"):
+
+                try {
+                    String toDoCondition = "todo ";
+                    int indexOfToDo = toDoCondition.length(); //to find todo
+                    String stringSliced = input.substring(indexOfToDo,input.length());
+                    Todo todoTask = new Todo(stringSliced);
+                    taskList.addTask(todoTask);
+                    String noOfTask = String.valueOf(taskList.getTaskArray().size());
+                    ui.showAddedMessage(todoTask, noOfTask);
+                } catch (StringIndexOutOfBoundsException e) {
+                    ui.showTodoError();
+                }
+                break;
+
+            case ("deadline"):
+
+                try {
+                    String deadlineCondition = "/by ";
+                    int indexOfTime = input.indexOf(deadlineCondition); //to find /
+                    String dateTime = input.substring(indexOfTime + deadlineCondition.length(), input.length()); // the date and time for by
+                    //convert to the correct one
+                    LocalDateTime deadlineTime = LocalDateTime.parse(dateTime, DateTimeFormatter.ofPattern("d/M/y Hmm"));
+                    String convertedTime = deadlineTime.format(DateTimeFormatter.ofPattern("MMM d yyyy hh:mm a"));
+                    String stringSliced = input.substring(9, indexOfTime); // after deadline
+                    Deadline deadlineTask = new Deadline(stringSliced, convertedTime);
+                    taskList.addTask(deadlineTask);
+                    String noOfTask = String.valueOf(taskList.getTaskArray().size());
+                    ui.showAddedMessage(deadlineTask, noOfTask);
+                } catch (StringIndexOutOfBoundsException e) {
+                    ui.showDeadlineError();
+                }
+                break;
+
+            case ("event"):
+
+                try {
+                    String eventCondition = "/at ";
+                    int indexOfTime = input.indexOf(eventCondition); //to find /
+                    String dateTime = input.substring(indexOfTime + eventCondition.length(), input.length()); // the date and time for at
+                    //convert to the correct one
+                    LocalDateTime eventTime = LocalDateTime.parse(dateTime, DateTimeFormatter.ofPattern("d/M/y Hmm"));
+                    String convertedTime = eventTime.format(DateTimeFormatter.ofPattern("MMM d yyyy hh:mm a"));
+                    String stringSliced = input.substring(6, indexOfTime); // after deadline
+                    Event eventTask = new Event(stringSliced, convertedTime);
+                    taskList.addTask(eventTask);
+                    String noOfTask = String.valueOf(taskList.getTaskArray().size());
+                    ui.showAddedMessage(eventTask, noOfTask);
+
+                } catch (StringIndexOutOfBoundsException e) {
+                    ui.showEventError();
+                }
+                break;
+
+            case("delete"):
+
+                try {
+                    int index = Integer.parseInt(checkCase[1]) - 1;
+                    Task task = taskList.getTaskArray().get(index);
+                    taskList.deleteTask(index);
+                    String noOfTask = String.valueOf(taskList.getTaskArray().size());
+                    ui.showDeletedMessage(task, noOfTask);
+                } catch (ArrayIndexOutOfBoundsException e) {
+                    ui.showDeleteError();
+                }
+                break;
+
+            case("bye"):
+                ui.showGoodbyeMessage();
+                break;             
+
+            default:
+                ui.showDefaultMessage();
+                break;
+
+
+
+        }
+
+
+    }
+
+
+
+
+
+}

src/main/java/duke/Storage.java

@@ -0,0 +1,53 @@
+package duke;
+
+import java.util.ArrayList;
+import java.io.File;
+import java.io.IOException;
+
+class Storage {
+    private ArrayList<Task> taskArray;
+    private String path;
+    private static String HOME = System.getProperty("user.home");
+
+    Storage(String path) {
+        this.taskArray = new ArrayList<Task>();
+        this.path = path;
+    }
+
+    public File load() {
+        FileClass fc = new FileClass(); //file class 
+        String homePath = HOME + "/data";
+        path = HOME + path;
+        fc.createDirectory(homePath); //create directory first
+        fc.createFile(path); //create a file in the /home/data/tasks.txt
+        File file = new File(path);
+        return file;
+    }
+
+    public void writeFile() {
+        FileClass fc = new FileClass();
+        String filePath = HOME + "/data/stored.txt";
+        fc.createFile(filePath);
+        for (int i = 0; i < taskArray.size(); i++) {
+            Task tasks = taskArray.get(i);
+            try {
+                String firstInitial = tasks.getInitial() ; //first initial character
+                String textToAdd = firstInitial + " | " + tasks.getStatusIcon() + " | " 
+                                    + taskArray.get(i).getDescription();
+                fc.writeFile(filePath, textToAdd);
+            } catch (IOException e) {
+                System.out.println("File is not found :(!");
+            }
+
+        }
+
+    }
+
+    public ArrayList<Task> getList() {
+        return this.taskArray;
+    }
+
+
+
+
+}