[rohitcube] iP

Main.java

@@ -0,0 +1,2 @@
+public class Main {
+}

data/dukey.txt

@@ -0,0 +1,3 @@
+4.[T][ ] hey
+4.[T][ ] yn
+3.[T][ ] hi

docs/README.md

@@ -1,29 +1,139 @@
+# Dukey Chatbot
 # User Guide
 
-## Features 
 
-### Feature-ABC
 
-Description of the feature.
+## Usage of Features
 
-### Feature-XYZ
+### `bye` - Exit Program
 
-Description of the feature.
+This command is used to exit the program.
 
-## Usage
+Format:
 
-### `Keyword` - Describe action
+`bye`
 
-Describe the action and its outcome.
+Expected outcome: Bye. Hope to see you again soon!
 
-Example of usage: 
 
-`keyword (optional arguments)`
+### `list` - List Tasks
+
+This command is used to list all tasks.
+
+Format:
+
+`list`
+
 
 Expected outcome:
+1.[T][ ] homework 
+2.[T][ ] go to the beach
+3.[E][ ] cycle (from: 5am to: 8am)
+
+
+### `mark` - Mark Task as Done
+
+This command is used to mark a task as done.
+
+Format:
+
+`mark (task number)`
+
+
+Expected outcome: Nice! I've marked this task as done:
+`[T][X]` hi
+
+
+### `unmark` - Unmark Task
+
+This command is used to unmark a task (mark it as not done).
+
+Format:
+
+`unmark (task number)`
+
+Expected outcome: Nice! I've marked this task as done:
+[T][ ] hi
+
+
+
+### `deadline` - Add Deadline Task
+
+This command is used to add a deadline task.
+
+Format:
+
+`deadline (description) /by (due date)`
+
+Example of input :
+`Submit assignment /by 9am`
+
+Expected outcome: [D][ ] Submit assignment (by: 9am)
+
+
+### `event` - Add Event Task
+
+This command is used to add an event task.
+
+Format:
+
+`event (description) /from (start time) /to (end time)`
+
+Example of input :
+`Rohit attends cs2113 lecture /from 4pm /to 6pm`
+
+Expected outcome: [E][ ] Rohit attends cs2113 lecture (from: 4pm to: 6pm)
+
+
+### `todo` - Add Todo Task
+
+This command is used to add a todo task.
+
+Format:
+
+`todo (description)`
+
+Example of input :
+`todo buy groceries`
+
+Expected outcome: [T][ ] buy groceries
+
+
+### `delete` - Delete Task
+
+This command is used to delete a task.
+
+Format:
+
+`delete (task number)`
+
+Expected outcome: 
+"Noted. I have removed this task:
+[D][ ] bro (by:tmr)
+Now you have 3 tasks in the list."
+
+### `find` - Find a task/tasks
+
+This command is used to search for tasks that contain a particular
+keyword in the description.
+
+Format:
+
+`find (task number)`
+
+Example of input:
+`find hohoho`
+
+Expected Outcome:
+
+"Here are the matching tasks in your list:
+
+[T][ ] hohoho
+[T][ ] hohoho
+[E][ ] hohoho (from: 9am to: 5pm)"
+
 
-Description of the outcome.
+### Additional Notes For Users 
 
-```
-expected output
-```
+- Do not input whitespaces before your command 
+- e.g. (  `todo homework` is invalid), (`todo homework` is valid)

docs/dukey.txt

@@ -0,0 +1 @@
+

src/main/java/Duke.java

@@ -1,10 +1 @@
-public class Duke {
-    public static void main(String[] args) {
-        String logo = " ____        _        \n"
-                + "|  _ \\ _   _| | _____ \n"
-                + "| | | | | | | |/ / _ \\\n"
-                + "| |_| | |_| |   <  __/\n"
-                + "|____/ \\__,_|_|\\_\\___|\n";
-        System.out.println("Hello from\n" + logo);
-    }
-}
+

src/main/java/Dukey.java

