[Sunaga] iP

src/main/java/duke/Duke.java

@@ -0,0 +1,141 @@
+package duke;
+
+import duke.exceptions.DukeException;
+import duke.exceptions.DukeIDKException;
+import duke.exceptions.DukeInvalidDesException;
+import duke.exceptions.DukeMissingDesException;
+import duke.handler.Parser;
+import duke.handler.Queries;
+import duke.tasks.*;
+import duke.tasks.Event;
+
+import java.awt.*;
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Scanner;
+
+public class Duke {
+    private boolean exit = false;
+    private Storage storage;
+    private TaskList tasks;
+    private Ui ui;
+
+    private Duke(String storagePath) {
+        storage = new Storage(storagePath);
+        tasks = storage.load();
+        ui = new Ui();
+    }
+
+    public static void main(String[] args) throws IOException {
+        new Duke("data/tasks.txt").run();
+    }
+
+    public void run() {
+        ui.displayIntro();
+        while (exit == false) {
+            processInput(ui.readCommand());
+        }
+        ui.close();
+    }
+
+
+    private void processInput(String userInput) {
+        String keyword_UC = userInput.toUpperCase().split(" ", -1)[0];
+        Queries query = Queries.ADD;
+        String response = "";
+
+        if (Queries.containsValue(keyword_UC)) {
+            query = Queries.valueOf(keyword_UC);
+        }
+
+        try {
+            switch (query) {
+            case BYE:
+                response = "Bye. Hope to see you again soon!";
+                ui.respond(response);
+                exit = true;
+                break;
+
+            case ADD:
+                Task toAdd;
+                try {
+                    if (keyword_UC.equals("TODO")) {
+                        toAdd = new Todo(userInput.split(" ", 2)[1]);
+                    } else if (keyword_UC.equals("DEADLINE")) {
+                        String[] info = userInput.split(" ", 2);
+                        if (info[1].contains("/by")) {
+                            info = info[1].split("/by");
+                        } else {
+                            throw new DukeInvalidDesException(keyword_UC);
+                        }
+                        toAdd = new Deadline(info[0], info[1]);
+                    } else if (keyword_UC.equals("EVENT")) {
+                        String[] info = userInput.split(" ", 2);
+                        if (info[1].contains("/at")) {
+                            info = info[1].split(("/at"));
+                        } else {
+                            throw new DukeInvalidDesException(keyword_UC);
+                        }
+                        toAdd = new Event(info[0], info[1]);
+                    } else {
+                        throw new DukeIDKException();
+                    }
+                    tasks.addTask(toAdd);
+                    response = "Got it. I've added this task:\n"
+                            + " " + toAdd + "\n"
+                            + "Now you have " + tasks.getNumOfTasks() + " tasks in the list.\n";
+                    ui.respond(response);
+                    storage.addTask(toAdd);
+                } catch (ArrayIndexOutOfBoundsException e) {
+                    throw new DukeMissingDesException(keyword_UC);
+                }
+                break;
+
+            case DONE:
+                try {
+                    int taskNum = Integer.parseInt(userInput.split(" ")[1]);
+                    tasks.markDone(taskNum);
+                    Task updatedTask = tasks.getTask(taskNum);
+                    response = "Nice! I've marked this task as done: \n"
+                            + " " + updatedTask+ "\n";
+                    ui.respond(response);
+                    storage.markDoneInStorage(updatedTask, taskNum);
+                } catch (ArrayIndexOutOfBoundsException e) {
+                    throw new DukeMissingDesException("DONE");
+                } catch (IndexOutOfBoundsException | NumberFormatException e) {
+                    throw new DukeInvalidDesException("DONE");
+                }
+                break;
+
+            case DELETE:
+                try {
+                    int taskNum = Integer.parseInt(userInput.split(" ")[1]);
+                    Task task = tasks.getTask(taskNum);
+                    tasks.removeTask(taskNum);
+                    response = "Noted. I've removed this task: \n"
+                            + " " + task + "\n";
+                    ui.respond(response);
+                    storage.delete(taskNum);
+                } catch (ArrayIndexOutOfBoundsException e) {
+                    throw new DukeMissingDesException("DELETE");
+                } catch (IndexOutOfBoundsException | NumberFormatException e) {
+                    throw new DukeInvalidDesException("DELETE");
+                }
+                break;
+            case LIST:
+                response += tasks.toString();
+                ui.respond(response);
+                break;
+            }
+        } catch (DukeException e) {
+            String output = e.getMessage();
+            ui.respond(output);
+        }
+
+    }
+
+
+}
+

src/main/java/duke/Storage.java

