[Barbaracwx] iP

README.md

@@ -1,6 +1,6 @@
-# Duke project template
+# 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.
+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. :)
 
 ## Setting up in Intellij
 

docs/README.md

@@ -1,29 +1,126 @@
-# User Guide
+# User Guide of Cara
+Cara: a fun and friendly task management bot that helps you to organise your task efficiently and easily :)
 
-## Features 
+### Task Management  
+- **Add Tasks**: Easily add different task types to your to-do list, such as Todo, Deadline, and Event.
+- **Mark Tasks as Done**: Mark tasks as completed when you've finished them.
+- **Delete Tasks**: Remove tasks that you no longer need.
+- **List Tasks**: View a list of all your tasks.
+- **Find Tasks**: Search for specific tasks using keywords.
 
-### Feature-ABC
+## Features
 
-Description of the feature.
+### 1. Add Todo Task - `todo` 
 
-### Feature-XYZ
+Add a todo task to the tasklist
 
-Description of the feature.
+Format: `todo DESCRIPTION`
 
-## Usage
+Example of usage: 
+
+```
+todo buy book
+todo return money 
+```
 
-### `Keyword` - Describe action
+### 2. Add Deadline Task - `deadline` 
 
-Describe the action and its outcome.
+Add a deadline task to the tasklist, with a date to complete by
+
+Format: `deadline DESCRIPTION /by DEADLINE`
 
 Example of usage: 
 
-`keyword (optional arguments)`
+```
+Deadline do homework /by 8 nov 2023
+```
+
+### 3. Add Event Task - `event` 
 
-Expected outcome:
+Add an event task to the tasklist, with a start and end time
 
-Description of the outcome.
+Format: `event DESCRIPTION /from STARTTIME /to ENDTIME`
+
+Example of usage: 
 
 ```
-expected output
+event concert /from 6pm /to 9pm
 ```
+
+### 4. Delete Task - `delete` 
+
+Delete a task from the tasklist base on index
+
+Format: `delete INDEX`
+
+- The index refers to the index number shown in the tasklist
+- the index **must be a positive integer** 1,2,3...
+
+Example of usage: 
+
+```
+delete 5
+```
+
+### 5. List Task - `list` 
+
+Shows a list of all tasks in the list
+
+Format: `list`
+
+Example of usage: 
+
+```
+list
+```
+
+### 6. Find Task - `find` 
+
+Find tasks that contains any of the keywords
+
+Format: `find KEYWORD`
+
+- The search is case-insensitive, e.g `Book` will match `book`
+
+Example of usage: 
+
+```
+find book
+```
+
+### 7. Mark Task - `mark` 
+
+Mark a task as done based on their index
+
+Format: `mark INDEX`
+
+Example of usage: 
+
+```
+mark 1
+```
+
+### 8. Unmark Task - `unmark` 
+
+Mark a task as not done based on their index
+
+Format: `unmark INDEX`
+
+Example of usage: 
+
+```
+unmark 1
+```
+
+### 9. Ending the program - `bye` 
+
+Exits the program
+
+Format: `bye`
+
+Example of usage: 
+
+```
+bye
+```
+

src/main/java/Cara/Cara.java

@@ -0,0 +1,67 @@
+package Cara;
+
+import Commands.Command;
+import Tasks.TaskList;
+
+import java.io.IOException;
+
+/**
+ * Duke is a task management program that allows users to manage their tasks.
+ * It provides functionality for adding, deleting, and listing tasks.
+ */
+public class Cara {
+    private Ui ui;
+    private TaskList tasks;
+    private Storage storage;
+
+    /**
+     * Constructs a Duke instance with the specified file path.
+     *
+     * @param filePath The path to the file used for task storage.
+     * @throws CaraException If there is an issue initializing Duke.
+     */
+    public Cara(String filePath) throws CaraException {
+        ui = new Ui();
+        storage = new Storage(filePath);
+        try {
+            tasks = new TaskList(storage.loadTasks());
+        } catch (CaraException | IOException e) {
+            ui.showLoadingError();
+            tasks = new TaskList();
+        }
+    }
+
+    /**
+     * Runs the Duke program, handling user input and executing commands.
+     */
+    public void run() {
+        ui.printWelcomeMessage();
+        boolean isExit = false;
+
+        while (!isExit) {
+            try {
+                String fullCommand = ui.readCommand();
+                ui.showLine();
+                Command c = Parser.parse(fullCommand);
+                c.execute(tasks.getTasks(), ui, storage);
+                isExit = c.isExit();
+                Storage.saveTasks(tasks.getTasks());
+            } catch (IOException | CaraException e) {
+                ui.showError(e.getMessage());
+            } finally {
+                ui.showLine();
+            }
+        }
+    }
+
+    /**
+     * The main entry point for running the Duke program.
+     *
+     * @param args The command-line arguments (not used in this program).
+     * @throws IOException   If an I/O error occurs.
+     * @throws CaraException If there is an issue with Duke initialization.
+     */
+    public static void main(String[] args) throws IOException, CaraException {
+        new Cara("data/tasks.txt").run();
+    }
+}

