Level 1 to 3 (Week 2)

README.md

@@ -1,4 +1,4 @@
-# Duke project template
+# duke.Duke project template
 
 This is a project template for a greenfield Java project. It's named after the Java mascot _Duke_. Given below are instructions on how to use it.
 
@@ -15,7 +15,7 @@ Prerequisites: JDK 11, update Intellij to the most recent version.
    1. Click `Open or Import`.
    1. Select the project directory, and click `OK`
    1. If there are any further prompts, accept the defaults.
-1. After the importing is complete, locate the `src/main/java/Duke.java` file, right-click it, and choose `Run Duke.main()`. If the setup is correct, you should see something like the below:
+1. After the importing is complete, locate the `src/main/java/duke.Duke.java` file, right-click it, and choose `Run duke.Duke.main()`. If the setup is correct, you should see something like the below:
    ```
    Hello from
     ____        _        

src/main/java/duke/Duke.java

@@ -0,0 +1,38 @@
+package duke;
+
+import duke.command.CommandHandler;
+import duke.input.InputHandler;
+import duke.input.InputParser;
+import duke.output.DisplayHandler;
+import duke.storage.ListHandler;
+
+public class Duke {
+    public static void main(String[] args) {
+
+        // Instantiate program components
+        DisplayHandler displayHandler = new DisplayHandler();
+        InputHandler inputHandler = new InputHandler();
+        InputParser parser = new InputParser();
+        ListHandler list = new ListHandler();
+        CommandHandler command = new CommandHandler();
+
+        // Uses a Facade to Manage Individual Modular Components
+        displayHandler.ProgramOpening();
+
+        while(true) {
+
+            // Get User input
+            String input = inputHandler.getUserInput();
+            // Parse User input
+            String keyWord = parser.extractKeyWord(input);
+            String body = parser.extractKeyWordBody(input, keyWord);
+
+            // If input is not recognised Keyword
+            if(parser.checkIfKeyWord(keyWord) == false)
+                displayHandler.DisplayInvalidInput();
+            // If input is a recognised Keyword
+            else
+                command.checkCommandType(keyWord, body, list);
+        }
+    }
+}

src/main/java/duke/command/CommandHandler.java

@@ -0,0 +1,70 @@
+package duke.command;//import jdk.internal.util.xml.impl.Input;
+
+import duke.output.DisplayHandler;
+import duke.storage.ListHandler;
+import duke.exception.IncorrectInputException;
+import duke.input.InputParser;
+import duke.task.Task;
+
+public class CommandHandler {
+
+    DisplayHandler displayHandler = new DisplayHandler();
+    InputParser inputParser = new InputParser();
+
+    public void checkCommandType(String KeyWord, String Body, ListHandler List) {
+
+        KEYWORD keyword = KEYWORD.valueOf(KeyWord.toUpperCase());
+
+        try{
+
+            switch(keyword){
+                case TODO:
+                    String todoBody = inputParser.extractTodoBody(Body);
+                    List.addToDo(todoBody);
+                    Task todoTaskAdded = (Task) List.GetList().lastElement();
+                    displayHandler.ShowTaskAdded(List.GetList().size(), todoTaskAdded);
+                    break;
+
+                case DEADLINE:
+                    String deadlineBody = inputParser.extractDeadlineBody(Body);
+                    String deadlineByDate = inputParser.extractDeadlineByDay(Body);
+                    String deadlineByTime = inputParser.extractDeadlineByTime(Body);
+                    List.addDeadline(deadlineBody, deadlineByDate, deadlineByTime);
+                    Task deadlineTaskAdded = (Task) List.GetList().lastElement();
+                    displayHandler.ShowTaskAdded(List.GetList().size(), deadlineTaskAdded);
+                    break;
+
+                case EVENT:
+                    String eventBody = inputParser.extractEventBody(Body);
+                    String eventDay = inputParser.extractEventAtDay(Body);;
+                    String eventTime = inputParser.extractEventAtTime(Body);
+                    List.addEvent(eventBody, eventDay, eventTime);
+                    Task EventTaskAdded = (Task) List.GetList().lastElement();
+                    displayHandler.ShowTaskAdded(List.GetList().size(), EventTaskAdded);
+                    break;
+
+                case LIST:
+                    displayHandler.DisplayList(List.GetList());
+                    break;
+
+                case DONE:
+                    Task task = List.UpdateListItem(Body);
+                    displayHandler.DisplayChanges(task);
+                    break;
+
+                case BYE:
+                    displayHandler.ProgramEnding();
+                    System.exit(0);
+                    break;
+            }
+
+        } catch (Exception e){
+            if(e instanceof IncorrectInputException){
+                displayHandler.DisplayCustomException(e);
+            }
+            else {
+                displayHandler.DisplayInvalidInput();
+            }
+        }
+    }
+}

src/main/java/duke/command/KEYWORD.java

@@ -0,0 +1,11 @@
+package duke.command;
+
+public enum KEYWORD {
+        TODO,
+        DEADLINE,
+        EVENT,
+        LIST,
+        DONE,
+        BYE
+    }
+

src/main/java/duke/exception/IncorrectInputException.java

@@ -0,0 +1,7 @@
+package duke.exception;
+
+public class IncorrectInputException extends Exception {
+    public IncorrectInputException(String message){
+        super(message);
+    }
+}

src/main/java/duke/input/InputHandler.java

@@ -0,0 +1,15 @@
+package duke.input;
+
+import java.util.Scanner;
+
+public class InputHandler {
+
+    static private Scanner fromInputStream = new Scanner(System.in);
+
+    public String getUserInput(){
+
+        String command = fromInputStream.nextLine();
+
+        return command;
+    }
+}

src/main/java/duke/input/InputParser.java

@@ -0,0 +1,146 @@
+package duke.input;
+
+import duke.output.DisplayHandler;
+import duke.command.KEYWORD;
+import duke.exception.IncorrectInputException;
+
+public class InputParser {
+
+    // Check if First Word is Keyword
+    public boolean checkIfKeyWord(String input) {
+
+        try {
+            KEYWORD.valueOf(input.toUpperCase());
+            return true;
+
+        } catch (IllegalArgumentException e) {
+            return false;
+        }
+    }
+
+    // Extract Keyword from Input
+    public String extractKeyWord(String input) {
+        String[] Array = input.split(" ");
+        return Array[0];
+    }
+
+    // Extract Body from Input
+    public String extractKeyWordBody(String input, String keyword) {
+        try {
+            return input.replaceFirst(keyword, "");
+
+        } catch(ArrayIndexOutOfBoundsException e){ // May not be used anymore
+            return null;
+        }
+    }
+
+    // For Todos
+    public String extractTodoBody(String todoInput) throws IncorrectInputException {
+        if(todoInput.isEmpty())
+            throw new IncorrectInputException(DisplayHandler.EMPTY_TODO);
+
+        return todoInput;
+    }
+
+    // For Deadlines
+    public String extractDeadlineBody(String deadlineInput) throws IncorrectInputException {
+        String result = "";
+        try{
+            int indx = deadlineInput.indexOf("/by");
+            result = deadlineInput.substring(0, indx);
+
+        } catch (Exception e){
+            if(result.length() < 1){
+                throw new IncorrectInputException(DisplayHandler.EMPTY_DEADLINE_DESC);
+            }
+        }
+        return result;
+    }
+
+    public String extractDeadlineByDay(String deadlineInput) throws IncorrectInputException{
+        String day = "";
+        try{
+            int indx = deadlineInput.indexOf("/by");
+            String by = deadlineInput.substring(indx, deadlineInput.length());
+            String[] array = by.split(" ");
+            day = array[1];
+            return day;
+
+        }catch (Exception e) {
+            if(day.length() < 1){
+                throw new IncorrectInputException(DisplayHandler.EMPTY_DEADLINE_DAY);
+            }
+        }
+
+        return day;
+    }
+
+    public String extractDeadlineByTime(String deadlineInput) throws IncorrectInputException {
+        String time = "";
+        try{
+            int indx = deadlineInput.indexOf("/by");
+            String by = deadlineInput.substring(indx);
+            String[] array = by.split(" ");
+            time = array[2];
+
+        } catch (Exception e) {
+            if(time.length() < 1){
+                throw new IncorrectInputException(DisplayHandler.EMPTY_DEADLINE_TIME);
+            }
+        }
+
+        return time;
+    }
+
+    // For Events
+    public String extractEventBody(String eventInput) throws IncorrectInputException {
+        String result = "";
+
+        try{
+            int indx = eventInput.indexOf("/at");
+            result = eventInput.substring(0, indx);
+
+        }catch (Exception e){
+            if(result.length() < 1){
+                throw new IncorrectInputException(DisplayHandler.EMPTY_EVENT_DESC);
+            }
+        }
+
+        return result;
+    }
+
+    public String extractEventAtDay(String eventInput) throws IncorrectInputException{
+        String day = "";
+
+        try {
+            int indx = eventInput.indexOf("/at");
+            String by = eventInput.substring(indx, eventInput.length());
+            String[] array = by.split(" ");
+            day = array[1];
+
+        }catch (Exception e) {
+            if(day.length() < 1){
+                throw new IncorrectInputException(DisplayHandler.EMPTY_EVENT_DAY);
+            }
+        }
+        return day;
+    }
+
+    public String extractEventAtTime(String eventInput) throws IncorrectInputException {
+        String time = "";
+
+        try{
+            int indx = eventInput.indexOf("/at");
+            String by = eventInput.substring(indx);
+            String[] array = by.split(" ");
+            time = array[2];
+
+        } catch (Exception e) {
+            if(time.length() < 1){
+                throw new IncorrectInputException(DisplayHandler.EMPTY_EVENT_TIME);
+            }
+        }
+
+        return time;
+    }
+}