@@ -0,0 +1,106 @@
+package duke;
+
+import duke.handler.Parser;
+import duke.tasks.Deadline;
+import duke.tasks.Event;
+import duke.tasks.Task;
+import duke.tasks.TaskList;
+
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.List;
+import java.util.Scanner;
+
+public class Storage {
+    private static String STORAGE_PATH;
+    private static final int MARK_INDEX = 2;
+
+    public Storage(String storagePath) {
+        STORAGE_PATH = storagePath;
+    }
+
+    public TaskList load() {
+        TaskList tasks = new TaskList();
+        Scanner dataReader = null;
+        try{
+            File file = new File(STORAGE_PATH);
+            file.getParentFile().mkdirs();
+            file.createNewFile();
+
+            dataReader = new Scanner(file);
+            while (dataReader.hasNextLine()) {
+                Task task = Parser.parseFromData(dataReader.nextLine());
+                tasks.addTask(task);
+            }
+            return tasks;
+        } catch (IOException e) {
+            System.out.println("File did not load");
+        } finally {
+            dataReader.close();
+        }
+        return tasks;
+    }
+
+    public void addTask(Task task){
+        try {
+            FileWriter fw = new FileWriter(STORAGE_PATH, true);
+            String toWrite ="";
+            switch(task.getType()) {
+            case "TODO":
+                toWrite = String.format("%c|%c|%s",
+                        'T',
+                        task.isDone() ? 'X' : ' ',
+                        task.getDescription());
+                break;
+            case "DEADLINE":
+                toWrite = String.format("%c|%c|%s|%s",
+                        'D',
+                        task.isDone() ? 'X' : ' ',
+                        task.getDescription(),
+                        ((Deadline) task).getBy());
+                break;
+            case "EVENT":
+                toWrite = String.format("%c|%c|%s|%s",
+                        'E',
+                        task.isDone() ? 'X' : ' ',
+                        task.getDescription(),
+                        ((Event) task).getAt());
+                break;
+            }
+            fw.write(toWrite + "\n");
+            fw.close();
+        } catch (IOException e) {
+            System.out.println("File could not be written to. Could not add task.");
+        }
+    }
+
+    public void markDoneInStorage(Task task, int taskNum) {
+        try {
+            Path path = Paths.get(STORAGE_PATH);
+            List<String> lines = Files.readAllLines(path, StandardCharsets.UTF_8);
+            String line = lines.get(taskNum - 1);
+            StringBuilder updatedLine = new StringBuilder(line);
+            updatedLine.setCharAt(MARK_INDEX, 'X');
+            lines.set(taskNum - 1, updatedLine.toString());
+            Files.write(path, lines, StandardCharsets.UTF_8);
+        } catch (IOException e) {
+            System.out.println("Fail to mark done in storage file.");
+        }
+    }
+
+    public void delete(int taskNum) {
+        try {
+            Path path = Paths.get(STORAGE_PATH);
+            List<String> lines = Files.readAllLines(path, StandardCharsets.UTF_8);
+            lines.remove(taskNum - 1);
+            Files.write(path, lines, StandardCharsets.UTF_8);
+        } catch (IOException e) {
+            System.out.println("Fail to delete item in storage file.");
+        }
+    }
+}

src/main/java/duke/Ui.java

@@ -0,0 +1,59 @@
+package duke;
+
+import java.io.PrintStream;
+import java.util.Arrays;
+import java.util.Scanner;
+import java.util.stream.Collectors;
+
+public class Ui {
+    private static final String INDENT = "  ";
+    private static final String TEXT_INDENT = INDENT + "|" + " ";
+    private static final String RES_BOX_TOP = INDENT + "_______________________________________________\n";
+    private static final String RES_BOX_BOTTOM = INDENT + "|____________________________________________\n"
+            + INDENT + "                                              \\|\n";
+    private static Scanner sc = new Scanner(System.in);
+    private final Scanner in;
+    private final PrintStream out;
+
+
+    public Ui() {
+        this.in = new Scanner(System.in);
+        this.out = System.out;
+    }
+
+    private boolean hasCommand() {
+        return in.hasNext();
+    }
+
+    public String readCommand() {
+        assert hasCommand();
+        return in.nextLine();
+    }
+
+    public void close() {
+        in.close();
+    }
+
+    public void displayIntro() {
+        String logo = " ____        _        \n"
+                + "|  _ \\ _   _| | _____ \n"
+                + "| | | | | | | |/ / _ \\\n"
+                + "| |_| | |_| |   <  __/\n"
+                + "|____/ \\__,_|_|\\_\\___|\n";
+        String response = "Hello from\n"
+                + logo + "\n"
+                + "What can I do for you?\n";
+        respond(response);
+    }
+
+    public void respond(String response) {
+        String indentedResponse = Arrays.stream(response.split("\n"))
+                .map(line -> TEXT_INDENT + line)
+                .collect(Collectors.joining("\n")) + "\n";
+        String output = RES_BOX_TOP
+                + indentedResponse
+                + RES_BOX_BOTTOM;
+
+        System.out.println(output);
+    }
+}

src/main/java/duke/exceptions/DukeException.java

@@ -0,0 +1,14 @@
+package duke.exceptions;
+
+public class DukeException extends Exception{
+    private  String message = "OOPS!";
+
+    public DukeException(String s) {
+        super(s);
+    }
+
+    @Override
+    public String getMessage() {
+        return message;
+    }
+}

src/main/java/duke/exceptions/DukeIDKException.java

@@ -0,0 +1,23 @@
+package duke.exceptions;
+
+public class DukeIDKException extends DukeException{
+    private String message;
+
+    /**
+     * Constructor for DukeException for incomprehensible request.
+     */
+    public DukeIDKException() {
+        super("This is a Duke IDK exception");
+        message = super.getMessage() + " "
+                + "I don't get what you mean.";
+    }
+
+    /**
+     * Returns message of the incomprehensible request.
+     * @return Message of the incomprehensible request.
+     */
+    @Override
+    public String getMessage() {
+        return message;
+    }
+}