+ * The ToDo class inherits the 2 attributes from the Task class with an additional
+ * LocalDateTime attribute deadline. The deadline attribute represents the deadline
+ * by which the Deadline task has to be completed.
+ *
+ */
+public class Deadline extends Task {
+ LocalDateTime deadline;
+
+ /**
+ * Constructs a new Deadline object, with a default false
+ * value for isCompleted as tasks inputted into the task list are incomplete.
+ * Takes in a String name which is the name of the task as
+ * well as a String deadline in the format "dd/MM/yyyy HH:mm".
+ */
+ public Deadline(String name, String deadline) {
+ super(name);
+ this.isCompleted = false;
+ DateTimeFormatter formatter = DateTimeFormatter.ofPattern("dd/MM/yyyy HH:mm");
+ this.deadline = LocalDateTime.parse(deadline, formatter);
+ }
+
+ /**
+ * Overrides the toString() method inherited from the Task class.
+ * [D] to indicate that the task is a deadline.
+ * Deadline is formatted in 'yyyy-MM-dd HH:mm' to output.
+ */
+ @Override
+ public String toString() {
+ DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm");
+ String desiredFormat = this.deadline.format(formatter);
+ return "[D]" + super.toString() + "(by: " + desiredFormat + ")";
+ }
+}
+
+
diff --git a/src/main/java/Frenchie/DialogBox.java b/src/main/java/Frenchie/DialogBox.java
new file mode 100644
index 0000000000..d2c33813c2
--- /dev/null
+++ b/src/main/java/Frenchie/DialogBox.java
@@ -0,0 +1,63 @@
+package Frenchie;
+
+import java.io.IOException;
+import java.util.Collections;
+
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableList;
+import javafx.fxml.FXML;
+import javafx.fxml.FXMLLoader;
+import javafx.geometry.Pos;
+import javafx.scene.Node;
+import javafx.scene.control.Label;
+import javafx.scene.image.Image;
+import javafx.scene.image.ImageView;
+import javafx.scene.layout.HBox;
+
+/**
+ * An example of a custom control using FXML.
+ * This control represents a dialog box consisting of an ImageView to represent the speaker's face and a label
+ * containing text from the speaker.
+ */
+public class DialogBox extends HBox {
+ @FXML
+ private Label dialog;
+ @FXML
+ private ImageView displayPicture;
+
+ private DialogBox(String text, Image img) {
+ try {
+ FXMLLoader fxmlLoader = new FXMLLoader(MainWindow.class.getResource("/view/DialogBox.fxml"));
+ fxmlLoader.setController(this);
+ fxmlLoader.setRoot(this);
+ fxmlLoader.load();
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+
+ dialog.setText(text);
+ displayPicture.setImage(img);
+ }
+
+ /**
+ * Flips the dialog box such that the ImageView is on the left and text on the right.
+ */
+ private void flip() {
+ ObservableList tmp = FXCollections.observableArrayList(this.getChildren());
+ Collections.reverse(tmp);
+ getChildren().setAll(tmp);
+ setAlignment(Pos.TOP_LEFT);
+ }
+
+ public static DialogBox getUserDialog(String text, Image img) {
+ return new DialogBox(text, img);
+ }
+
+ public static DialogBox getFrenchieDialog(String text, Image img) {
+ var db = new DialogBox(text, img);
+ db.flip();
+ return db;
+ }
+}
+
+
diff --git a/src/main/java/Frenchie/Event.java b/src/main/java/Frenchie/Event.java
new file mode 100644
index 0000000000..7fb0df978e
--- /dev/null
+++ b/src/main/java/Frenchie/Event.java
@@ -0,0 +1,44 @@
+package Frenchie;
+
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+
+/**
+ * Represents an Event that inherits from the Task class.
+ *
+ * The Event class has 2 additional LocalDateTime attributes startTime and endTime
+ * which represent the time the event starts and ends respectively.
+ *
+ */
+public class Event extends Task {
+ LocalDateTime startTime;
+ LocalDateTime endTime;
+
+ /**
+ * Constructs a new Event object, with a default false value for isCompleted
+ * as all tasks inputted into the task list are incomplete.
+ * Takes in a String which is the name of the task.
+ * Takes in String startTime and String endTime in the format "dd/MM/yyyy HH:mm"
+ * which is then parsed into a formatter and stored as LocalDateTime objects.
+ */
+ public Event(String name, String startTime, String endTime) {
+ this.taskName = name;
+ DateTimeFormatter formatter = DateTimeFormatter.ofPattern("dd/MM/yyyy HH:mm");
+ this.startTime = LocalDateTime.parse(startTime, formatter);
+ this.endTime = LocalDateTime.parse(endTime, formatter);
+ this.isCompleted = false;
+ }
+
+ /**
+ * Overrides the toString() method inherited from the Task class.
+ * [E] to indicate that the task is an Event.
+ * startTime and endTime is formatted in 'yyyy-MM-dd HH:mm' to output.
+ */
+ @Override
+ public String toString() {
+ DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm");
+ String desiredStartFormat = this.startTime.format(formatter);
+ String desiredEndFormat = this.endTime.format(formatter);
+ return "[E]" + super.toString() + "(from: " + desiredStartFormat + " to: " + desiredEndFormat + ")";
+ }
+}
diff --git a/src/main/java/Frenchie/Frenchie.java b/src/main/java/Frenchie/Frenchie.java
new file mode 100644
index 0000000000..5da5ca4b26
--- /dev/null
+++ b/src/main/java/Frenchie/Frenchie.java
@@ -0,0 +1,189 @@
+package Frenchie;
+
+
+import javafx.animation.KeyFrame;
+import javafx.animation.Timeline;
+import javafx.application.Application;
+import javafx.application.Platform;
+import javafx.scene.Scene;
+import javafx.scene.control.Button;
+import javafx.scene.control.ScrollPane;
+import javafx.scene.control.TextField;
+import javafx.scene.image.Image;
+import javafx.scene.layout.AnchorPane;
+import javafx.scene.layout.Region;
+import javafx.scene.layout.VBox;
+import javafx.stage.Stage;
+import javafx.util.Duration;
+
+
+public class Frenchie extends Application {
+ private TaskList tasks;
+ private Storage storage;
+ private Ui ui;
+ private ScrollPane scrollPane;
+ private VBox dialogContainer;
+ private TextField userInput;
+ private Button sendButton;
+ private Scene scene;
+
+ public Frenchie() {
+ this.storage = new Storage("frenchie.txt");
+ this.ui = new Ui();
+ this.tasks = new TaskList();
+ }
+ public Frenchie(String filepath) {
+ this.storage = new Storage(filepath);
+ this.ui = new Ui();
+ try {
+ this.tasks = storage.load();
+ } catch (FrenchieException e) {
+ tasks = new TaskList();
+ }
+ }
+ public void start(Stage stage) {
+ //Step 1. Setting up required components
+
+ //The container for the content of the chat to scroll.
+ scrollPane = new ScrollPane();
+ dialogContainer = new VBox();
+ scrollPane.setContent(dialogContainer);
+
+ userInput = new TextField();
+ sendButton = new Button("Send");
+
+ AnchorPane mainLayout = new AnchorPane();
+ mainLayout.getChildren().addAll(scrollPane, userInput, sendButton);
+
+ scene = new Scene(mainLayout);
+ stage.setScene(scene);
+ stage.show();
+
+ //Step 2. Formatting the window to look as expected
+ stage.setTitle("Frenchie");
+ stage.setResizable(false);
+ stage.setMinHeight(600.0);
+ stage.setMinWidth(400.0);
+
+ mainLayout.setPrefSize(400.0, 600.0);
+
+ scrollPane.setPrefSize(385, 535);
+ scrollPane.setHbarPolicy(ScrollPane.ScrollBarPolicy.NEVER);
+ scrollPane.setVbarPolicy(ScrollPane.ScrollBarPolicy.ALWAYS);
+
+ scrollPane.setVvalue(1.0);
+ scrollPane.setFitToWidth(true);
+
+ // You will need to import `javafx.scene.layout.Region` for this.
+ dialogContainer.setPrefHeight(Region.USE_COMPUTED_SIZE);
+ userInput.setPrefWidth(325.0);
+ sendButton.setPrefWidth(55.0);
+
+ AnchorPane.setTopAnchor(scrollPane, 1.0);
+ AnchorPane.setBottomAnchor(sendButton, 1.0);
+ AnchorPane.setRightAnchor(sendButton, 1.0);
+ AnchorPane.setLeftAnchor(userInput , 1.0);
+ AnchorPane.setBottomAnchor(userInput, 1.0);
+
+ //Step 3. Add functionality to handle user input.
+ sendButton.setOnMouseClicked((event) -> {
+ //handleUserInput();
+ });
+ userInput.setOnAction((event) -> {
+ //handleUserInput();
+ });
+ //Scroll down to the end every time dialogContainer's height changes.
+ dialogContainer.heightProperty().addListener((observable) -> scrollPane.setVvalue(1.0));
+ }
+
+
+ public String getResponse(String input) {
+ StringBuilder output = new StringBuilder();
+ try {
+ tasks = storage.load();
+ } catch (FrenchieException e) {
+ // Handle the exception if loading fails, e.g., display an error message
+ output.append("Error loading tasks from storage.\n");
+ }
+ Command command = Parser.parseCommand(input);
+ String details = Parser.parseDetails(input);
+
+ switch (command) {
+ case bye:
+ storage.save(tasks);
+ ui.closeScanner();
+ output.append(this.exit());
+ Timeline exitDelay = new Timeline(new KeyFrame(Duration.seconds(2), event -> Platform.exit()));
+ exitDelay.setCycleCount(1);
+ exitDelay.play();
+ break;
+ case list:
+ output.append(this.listTasks());
+ return output.toString();
+ case mark:
+ int index = Integer.parseInt(details) - 1;
+ tasks.markTaskAsCompleted(index);
+ output.append(ui.markTaskAsComplete(tasks.get(index)));
+ storage.save(tasks);
+ return output.toString();
+ case unmark:
+ index = Integer.parseInt(details) - 1;
+ tasks.markTaskAsIncomplete(index);
+ output.append(ui.markTaskAsIncompelte(tasks.get(index)));
+ storage.save(tasks);
+ return output.toString();
+ case delete:
+ index = Integer.parseInt(details) - 1;
+ Task task = tasks.get(index);
+ tasks.deleteTask(index);
+ output.append(ui.deleteTask(task, tasks));
+ storage.save(tasks);
+ return output.toString();
+ case todo:
+ String taskName = details;
+ ToDo todo = new ToDo(taskName);
+ tasks.addTask(todo);
+ output.append(ui.addTask(todo, tasks));
+ storage.save(tasks);
+ return output.toString();
+ case deadline:
+ taskName = details.split("/by")[0].trim();
+ String deadlineDate = details.split("/by")[1].trim();
+ Deadline deadline = new Deadline(taskName, deadlineDate);
+ tasks.addTask(deadline);
+ output.append(ui.addTask(deadline, tasks));
+ storage.save(tasks);
+ return output.toString();
+ case event:
+ taskName = details.split("/")[0].trim();
+ String startTime = details.split("/from")[1].split("/to")[0].trim();
+ String endTime = input.split("/from")[1].split("/to")[1].trim();
+ Event event = new Event(taskName, startTime, endTime);
+ tasks.addTask(event);
+ output.append(ui.addTask(event, tasks));
+ storage.save(tasks);
+ return output.toString();
+ case find:
+ String keyword = details;
+ output.append(ui.findMessage());
+ output.append(tasks.returnMatchTasks(keyword));
+ return output.toString();
+ case help:
+ output.append(ui.helpMessage());
+ return output.toString();
+ default:
+ return "OOPS!!! That is an invalid command!\n "
+ + "NOTE: Dates have to be entered in the dd/MM/yyyy HH:mm format!";
+ }
+ return output.toString();
+ }
+
+ public String exit() {
+ return ui.exitMessage();
+ }
+
+ public String listTasks() {
+ return ui.listTasks(tasks);
+ }
+
+}
diff --git a/src/main/java/Frenchie/FrenchieException.java b/src/main/java/Frenchie/FrenchieException.java
new file mode 100644
index 0000000000..ce960f3931
--- /dev/null
+++ b/src/main/java/Frenchie/FrenchieException.java
@@ -0,0 +1,7 @@
+package Frenchie;
+
+public class FrenchieException extends Exception {
+ public FrenchieException(String message) {
+ super(message);
+ }
+}
diff --git a/src/main/java/Frenchie/Launcher.java b/src/main/java/Frenchie/Launcher.java
new file mode 100644
index 0000000000..86753f9962
--- /dev/null
+++ b/src/main/java/Frenchie/Launcher.java
@@ -0,0 +1,12 @@
+package Frenchie;
+
+import javafx.application.Application;
+
+/**
+ * A launcher class to workaround classpath issues.
+ */
+public class Launcher {
+ public static void main(String[] args) {
+ Application.launch(Main.class, args);
+ }
+}
diff --git a/src/main/java/Frenchie/Main.java b/src/main/java/Frenchie/Main.java
new file mode 100644
index 0000000000..65c4f65100
--- /dev/null
+++ b/src/main/java/Frenchie/Main.java
@@ -0,0 +1,32 @@
+package Frenchie;
+
+import java.io.IOException;
+
+import javafx.application.Application;
+import javafx.fxml.FXMLLoader;
+import javafx.scene.Scene;
+import javafx.scene.layout.AnchorPane;
+import javafx.stage.Stage;
+
+/**
+ * A GUI for Duke using FXML.
+ */
+public class Main extends Application {
+
+ private Frenchie frenchie = new Frenchie();
+
+ @Override
+ public void start(Stage stage) {
+ try {
+ FXMLLoader fxmlLoader = new FXMLLoader(Main.class.getResource("/view/MainWindow.fxml"));
+ AnchorPane ap = fxmlLoader.load();
+ Scene scene = new Scene(ap);
+ stage.setScene(scene);
+ fxmlLoader.getController().setFrenchie(frenchie);
+ stage.show();
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ }
+}
+
diff --git a/src/main/java/Frenchie/MainWindow.java b/src/main/java/Frenchie/MainWindow.java
new file mode 100644
index 0000000000..97e613621d
--- /dev/null
+++ b/src/main/java/Frenchie/MainWindow.java
@@ -0,0 +1,55 @@
+package Frenchie;
+
+import javafx.fxml.FXML;
+import javafx.scene.control.Button;
+import javafx.scene.control.ScrollPane;
+import javafx.scene.control.TextField;
+import javafx.scene.image.Image;
+import javafx.scene.layout.AnchorPane;
+import javafx.scene.layout.VBox;
+/**
+ * Controller for MainWindow. Provides the layout for the other controls.
+ */
+public class MainWindow extends AnchorPane {
+ @FXML
+ private ScrollPane scrollPane;
+ @FXML
+ private VBox dialogContainer;
+ @FXML
+ private TextField userInput;
+ @FXML
+ private Button sendButton;
+
+ private Frenchie frenchie;
+
+ private Image userImage = new Image(this.getClass().getResourceAsStream("/images/FrenchieUser.jpg"));
+ private Image frenchieImage = new Image(this.getClass().getResourceAsStream("/images/FrenchieBot.jpeg"));
+
+ @FXML
+ public void initialize() {
+ scrollPane.vvalueProperty().bind(dialogContainer.heightProperty());
+ }
+
+ public void setFrenchie(Frenchie frenchie) {
+
+ this.frenchie = frenchie;
+ String openingMessage = " Hello! I'm Frenchie.\n"
+ + " What can I do for you?\n";
+ dialogContainer.getChildren().addAll(DialogBox.getFrenchieDialog(openingMessage, frenchieImage));
+ }
+
+ /**
+ * Creates two dialog boxes, one echoing user input and the other containing Duke's reply and then appends them to
+ * the dialog container. Clears the user input after processing.
+ */
+ @FXML
+ private void handleUserInput() throws FrenchieException {
+ String input = userInput.getText();
+ String response = frenchie.getResponse(input);
+ dialogContainer.getChildren().addAll(
+ DialogBox.getUserDialog(input, userImage),
+ DialogBox.getFrenchieDialog(response, frenchieImage)
+ );
+ userInput.clear();
+ }
+}
diff --git a/src/main/java/Frenchie/Parser.java b/src/main/java/Frenchie/Parser.java
new file mode 100644
index 0000000000..c15a152acc
--- /dev/null
+++ b/src/main/java/Frenchie/Parser.java
@@ -0,0 +1,57 @@
+package Frenchie;
+
+/**
+ * This is a Parser object responsible for handling user input.
+ *
+ * This parser object interprets the user input based on the Command enums.
+ *
+ */
+public class Parser {
+ /**
+ * This method takes in the user's input to the chatbot and splits it to return the Command.
+ * @param input user input to the Frenchie Chatbot
+ * @return respective Command from the input string
+ */
+ public static Command parseCommand(String input) {
+
+ String[] parts = input.split(" ");
+ String command = parts[0];
+
+ switch (command) {
+ case "list":
+ return Command.list;
+ case "mark":
+ return Command.mark;
+ case "unmark":
+ return Command.unmark;
+ case "todo":
+ return Command.todo;
+ case "deadline":
+ return Command.deadline;
+ case "event":
+ return Command.event;
+ case "bye":
+ return Command.bye;
+ case "delete":
+ return Command.delete;
+ case "find":
+ return Command.find;
+ case "help":
+ return Command.help;
+ default:
+ return Command.invalid;
+ }
+ }
+
+ /**
+ * This method takes in the user's input to the chatbot and splits it to obtain the details
+ * of the task: Task Name, Deadline, StartTime and EndTime if applicable.
+ *
+ * @param input user input to the Frenchie Chatbot.
+ * @return String containing all details of the task.
+ */
+ public static String parseDetails(String input) {
+ String[] parts = input.split(" ", 2);
+ return (parts.length > 1) ? parts[1] : "";
+ }
+}
diff --git a/src/main/java/Frenchie/Storage.java b/src/main/java/Frenchie/Storage.java
new file mode 100644
index 0000000000..b1e9c76fd8
--- /dev/null
+++ b/src/main/java/Frenchie/Storage.java
@@ -0,0 +1,76 @@
+package Frenchie;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+
+
+public class Storage {
+ private String filePath;
+
+ public Storage() { this.filePath = ""; }
+ public Storage(String filePath) {
+ this.filePath = filePath;
+ }
+ public TaskList load() throws FrenchieException {
+ TaskList loadedTasks = new TaskList();
+ try (BufferedReader reader = new BufferedReader(new FileReader(filePath))) {
+ String input;
+ while ((input = reader.readLine()) != null) {
+ String taskType = Character.toString(input.charAt(1));
+ String taskStatus = Character.toString(input.charAt(4));
+ String taskDetails = input.substring(7);
+ if (taskType.equals("T")) {
+ ToDo currentTask = new ToDo(taskDetails);
+ if (taskStatus.equals("X")) {
+ currentTask.setIsCompleted();
+ }
+ loadedTasks.addTask(currentTask);
+ } else if (taskType.equals("D")) {
+ String taskName = taskDetails.split("\\(")[0].trim();
+ String deadline = taskDetails.split("\\(by: ")[1].split("\\)")[0];
+ DateTimeFormatter inputFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm");
+ LocalDateTime storedDeadline = LocalDateTime.parse(deadline, inputFormatter);
+ DateTimeFormatter desiredFormatter = DateTimeFormatter.ofPattern("dd/MM/yyyy HH:mm");
+ String constructorDeadline = storedDeadline.format(desiredFormatter);
+ Deadline currentTask = new Deadline(taskName, constructorDeadline);
+ if (taskStatus.equals("X")) {
+ currentTask.setIsCompleted();
+ }
+ loadedTasks.addTask(currentTask);
+ } else if (taskType.equals("E")) {
+ String taskName = taskDetails.split("\\(")[0].trim();
+ String startTime = taskDetails.split("\\(")[1].split("from: ")[1].split(" to")[0];
+ String endTime = taskDetails.split("\\(")[1].split("to: ")[1].split("\\)")[0];
+ DateTimeFormatter inputFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm");
+ LocalDateTime storedStartTime = LocalDateTime.parse(startTime, inputFormatter);
+ LocalDateTime storedEndTime = LocalDateTime.parse(endTime, inputFormatter);
+ DateTimeFormatter desiredFormatter = DateTimeFormatter.ofPattern("dd/MM/yyyy HH:mm");
+ String constructorStartTime = storedStartTime.format(desiredFormatter);
+ String constructorEndTime = storedEndTime.format(desiredFormatter);
+ Event currentTask = new Event(taskName, constructorStartTime, constructorEndTime);
+ if (taskStatus.equals("X")) {
+ currentTask.setIsCompleted();
+ }
+ loadedTasks.addTask(currentTask);
+ }
+ }
+ } catch (IOException e) {
+ throw new FrenchieException("Error loading tasks");
+ }
+ return loadedTasks;
+ }
+
+ public void save(TaskList taskList) {
+ try (PrintWriter writer = new PrintWriter("frenchie.txt")) {
+ for (Task task : taskList.tasks) {
+ writer.println(task.toString());
+ }
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ }
+}
diff --git a/src/main/java/Frenchie/Task.java b/src/main/java/Frenchie/Task.java
new file mode 100644
index 0000000000..2d84cfa027
--- /dev/null
+++ b/src/main/java/Frenchie/Task.java
@@ -0,0 +1,58 @@
+package Frenchie;
+
+/**
+ * Represents a Task that is stored in the Task list of the Frenchie chatbot.
+ *
+ * The task class has 2 attributes, isCompleted and taskName.
+ * isCompleted is a boolean attribute, returning true if the task has been completed
+ * and false if the task is incomplete.
+ * taskName is a String that stores the name of the task, such as 'Read Book'.
+ *
+ */
+public class Task {
+ public boolean isCompleted;
+ public String taskName;
+
+
+ public Task() {
+ isCompleted = false;
+ }
+ /**
+ * Constructs a new Task object, with a default false value for
+ * isCompleted as tasks inputted into the task list are incomplete.
+ * Takes in a String which is the name of the task.
+ */
+ public Task(String name) {
+ this.taskName = name;
+ isCompleted = false;
+ }
+
+ /**
+ * Marks Task as complete by setting the isCompleted attribute to true.
+ */
+ public void setIsCompleted() {
+ isCompleted = true;
+ }
+
+ /**
+ * Marks Task as incomplete by setting the isCompleted attribute to false.
+ */
+ public void setIsIncomplete() {
+ isCompleted = false;
+ }
+
+ /**
+ * Returns the isCompleted attribute to check if Task is completed.
+ */
+ public boolean checkCompletion() {
+ return isCompleted;
+ }
+ @Override
+ public String toString() {
+ String indicator = " ";
+ if (isCompleted) {
+ indicator = "X";
+ }
+ return "[" + indicator + "] " + taskName;
+ }
+}
diff --git a/src/main/java/Frenchie/TaskList.java b/src/main/java/Frenchie/TaskList.java
new file mode 100644
index 0000000000..0592f247e8
--- /dev/null
+++ b/src/main/java/Frenchie/TaskList.java
@@ -0,0 +1,55 @@
+package Frenchie;
+
+import java.util.ArrayList;
+
+public class TaskList {
+ public ArrayList tasks;
+
+ public TaskList() {
+ this.tasks = new ArrayList();
+ }
+
+ public String listTasks() {
+ int counter = 1;
+ StringBuilder output = new StringBuilder();
+ for (Task task : tasks) {
+ output.append(counter).append(". ").append(task.toString()).append("\n");
+ counter += 1;
+ }
+ return output.toString();
+ }
+
+ public Task get(int index) {
+ return this.tasks.get(index);
+ }
+ public void addTask(Task task) {
+ this.tasks.add(task);
+ }
+
+ public int size() {
+ return this.tasks.size();
+ }
+ public void deleteTask(int index) {
+ this.tasks.remove(index);
+ }
+
+ public void markTaskAsCompleted(int index) {
+ this.tasks.get(index).setIsCompleted();
+ }
+
+ public String returnMatchTasks(String keyword) {
+ int counter = 1;
+ StringBuilder output = new StringBuilder();
+ for (Task task: tasks) {
+ if (task.toString().contains(keyword)) {
+ output.append(counter).append(". ").append(task.toString()).append("\n");
+ counter += 1;
+ }
+ } return output.toString();
+ }
+ public void markTaskAsIncomplete(int index) {
+ this.tasks.get(index).setIsIncomplete();
+ }
+ // Other methods for updating tasks
+}
+
diff --git a/src/main/java/Frenchie/ToDo.java b/src/main/java/Frenchie/ToDo.java
new file mode 100644
index 0000000000..ced615bf22
--- /dev/null
+++ b/src/main/java/Frenchie/ToDo.java
@@ -0,0 +1,25 @@
+package Frenchie;
+
+/**
+ * Represents a ToDo that inherits from the Task superclass.
+ *
+ * The ToDo class is indicated with a [T] in its toString() method.
+ *
+ */
+public class ToDo extends Task {
+
+ /**
+ * Constructs a new ToDo object, with a default false value for isCompleted
+ * as tasks inputted into the task list are incomplete.
+ * Takes in a String which is the name of the task.
+ */
+ ToDo(String name) {
+ this.taskName = name;
+ this.isCompleted = false;
+ }
+
+ @Override
+ public String toString() {
+ return "[T]" + super.toString();
+ }
+}
diff --git a/src/main/java/Frenchie/Ui.java b/src/main/java/Frenchie/Ui.java
new file mode 100644
index 0000000000..bcb5a13776
--- /dev/null
+++ b/src/main/java/Frenchie/Ui.java
@@ -0,0 +1,102 @@
+package Frenchie;
+
+import java.util.Scanner;
+
+/**
+ * This Ui Class deals with handling the user input returning respective success messages
+ * depending on the user input.
+ * This Ui class has a private Scanner attribute that takes in User input.
+ */
+public class Ui {
+ private Scanner scanner;
+
+ /**
+ * Constructor that creates a new Ui object.
+ */
+ public Ui() {
+ this.scanner = new Scanner(System.in);
+ }
+
+ /**
+ * This method prints out all the tasks stored in a TaskList.
+ * @param tasks TaskList object that contains all the Tasks in an arraylist.
+ */
+ public String listTasks(TaskList tasks) {
+ return tasks.listTasks();
+ }
+
+ /**
+ * This method prints out the success message that a Task in a tasklist has been marked as completed.
+ * @param target_task the Task to be marked as completed.
+ */
+ public String markTaskAsComplete(Task target_task) {
+ return " Nice! I've marked this task as done: \n"
+ + target_task.toString() + "\n";
+ }
+
+ /**
+ * This method prints out the success message that a Task in a tasklist has been marked as incomplete.
+ * @param target_task the Task to be marked as incomplete.
+ */
+ public String markTaskAsIncompelte(Task target_task) {
+ return " OK, I've marked this task as not done yet: \n"
+ + target_task.toString() + "\n";
+ }
+
+ /**
+ * This method prints out the success message when a Task has been added to the TaskList.
+ * @param task the Task object to be added to the TaskList.
+ * @param taskList the Tasklist that the Task should be added to.
+ */
+ public String addTask(Task task, TaskList taskList) {
+ return " Got it! I've added this task: \n"
+ + task + "\n"
+ + "Now you have " + taskList.size() + " tasks in the list.\n";
+ }
+
+ /**
+ * This method prints out the success message when a Task has been removed from a TaskList.
+ * @param target_task the Task to be removed from the TaskList.
+ * @param taskList the TaskList that the Task should be removed from.
+ */
+ public String deleteTask(Task target_task, TaskList taskList) {
+ return "Noted. I've removed this task: \n"
+ + target_task.toString() + "\n"
+ + "Now you have " + taskList.size() + " tasks in the list.\n";
+ }
+
+ /**
+ * This method prints out the exit message when a user inputs 'bye'.
+ */
+ public String exitMessage() {
+ return "Bye. Hope to see you again soon!\n";
+ }
+
+ /**
+ * This method closes the Scanner of the Ui object when the chatbot should be closed.
+ */
+
+ public String findMessage() {
+ return "Here are the matching tasks in your list: \n";
+ }
+
+ public String helpMessage() {
+ String output = "Quickstart guide: \n"
+ + "You have 3 different tasks you can add to Frenchie: \n"
+ + " 1. todo taskname\n"
+ + " 2. deadline taskname /by dd/MM/yyyy HH:mm \n"
+ + " 3. event taskname /from dd/MM/yyyy HH:mm /to dd/MM/yyyy HH:mm \n"
+ + "Ensure you input the tasks in the above format for Frenchie to function as intended. \n"
+ + "Other functions include: \n"
+ + "list - To list all tasks stored in the TaskList \n"
+ + "mark taskIndex - mark the task of index taskIndex as done \n"
+ + "unmark taskIndex - mark the task of index taskIndex as incomplete \n"
+ + "delete taskIndex - delete the task of index taskIndex from the list \n"
+ + "find keyword - list out all tasks that contain the keyword in their task name";
+ return output;
+ }
+
+ public void closeScanner() {
+ scanner.close();
+ }
+}
diff --git a/src/main/resources/images/FrenchieBot.jpeg b/src/main/resources/images/FrenchieBot.jpeg
new file mode 100644
index 0000000000..3e7f30b45d
Binary files /dev/null and b/src/main/resources/images/FrenchieBot.jpeg differ
diff --git a/src/main/resources/images/FrenchieUser.jpg b/src/main/resources/images/FrenchieUser.jpg
new file mode 100644
index 0000000000..58d0b76b78
Binary files /dev/null and b/src/main/resources/images/FrenchieUser.jpg differ
diff --git a/src/main/resources/view/DialogBox.fxml b/src/main/resources/view/DialogBox.fxml
new file mode 100644
index 0000000000..59d16ac91a
--- /dev/null
+++ b/src/main/resources/view/DialogBox.fxml
@@ -0,0 +1,16 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/main/resources/view/MainWindow.fxml b/src/main/resources/view/MainWindow.fxml
new file mode 100644
index 0000000000..9c70ebdea9
--- /dev/null
+++ b/src/main/resources/view/MainWindow.fxml
@@ -0,0 +1,19 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/test/java/Frenchie/TaskTest.java b/src/test/java/Frenchie/TaskTest.java
new file mode 100644
index 0000000000..f6ebdbbf7e
--- /dev/null
+++ b/src/test/java/Frenchie/TaskTest.java
@@ -0,0 +1,13 @@
+package Frenchie;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+public class TaskTest {
+ @Test
+ public void markTaskCompleteTest() {
+ ToDo testTask = new ToDo("Test Task");
+ testTask.setIsCompleted();
+ assertTrue(testTask.checkCompletion());
+ }
+}
diff --git a/src/test/java/Frenchie/ToDoTest.java b/src/test/java/Frenchie/ToDoTest.java
new file mode 100644
index 0000000000..458f1570b6
--- /dev/null
+++ b/src/test/java/Frenchie/ToDoTest.java
@@ -0,0 +1,13 @@
+package Frenchie; //same package as the class being tested
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class ToDoTest {
+ @Test
+ public void ToDoConstructorTest() {
+ ToDo todo = new ToDo("Read Book");
+ assertEquals("[T][ ] Read Book", todo.toString());
+ }
+}
\ No newline at end of file
diff --git a/text-ui-test/runtest.sh b/text-ui-test/runtest.sh
old mode 100644
new mode 100755