@@ -0,0 +1,139 @@
+import Exceptions.DukeyErrorMessages;
+import Tasks.*;
+
+import java.util.ArrayList;
+import java.util.Scanner;
+import java.io.IOException;
+public class Dukey {
+    protected Storage storage;
+    protected TaskList tasks;
+    protected Ui ui;
+    protected String filePath = "data/dukey.txt";
+
+    public Dukey(String filePath) {
+        ui = new Ui();
+        storage = new Storage(filePath);
+        try {
+            ArrayList<Task> array1 = new ArrayList<>();
+            storage.fileToTaskArray(filePath, array1);
+            tasks = new TaskList(array1); // Assigning the TaskList to the class-level variable
+        } catch (Exception e) {
+            Ui.showLoadingError();
+            this.tasks = new TaskList(new ArrayList<>());
+        }
+    }
+
+    public void run() throws IOException {
+        ui.showWelcomeMessage();
+        Scanner in = new Scanner(System.in);
+        String line;
+        storage.checkDirectoryExists("data");
+        storage.checkFileExists(filePath);
+        while (true) {
+            line = in.nextLine();
+            String[] input = Parser.parseUserInput(line);
+            String command = input[0];
+            switch (command) {
+                case "bye":
+                    Ui.showExitMessage();
+                    return;
+                case "list":
+                    TaskList.printTaskList(tasks.tasks);
+                    break;
+                case "mark":
+                    try {
+                        TaskList.markTask(line, tasks.tasks);
+                        storage.markTaskInFile(Integer.parseInt(input[1].trim()) - 1, filePath);
+                    } catch (IndexOutOfBoundsException e) {
+                        DukeyErrorMessages.markInvalidError();
+                    } catch (NumberFormatException e) {
+                        DukeyErrorMessages.markInvalidTypeError();
+                    }
+                    break;
+                case "unmark":
+                    try {
+                        TaskList.unmarkTask(line, tasks.tasks);
+                        storage.unmarkTaskInFile(Integer.parseInt(input[1].trim()) - 1, filePath);
+                    } catch (IndexOutOfBoundsException e) {
+                        DukeyErrorMessages.unmarkInvalidError();
+                    } catch (NumberFormatException e) {
+                        DukeyErrorMessages.unmarkInvalidTypeError();
+                    }
+                    break;
+                case "deadline":
+                    try {
+                        String[] deadline = Parser.parseCommandInput(command, input[1]);
+                        if (deadline[0].trim().isEmpty() || deadline[1].trim().isEmpty()) {
+                            DukeyErrorMessages.deadlineEmptyInputError();
+                            break;
+                        }
+                        TaskList.addDeadline(deadline[0], deadline[1], tasks.tasks);
+                    } catch (ArrayIndexOutOfBoundsException e) {
+                        DukeyErrorMessages.deadlineFormatError();
+                    }
+                    storage.taskArrayToFile(filePath, tasks.tasks);
+                    break;
+                case "event":
+                    try {
+                        String[] events = Parser.parseCommandInput(command, input[1]);
+                        if (events[2].isEmpty() || events[1].isEmpty() || events[0].isEmpty()) {
+                            DukeyErrorMessages.eventEmptyInputError();
+                            break;
+                        }
+                        TaskList.addEvent(events[0], events[1], events[2], tasks.tasks);
+                        storage.taskArrayToFile(filePath, tasks.tasks);
+                    } catch (ArrayIndexOutOfBoundsException e) {
+                        System.out.println(Exceptions.DukeyException.EmptyInputError());
+                        DukeyErrorMessages.eventFormatError();
+                    } catch (StringIndexOutOfBoundsException e) {
+                        DukeyErrorMessages.eventFormatError();
+                    }
+                    break;
+                case "todo":
+                    try {
+                        String[] todo = Parser.parseCommandInput(command, input[1]);
+                        if (input[1].trim().isEmpty()) {
+                            DukeyErrorMessages.todoEmptyInputError();
+                            break;
+                        }
+                        TaskList.addTodo(todo[0], tasks.tasks);
+                        storage.taskArrayToFile(filePath, tasks.tasks);
+                    } catch (ArrayIndexOutOfBoundsException e) {
+                        DukeyErrorMessages.todoFormatError();
+                    }
+                    break;
+                case "delete":
+                    try {
+                        TaskList.deleteTask(line, tasks.tasks);
+                        storage.deleteLineFromFile(Integer.parseInt(input[1].trim()) - 1, filePath);
+                    }
+                    catch (ArrayIndexOutOfBoundsException e) {
+                        DukeyErrorMessages.deleteEmptyInputError();
+                    } catch (NumberFormatException e) {
+                        DukeyErrorMessages.deleteInvalidTypeError();
+                    }
+                    break;
+                case "find":
+                    TaskList.findKeyword(line, tasks.tasks);
+                    break;
+                default:
+                    if (line.trim().isEmpty()) {
+                        DukeyErrorMessages.unrecognizedCommandError();
+                    } else {
+                        DukeyErrorMessages.unrecognizedCommandError();
+                    }
+            }
+        }
+    }
+    public static void main(String[] args) {
+        try {
+            new Dukey("data/dukey.txt").run();
+        } catch (IOException e) {
+            System.out.println("An error occurred: " + e.getMessage());
+        }
+    }
+
+}
+
+
+