src/main/java/Cara/CaraException.java

@@ -0,0 +1,16 @@
+package Cara;
+
+/**
+ * DukeException is a custom exception class used to represent exceptions specific to the Duke program.
+ */
+public class CaraException extends Exception {
+
+    /**
+     * Constructs a DukeException with the specified error message.
+     *
+     * @param message The error message associated with the exception.
+     */
+    public CaraException(String message) {
+        super(message);
+    }
+}

src/main/java/Cara/Parser.java

@@ -0,0 +1,43 @@
+package Cara;
+
+import Commands.*;
+
+/**
+ * The Parser class is responsible for parsing user input and generating corresponding commands.
+ */
+public class Parser {
+
+    /**
+     * Parses the user input and returns the corresponding command.
+     *
+     * @param input The user input to be parsed.
+     * @return A Command object based on the parsed input.
+     * @throws CaraException If there is an issue with parsing the input.
+     */
+    public static Command parse(String input) throws CaraException {
+        // Split the input into words
+        String[] words = input.split(" ");
+        String command = words[0].toLowerCase(); // Extract the first word as the command
+
+        switch (command) {
+        case "bye":
+            return new ExitCommand(); // Create an ExitCommand
+        case "list":
+            return new ListCommand(); // Create a ListCommand
+        case "mark":
+            return new MarkCommand(input); // Create a MarkCommand with the input as a parameter
+        case "unmark":
+            return new UnmarkCommand(input); // Create an UnmarkCommand with the input as a parameter
+        case "delete":
+            return new DeleteCommand(input); // Create a DeleteCommand with the input as a parameter
+        case "find":
+            return new FindCommand(input); // Create a FindCommand with the input as a parameter
+        case "todo":
+        case "event":
+        case "deadline":
+            return new AddCommand(input); //Create a AddCommand with the input as a parameter
+        default:
+            throw new CaraException(" ☹ OOPS!!! I'm sorry, but I don't know what that means :-(");
+        }
+    }
+}

src/main/java/Cara/Storage.java

@@ -0,0 +1,44 @@
+package Cara;
+
+import Tasks.Task;
+import Tasks.TasksHandler;
+
+import java.io.*;
+import java.util.ArrayList;
+
+/**
+ * The Storage class is responsible for loading and saving tasks from/to a file.
+ */
+public class Storage {
+
+    /**
+     * Constructs a Storage instance with the specified file path (ignored).
+     *
+     * @param ignoredFilePath The path to the file (ignored).
+     */
+    public Storage(String ignoredFilePath) {
+    }
+
+    /**
+     * Loads tasks from a file and returns them as an ArrayList.
+     *
+     * @return An ArrayList of tasks loaded from the file.
+     * @throws IOException   If an I/O error occurs during file reading.
+     * @throws CaraException If there is an issue with Duke while reading the file.
+     */
+    public ArrayList<Task> loadTasks() throws IOException, CaraException {
+        ArrayList<Task> tasks = new ArrayList<>();
+        TasksHandler.readFromFile(tasks); // Pass an ArrayList<Task> to the readFromFile() method
+        return tasks;
+    }
+
+    /**
+     * Saves tasks to a file.
+     *
+     * @param tasks The ArrayList of tasks to be saved to the file.
+     * @throws IOException If an I/O error occurs during file writing.
+     */
+    public static void saveTasks(ArrayList<Task> tasks) throws IOException {
+        TasksHandler.writeToFile(tasks); // Pass the provided ArrayList<Task> to the writeToFile method
+    }
+}