Merge pull request #2 from Shizheng001/Jar

OOP and Jar

Author: Shizheng001

src/main/java/Deadline.java

@@ -1,95 +1,75 @@
-import java.util.Scanner;
-import java.util.ArrayList;
+import Duke.*;
+import DukeException.DukeException;
+import Parser.Parser;
+import Storage.Storage;
+import Ui.Ui;
+
 
 public class Duke {
+    public static final String LOG_PATH = "./duke.txt";
+    private Storage storage;
+    private TaskList tasks;
+    private Ui ui;
 
-    /**
-     * main method to run the program
-     *
-     * @param args command line arguments taken in
-     */
-    public static void main(String[] args) {
-        Scanner sc = new Scanner(System.in);
-        System.out.println("Hello! I'm Duke\n"+ "What can I do for you?");
-        ArrayList<Task> items = new ArrayList<>();
+    public Duke(String filepath) {
+        this.storage = new Storage(filepath);
+        this.tasks = new TaskList(this.storage);
+        this.ui = new Ui();
+    }
 
-        while (true) {
-            String input = sc.nextLine();
-            try {
-                errorHandling(input);
-                if (input.equals("bye")) {
-                    bye();
-                    break;
-                } else if (input.contains("done")) {
-                    System.out.println("Nice! I've marked this task as done: ");
+    public static void main(String[] args) throws DukeException {
+        try {
+            new Duke(LOG_PATH).run();
+        } catch (DukeException e) {
+            throw new DukeException("unable to load file, probably wrong format.");
+        }
+    }
 
-                    int taskNum = Integer.parseInt(input.substring(5));
-                    String name = items.get(taskNum - 1).getDescription();
+    private void process(Parser p) {
 
-                    Task type = items.get(taskNum - 1);
-                    items.remove(taskNum - 1);
-                    if (type instanceof Todo) {
-                        Todo markDone = new Todo(name, true);
-                        items.add(taskNum - 1, markDone);
-                        System.out.println(markDone);
-                    } else if (type instanceof Deadline) {
-                        Deadline markDone = new Deadline(name, true);
-                        items.add(taskNum - 1, markDone);
-                        System.out.println(markDone);
-                    } else {
-                        Event markDone = new Event(name, true);
-                        items.add(taskNum - 1, markDone);
-                        System.out.println(markDone);
-                    }
+        switch (p.getCommand()) {
+            case "delete":
+                this.tasks.remove(p.getTaskNum());
+                ui.printTaskRemovedMessage((p.getTaskNum()));
+                break;
+            case "done":
+                Task done = this.tasks.get(p.getTaskNum());
+                done.markDone();
+                this.tasks.set(p.getTaskNum(), done);
+                ui.printDoneMessage((done));
+                break;
+            case "add":
+                this.tasks.add(p.getTask());
+                ui.printTaskAddedMessage(p.getTask(), this.tasks.getSize());
+                break;
+            case "set":
+                this.tasks.set(p.getTaskNum(), p.getTask());
+                break;
+            case "list":
+                ui.printList(this.tasks);
+                break;
+            default:
+        }
+    }
 
-                } else if (input.equals("list")) {
-                    int n = 1;
-                    System.out.println("Here are the tasks in your list:");
-                    for (Task item : items) {
-                        System.out.println(n + ". " + item);
-                        n++;
-                    }
+    public void run() throws DukeException {
+        Ui.printGreeting();
 
-                } else if (input.length() >= 8 && input.substring(0,8).equals("deadline")) {
-                    items.add(new Deadline(input.substring(8)));
-                } else if (input.length() >= 4 && input.substring(0,4).equals("todo")) {
-                    items.add(new Todo(input.substring(4)));
-                } else if (input.length() >= 5 && input.substring(0,5).equals("event")) {
-                    items.add(new Event(input.substring(5)));
-                } else if (input.length() >= 6 && input.substring(0,6).equals("delete")) {
-                    int taskToDelete = Integer.parseInt(input.substring(7));
-                    Task toRemove = items.get(taskToDelete - 1);
-                    items.remove(taskToDelete - 1);
-                    System.out.println("Noted. I've removed this task:\n  "
-                                       + toRemove + "\nNow you have " + items.size() + " tasks in the list.");
+        while (true) {
+            String userInput = ui.getUserInput();
+            Parser p;
 
-                } else {
-                    items.add(new Task(input));
-                }
-            } catch (Exception e) {
-                System.out.println(e);
+            try {
+                p = Parser.parse(userInput);
+            } catch (DukeException e) {
+                System.out.println(e.getMessage());
+                continue;
             }
+            if (p.getCommand().equals("bye")) {
+                break;
+            }
+            this.process(p);
         }
-    }
-
-    /**
-     * prints Goodbye message.
-     */
-    public static void bye() {
-        System.out.println("Bye. Hope to see you again soon!");
-    }
-
-    public static void errorHandling(String input) throws DukeException {
-        if (input.length() == 4 && input.equals("todo")) {
-            throw new DukeException(" ☹ OOPS!!! The description of a todo cannot be empty.");
-        } else if (input.length() == 8 && input.equals("deadline")) {
-            throw new DukeException(" ☹ OOPS!!! The description of a deadline cannot be empty.");
-        } else if (input.length() == 5 && input.equals("event")) {
-            throw new DukeException(" ☹ OOPS!!! The description of a event cannot be empty.");
-        } else if (input.length() >= 4 && input.substring(0,4).equals("blah")) {
-            throw new DukeException("☹ OOPS!!! I'm sorry, but I don't know what that means :-(");
-        } else if (input.isBlank()) {
-            throw new DukeException(" ☹ OOPS!!! A Task cannot be empty.");
-        } else {}
+        Ui.printGoodbye();
     }
 }

src/main/java/Duke.java

@@ -0,0 +1,25 @@
+package Duke;
+
+import java.time.LocalDate;
+import java.time.format.DateTimeFormatter;
+
+public class Deadline extends Task {
+    private final LocalDate deadLine;
+
+    public Deadline(String description, String deadLine) {
+        super(description);
+        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-M-dd");
+        this.deadLine = LocalDate.parse(deadLine.trim(), formatter);
+    }
+
+    @Override
+    public String encode() {
+        return "D|" + super.encode() + " | " + this.deadLine.format(DateTimeFormatter.ofPattern("yyyy-M-dd"));
+    }
+
+    @Override
+    public String toString() {
+        return "[D]" + super.toString() + " | " + " (by: " + this.deadLine.format(DateTimeFormatter.ofPattern("MMM d yyyy")) + ")";
+    }
+
+}

src/main/java/Duke/Deadline.java

@@ -0,0 +1,25 @@
+package Duke;
+
+import java.time.LocalDate;
+import java.time.format.DateTimeFormatter;
+
+public class Event extends Task {
+    private LocalDate eventTime;
+    private DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-M-dd");
+
+        public Event(String description, String eventTime) {
+            super(description);
+            this.eventTime = LocalDate.parse(eventTime.trim(), formatter);
+        }
+    @Override
+    public String encode() {
+        return "E|" + super.encode() + " | " + this.eventTime.format(DateTimeFormatter.ofPattern("yyyy-M-dd"));
+    }
+
+    @Override
+    public String toString() {
+        return "[E]" + super.toString() + " (at: " + this.eventTime.format(DateTimeFormatter.ofPattern("MMM d yyyy")) + ")";
+    }
+}
+
+

src/main/java/Duke/Event.java

@@ -0,0 +1,41 @@
+package Duke;
+
+public class Task {
+    protected String description;
+    protected boolean isDone;
+    protected String dateTime;
+
+    public Task(String description) {
+        this.description = description;
+        this.isDone = false;
+    }
+
+    public Task(String description, String dateTime) {
+        this.description = description;
+        this.dateTime = dateTime;
+    }
+
+    public void markDone() {
+        this.isDone = true;
+    }
+    public String getDoneStatus() {
+        return (isDone ? "X" : " ");
+    }
+
+    public String getDescription() {
+        return this.description;
+    }
+
+    public String encode() {
+        if (isDone) {
+            return "X|" + this.description ;
+        } else {
+            return " |" + this.description ;
+        }
+    }
+
+    public String toString() {
+        return "[" + getDoneStatus() + "]" + getDescription();
+
+    }
+}

src/main/java/Duke/Task.java

@@ -0,0 +1,67 @@
+package Duke;
+
+import java.util.ArrayList;
+import java.util.List;
+import Storage.Storage;
+
+public class TaskList {
+    private final Storage storage;
+    private final List<Task> tasks;
+    private int numOfTasks;
+
+    public TaskList(Storage storage) {
+        this.storage = storage;
+        this.tasks = new ArrayList<>();
+        ArrayList<String> storedData = this.storage.load();
+        for (String s : storedData) {
+            this.tasks.add(loadData(s));
+        }
+        this.numOfTasks = this.tasks.size();
+    }
+
+    private Task loadData(String data) {
+        String[] dataArray = data.split("\\|");
+
+        //System.out.println(dataArray.length + " " + dataArray[0] + dataArray[1]);
+
+        Task task;
+
+        if (dataArray[0].equals("T")) {
+            task = new Todo(dataArray[2]);
+        } else if (dataArray[0].equals("D")) {
+            task = new Deadline(dataArray[2], dataArray[3]);
+        } else {
+            task = new Event(dataArray[2], dataArray[3]);
+        }
+        if (dataArray[1].contains("X")) {
+            task.markDone();
+        }
+
+        return task;
+    }
+
+    public Task get(int taskNumber) {
+        return this.tasks.get(taskNumber - 1);
+    }
+
+    public void add(Task task) {
+        this.storage.add(task);
+        this.tasks.add(task);
+        this.numOfTasks = this.tasks.size();
+    }
+    public void remove(int index) {
+        this.storage.remove(index);
+        this.tasks.remove(index - 1);
+        this.numOfTasks = this.tasks.size();
+    }
+
+    public void set(int index, Task task) {
+        this.storage.set(index, task);
+        this.tasks.set(index - 1, task);
+    }
+
+    public int getSize() {
+        return this.numOfTasks;
+    }
+
+}

src/main/java/Duke/TaskList.java

@@ -1,12 +1,18 @@
+package Duke;
+
+import java.time.format.DateTimeFormatter;
+
 public class Todo extends Task {
+
     public Todo(String description) {
         super(description);
     }
 
-    public Todo(String description, boolean b) {
-        super(description, b);
+    @Override
+    public String encode() {
+        return "T|" + super.encode();
     }
-
+    @Override
     public String toString() {
         return "[T]" + super.toString();
     }

src/main/java/Todo.java src/main/java/Duke/Todo.javasrc/main/java/Todo.java renamed to src/main/java/Duke/Todo.java

@@ -1,3 +1,5 @@
+package DukeException;
+
 public class DukeException extends Exception {
 
     public DukeException(String e) {

src/main/java/DukeException.java …in/java/DukeException/DukeException.javasrc/main/java/DukeException.java renamed to src/main/java/DukeException/DukeException.java src/main/java/DukeException.java renamed to src/main/java/DukeException/DukeException.java

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