From 61697851723d68941506ba9bf3671aa002d38f65 Mon Sep 17 00:00:00 2001 From: Gujimugger Date: Fri, 27 Jan 2023 10:42:31 +0800 Subject: [PATCH 01/19] Level 0: adding greetLine and exitLine --- src/main/java/Duke.java | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/src/main/java/Duke.java b/src/main/java/Duke.java index 5d313334c..8f0b8d3e2 100644 --- a/src/main/java/Duke.java +++ b/src/main/java/Duke.java @@ -6,5 +6,14 @@ public static void main(String[] args) { + "| |_| | |_| | < __/\n" + "|____/ \\__,_|_|\\_\\___|\n"; System.out.println("Hello from\n" + logo); + greetLine(); + exitLine(); + } + public static void greetLine(){ + System.out.println("How may I be of service?"); + } + + public static void exitLine(){ + System.out.println("Glad I could be of help!"); } } From d047c4ea218930a279de4f6128a4f47525736171 Mon Sep 17 00:00:00 2001 From: Gujimugger Date: Fri, 27 Jan 2023 11:00:50 +0800 Subject: [PATCH 02/19] Level 1: Adding echo function --- src/main/java/Duke.java | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/src/main/java/Duke.java b/src/main/java/Duke.java index 8f0b8d3e2..0de6a353e 100644 --- a/src/main/java/Duke.java +++ b/src/main/java/Duke.java @@ -1,3 +1,5 @@ +import java.util.Scanner; + public class Duke { public static void main(String[] args) { String logo = " ____ _ \n" @@ -7,12 +9,20 @@ public static void main(String[] args) { + "|____/ \\__,_|_|\\_\\___|\n"; System.out.println("Hello from\n" + logo); greetLine(); + echo(); exitLine(); } public static void greetLine(){ System.out.println("How may I be of service?"); } - + public static void echo(){ + String line = " "; + Scanner in = new Scanner(System.in); + while(!line.equals("bye")) { + line = in.nextLine(); + System.out.println(line); + } + } public static void exitLine(){ System.out.println("Glad I could be of help!"); } From b1f348108572330d72028a67a1b90125663a49dc Mon Sep 17 00:00:00 2001 From: Gujimugger Date: Fri, 27 Jan 2023 15:04:06 +0800 Subject: [PATCH 03/19] Level 1,2: Rectify mistake in echo, where "bye" will also be echoed. Complete level 2. --- src/main/java/Duke.java | 35 +++++++++++++++++++++++++++++++---- 1 file changed, 31 insertions(+), 4 deletions(-) diff --git a/src/main/java/Duke.java b/src/main/java/Duke.java index 0de6a353e..9acd302a8 100644 --- a/src/main/java/Duke.java +++ b/src/main/java/Duke.java @@ -1,3 +1,4 @@ +import java.util.Arrays; import java.util.Scanner; public class Duke { @@ -9,21 +10,47 @@ public static void main(String[] args) { + "|____/ \\__,_|_|\\_\\___|\n"; System.out.println("Hello from\n" + logo); greetLine(); - echo(); + addList(); exitLine(); } public static void greetLine(){ System.out.println("How may I be of service?"); } - public static void echo(){ - String line = " "; + public static void echo() + { + String line; Scanner in = new Scanner(System.in); + line = in.nextLine(); while(!line.equals("bye")) { - line = in.nextLine(); System.out.println(line); + line = in.nextLine(); } } public static void exitLine(){ System.out.println("Glad I could be of help!"); } + + public static void addList() + { + String[] list = new String[100]; + String line; + Scanner in = new Scanner(System.in); + line = in.nextLine(); + int numOfItems = 0; + while(!line.equals("bye")) { + if(line.equals("list")) { // users wants to know all text so far + String[] subList = Arrays.copyOf(list, numOfItems); + for(int i = 0; i < subList.length; ++i) + { + System.out.println(subList[i]); + } + } + else { // text from user + String item = (numOfItems + 1) + ". " + line; // convert to 1-based + list[numOfItems] = item; + ++numOfItems; + } + line = in.nextLine(); + } + } } From e45b36bc2b20e9efc53b2371a98bca4751fed2c2 Mon Sep 17 00:00:00 2001 From: Gujimugger Date: Fri, 27 Jan 2023 19:45:07 +0800 Subject: [PATCH 04/19] Level 3: Complete level 3, add in printCurrentList function. --- src/main/java/Duke.java | 45 ++++++++++++++++++++++++++++++++++------- 1 file changed, 38 insertions(+), 7 deletions(-) diff --git a/src/main/java/Duke.java b/src/main/java/Duke.java index 9acd302a8..d26017db6 100644 --- a/src/main/java/Duke.java +++ b/src/main/java/Duke.java @@ -39,18 +39,49 @@ public static void addList() int numOfItems = 0; while(!line.equals("bye")) { if(line.equals("list")) { // users wants to know all text so far - String[] subList = Arrays.copyOf(list, numOfItems); - for(int i = 0; i < subList.length; ++i) - { - System.out.println(subList[i]); - } + printCurrentList(list, numOfItems); + } + else if(line.startsWith("mark")){ + mark(line, list); + printCurrentList(list, numOfItems); + } + else if(line.startsWith("unmark")){ + unmark(line,list); + printCurrentList(list, numOfItems); } else { // text from user - String item = (numOfItems + 1) + ". " + line; // convert to 1-based + String item = (numOfItems + 1) + ".[ ] " + line; // convert to 1-based list[numOfItems] = item; ++numOfItems; } - line = in.nextLine(); + line = in.nextLine(); // read in next line of text + } + } + + public static void mark(String task, String[] list) + { + String locationOfTask = task.substring(5); // get the number of task to be marked + String taskToBeMarked = list[Integer.parseInt(locationOfTask) - 1]; + String taskMarked = taskToBeMarked.replace("[ ]", "[X]"); + list[Integer.parseInt(locationOfTask) - 1] = taskMarked; + System.out.println("Sir, your task has been marked as completed."); + } + + public static void unmark(String task, String[] list) + { + String locationOfTask = task.substring(7); + String taskToBeUnmarked = list[Integer.parseInt(locationOfTask) - 1]; + String taskUnmarked = taskToBeUnmarked.replace("[X]", "[ ]"); + list[Integer.parseInt(locationOfTask) - 1] = taskUnmarked; + System.out.println("Sir, your task has been unmarked as requested."); + } + + public static void printCurrentList(String[] list, int numOfItems) + { + String[] subList = Arrays.copyOf(list, numOfItems); + for(int i = 0; i < subList.length; ++i) + { + System.out.println(subList[i]); } } } From fbf03b079bdb19d33c2bc883f0610e3add5687a5 Mon Sep 17 00:00:00 2001 From: Gujimugger Date: Fri, 3 Feb 2023 10:38:17 +0800 Subject: [PATCH 05/19] Level 4 complete --- README.md | 4 ++++ src/main/java/Deadlines.java | 23 ++++++++++++++++++ src/main/java/Duke.java | 46 ++++++++++++++++++++++-------------- src/main/java/Events.java | 33 ++++++++++++++++++++++++++ src/main/java/Task.java | 31 ++++++++++++++++++++++++ src/main/java/ToDos.java | 11 +++++++++ text-ui-test/EXPECTED.TXT | 2 ++ text-ui-test/input.txt | 2 ++ 8 files changed, 134 insertions(+), 18 deletions(-) create mode 100644 src/main/java/Deadlines.java create mode 100644 src/main/java/Events.java create mode 100644 src/main/java/Task.java create mode 100644 src/main/java/ToDos.java diff --git a/README.md b/README.md index 8715d4d91..6095ffb21 100644 --- a/README.md +++ b/README.md @@ -21,4 +21,8 @@ Prerequisites: JDK 11, update Intellij to the most recent version. | | | | | | | |/ / _ \ | |_| | |_| | < __/ |____/ \__,_|_|\_\___| + + ``` + +wang silang diff --git a/src/main/java/Deadlines.java b/src/main/java/Deadlines.java new file mode 100644 index 000000000..b3b4f8576 --- /dev/null +++ b/src/main/java/Deadlines.java @@ -0,0 +1,23 @@ +public class Deadlines extends Task { + private String endTime; + private String taskLabel = "[D]"; + public Deadlines (String input){ + super(input.substring(9,input.indexOf('/') - 1)); // Sanitize input by removing "deadline" at the start + super.setTaskLabel(taskLabel); + endTime = "(" + getEndTime(input) + ")"; + } + // Method of StringBuffer operation taken from + // https://www.geeksforgeeks.org/insert-a-string-into-another-string-in-java/ + @Override + public String getEndTime(String input){ + String deadline = input.substring(input.indexOf('/') + 1); // endTime of task is the string after '/' + StringBuffer deadlineCorrectFormat = new StringBuffer(deadline); // convert to StringBuffer for inserting ':' + deadlineCorrectFormat.insert(2,":"); + return deadlineCorrectFormat.toString(); + } + + @Override + public String toString(){ + return this.taskLabel + this.mark + " " + this.description + " " + this.endTime; + } +} diff --git a/src/main/java/Duke.java b/src/main/java/Duke.java index d26017db6..7cfdc7a5d 100644 --- a/src/main/java/Duke.java +++ b/src/main/java/Duke.java @@ -1,3 +1,5 @@ +import jdk.jfr.Event; + import java.util.Arrays; import java.util.Scanner; @@ -32,12 +34,12 @@ public static void exitLine(){ public static void addList() { - String[] list = new String[100]; + Task[] list = new Task[100]; String line; Scanner in = new Scanner(System.in); line = in.nextLine(); int numOfItems = 0; - while(!line.equals("bye")) { + while(!line.equals("bye")) { // condition to shut down program if(line.equals("list")) { // users wants to know all text so far printCurrentList(list, numOfItems); } @@ -49,39 +51,47 @@ else if(line.startsWith("unmark")){ unmark(line,list); printCurrentList(list, numOfItems); } - else { // text from user - String item = (numOfItems + 1) + ".[ ] " + line; // convert to 1-based - list[numOfItems] = item; + else { // new tasks keyed in by user + Task newTask = new Task(line); + if(line.startsWith("todo")){ + newTask = new ToDos(line); + } + else if(line.startsWith("deadline")){ + newTask = new Deadlines(line); + } + else{ + newTask = new Events(line); + } + list[numOfItems] = newTask; ++numOfItems; } line = in.nextLine(); // read in next line of text } } - public static void mark(String task, String[] list) + public static void mark(String task, Task[] list) { - String locationOfTask = task.substring(5); // get the number of task to be marked - String taskToBeMarked = list[Integer.parseInt(locationOfTask) - 1]; - String taskMarked = taskToBeMarked.replace("[ ]", "[X]"); - list[Integer.parseInt(locationOfTask) - 1] = taskMarked; + String indexOfTask = task.substring(5); // get the number of task to be marked + Task taskToBeMarked = list[Integer.parseInt(indexOfTask) - 1]; // convert from 1-based to 0-based + taskToBeMarked.markTask(); System.out.println("Sir, your task has been marked as completed."); } - public static void unmark(String task, String[] list) + public static void unmark(String task, Task[] list) { - String locationOfTask = task.substring(7); - String taskToBeUnmarked = list[Integer.parseInt(locationOfTask) - 1]; - String taskUnmarked = taskToBeUnmarked.replace("[X]", "[ ]"); - list[Integer.parseInt(locationOfTask) - 1] = taskUnmarked; + String indexOfTask = task.substring(7); + Task taskToBeMarked = list[Integer.parseInt(indexOfTask) - 1]; // convert from 1-based to 0-based + taskToBeMarked.unmarkTask(); System.out.println("Sir, your task has been unmarked as requested."); } - public static void printCurrentList(String[] list, int numOfItems) + public static void printCurrentList(Task[] list, int numOfItems) { - String[] subList = Arrays.copyOf(list, numOfItems); + Task[] subList = Arrays.copyOf(list, numOfItems); + System.out.println("Your current list of items as requested, sir."); for(int i = 0; i < subList.length; ++i) { - System.out.println(subList[i]); + System.out.println(Integer.toString(i+1) + "." + subList[i]); } } } diff --git a/src/main/java/Events.java b/src/main/java/Events.java new file mode 100644 index 000000000..23f91e82c --- /dev/null +++ b/src/main/java/Events.java @@ -0,0 +1,33 @@ +public class Events extends Task{ + private String timeLine; + private String taskLabel = "[E]"; + public Events (String input){ + super(input.substring(6,input.indexOf('/') - 1)); + super.setTaskLabel(taskLabel); + timeLine = "(" + getStartTime(input) + getEndTime(input) + ")"; + } + public String[] splitInput(String input){ + String[] inputAfterSplit = input.split("/", 3); // split twice to generate three strings + return inputAfterSplit; + } + @Override + public String getStartTime(String input){ + String[] inputAfterSplit = splitInput(input); + String startTime = inputAfterSplit[1]; + StringBuffer startTimeCorrectFormat = new StringBuffer(startTime); + startTimeCorrectFormat.insert(4,":"); + return startTimeCorrectFormat.toString(); + } + @Override + public String getEndTime(String input){ + String[] inputAfterSplit = splitInput(input); + String startTime = inputAfterSplit[2]; + StringBuffer endTimeCorrectFormat = new StringBuffer(startTime); // convert to StringBuffer for inserting ':' + endTimeCorrectFormat.insert(2,":"); + return endTimeCorrectFormat.toString(); + } + @Override + public String toString(){ + return this.taskLabel + this.mark + " " + this.description + " " + this.timeLine; + } +} diff --git a/src/main/java/Task.java b/src/main/java/Task.java new file mode 100644 index 000000000..15394430c --- /dev/null +++ b/src/main/java/Task.java @@ -0,0 +1,31 @@ +public class Task { + protected String taskLabel; + protected String description; + protected String mark; + public Task(String input) { + this.description = input; + this.taskLabel = "To be replaced by labels"; + this.mark = "[ ]"; + } + public String getTaskLabel() { + return taskLabel; + } + public String getDescription() { + return description; + } + public String getStartTime(String input){ + return "To be overridden by subclass' methods"; + } + public String getEndTime(String input){ + return "To be overridden by subclass' methods"; + } + public void setTaskLabel(String taskLabel) { + this.taskLabel = taskLabel; + } + public void markTask(){ + this.mark = "[X]"; + } + public void unmarkTask(){ + this.mark = "[ ]"; + } +} diff --git a/src/main/java/ToDos.java b/src/main/java/ToDos.java new file mode 100644 index 000000000..8c951e678 --- /dev/null +++ b/src/main/java/ToDos.java @@ -0,0 +1,11 @@ +public class ToDos extends Task { + private String taskLabel = "[T]"; + public ToDos (String input){ + super(input.substring(5)); // for ToDos tasks, description = input + super.setTaskLabel(taskLabel); + } + @Override + public String toString(){ + return this.taskLabel + this.mark + " " + this.description; + } +} diff --git a/text-ui-test/EXPECTED.TXT b/text-ui-test/EXPECTED.TXT index 657e74f6e..15687aa33 100644 --- a/text-ui-test/EXPECTED.TXT +++ b/text-ui-test/EXPECTED.TXT @@ -5,3 +5,5 @@ Hello from | |_| | |_| | < __/ |____/ \__,_|_|\_\___| +How may I be of service? +Glad I could be of help! diff --git a/text-ui-test/input.txt b/text-ui-test/input.txt index e69de29bb..441df48b6 100644 --- a/text-ui-test/input.txt +++ b/text-ui-test/input.txt @@ -0,0 +1,2 @@ +todo CS2113 assignment +bye \ No newline at end of file From 9ac72cfc7b62973f39be2ba8e4a420c67330c318 Mon Sep 17 00:00:00 2001 From: Gujimugger Date: Fri, 10 Feb 2023 01:23:14 +0800 Subject: [PATCH 06/19] Level 5 complete --- src/main/java/Deadlines.java | 17 +++-- src/main/java/Duke.java | 87 ++++++++++++----------- src/main/java/EmptyDeadlineException.java | 2 + src/main/java/EmptyEventsException.java | 2 + src/main/java/EmptyToDoException.java | 2 + src/main/java/Events.java | 28 +++++--- src/main/java/NullCommandException.java | 2 + src/main/java/ToDos.java | 12 +++- 8 files changed, 95 insertions(+), 57 deletions(-) create mode 100644 src/main/java/EmptyDeadlineException.java create mode 100644 src/main/java/EmptyEventsException.java create mode 100644 src/main/java/EmptyToDoException.java create mode 100644 src/main/java/NullCommandException.java diff --git a/src/main/java/Deadlines.java b/src/main/java/Deadlines.java index b3b4f8576..6b21cfba9 100644 --- a/src/main/java/Deadlines.java +++ b/src/main/java/Deadlines.java @@ -1,23 +1,30 @@ public class Deadlines extends Task { + private static final int DEADLINE_INDEX = 9; + private static final int COLON_INDEX = 2; private String endTime; private String taskLabel = "[D]"; - public Deadlines (String input){ - super(input.substring(9,input.indexOf('/') - 1)); // Sanitize input by removing "deadline" at the start + + public Deadlines(String input) throws EmptyDeadlineException{ + super(input.substring(DEADLINE_INDEX, input.indexOf('/') - 1)); // Sanitize input by removing "deadline" at the start super.setTaskLabel(taskLabel); endTime = "(" + getEndTime(input) + ")"; + if (input.substring(DEADLINE_INDEX, input.indexOf('/') - 1).isEmpty()) { + throw new EmptyDeadlineException(); + } } + // Method of StringBuffer operation taken from // https://www.geeksforgeeks.org/insert-a-string-into-another-string-in-java/ @Override - public String getEndTime(String input){ + public String getEndTime(String input) { String deadline = input.substring(input.indexOf('/') + 1); // endTime of task is the string after '/' StringBuffer deadlineCorrectFormat = new StringBuffer(deadline); // convert to StringBuffer for inserting ':' - deadlineCorrectFormat.insert(2,":"); + deadlineCorrectFormat.insert(COLON_INDEX, ":"); return deadlineCorrectFormat.toString(); } @Override - public String toString(){ + public String toString() { return this.taskLabel + this.mark + " " + this.description + " " + this.endTime; } } diff --git a/src/main/java/Duke.java b/src/main/java/Duke.java index 7cfdc7a5d..85944240f 100644 --- a/src/main/java/Duke.java +++ b/src/main/java/Duke.java @@ -1,5 +1,3 @@ -import jdk.jfr.Event; - import java.util.Arrays; import java.util.Scanner; @@ -15,83 +13,92 @@ public static void main(String[] args) { addList(); exitLine(); } - public static void greetLine(){ + + private static final int MARK_INDEX = 5; + private static final int UNMARK_INDEX = 7; + + public static void greetLine() { System.out.println("How may I be of service?"); } - public static void echo() - { + + public static void echo() { String line; Scanner in = new Scanner(System.in); line = in.nextLine(); - while(!line.equals("bye")) { + while (!line.equals("bye")) { System.out.println(line); line = in.nextLine(); } } - public static void exitLine(){ + + public static void exitLine() { System.out.println("Glad I could be of help!"); } - public static void addList() - { + public static void addList() { Task[] list = new Task[100]; String line; Scanner in = new Scanner(System.in); line = in.nextLine(); int numOfItems = 0; - while(!line.equals("bye")) { // condition to shut down program - if(line.equals("list")) { // users wants to know all text so far + while (!line.equals("bye")) { // condition to shut down program + if (line.equals("list")) { // users wants to know all text so far printCurrentList(list, numOfItems); - } - else if(line.startsWith("mark")){ + } else if (line.startsWith("mark")) { mark(line, list); printCurrentList(list, numOfItems); - } - else if(line.startsWith("unmark")){ - unmark(line,list); + } else if (line.startsWith("unmark")) { + unmark(line, list); printCurrentList(list, numOfItems); - } - else { // new tasks keyed in by user - Task newTask = new Task(line); - if(line.startsWith("todo")){ - newTask = new ToDos(line); - } - else if(line.startsWith("deadline")){ - newTask = new Deadlines(line); - } - else{ - newTask = new Events(line); + } else {// new tasks keyed in by user + try { + Task newTask = new Task(line); + if (line.startsWith("todo")) { + newTask = new ToDos(line); + } else if (line.startsWith("deadline")) { + newTask = new Deadlines(line); + } else if (line.startsWith("event")){ + newTask = new Events(line); + } else { + throw new NullCommandException(); + } + list[numOfItems] = newTask; + ++numOfItems; + } catch (EmptyToDoException e) { + System.out.println("Sire, you have yet to tell me what is it you want to do."); + } catch (EmptyDeadlineException e) { + System.out.println("Sire, what is it that is due your specified time?"); + } catch (EmptyEventsException e) { + System.out.println("Sire, your event is unclear. Please specify."); + } catch (StringIndexOutOfBoundsException e) { + System.out.println("Don't hold back Sire. I am here to serve."); + } catch (NullCommandException e) { + System.out.println("Sire, I am not trained to understand gibberish."); } - list[numOfItems] = newTask; - ++numOfItems; } line = in.nextLine(); // read in next line of text } } - public static void mark(String task, Task[] list) - { - String indexOfTask = task.substring(5); // get the number of task to be marked + public static void mark(String task, Task[] list) { + String indexOfTask = task.substring(MARK_INDEX); // get the number of task to be marked Task taskToBeMarked = list[Integer.parseInt(indexOfTask) - 1]; // convert from 1-based to 0-based taskToBeMarked.markTask(); System.out.println("Sir, your task has been marked as completed."); } - public static void unmark(String task, Task[] list) - { - String indexOfTask = task.substring(7); + public static void unmark(String task, Task[] list) { + String indexOfTask = task.substring(UNMARK_INDEX); Task taskToBeMarked = list[Integer.parseInt(indexOfTask) - 1]; // convert from 1-based to 0-based taskToBeMarked.unmarkTask(); System.out.println("Sir, your task has been unmarked as requested."); } - public static void printCurrentList(Task[] list, int numOfItems) - { + public static void printCurrentList(Task[] list, int numOfItems) { Task[] subList = Arrays.copyOf(list, numOfItems); System.out.println("Your current list of items as requested, sir."); - for(int i = 0; i < subList.length; ++i) - { - System.out.println(Integer.toString(i+1) + "." + subList[i]); + for (int i = 0; i < subList.length; ++i) { + System.out.println(Integer.toString(i + 1) + "." + subList[i]); } } } diff --git a/src/main/java/EmptyDeadlineException.java b/src/main/java/EmptyDeadlineException.java new file mode 100644 index 000000000..e4e3ac67d --- /dev/null +++ b/src/main/java/EmptyDeadlineException.java @@ -0,0 +1,2 @@ +public class EmptyDeadlineException extends Exception { +} diff --git a/src/main/java/EmptyEventsException.java b/src/main/java/EmptyEventsException.java new file mode 100644 index 000000000..4ae4c8325 --- /dev/null +++ b/src/main/java/EmptyEventsException.java @@ -0,0 +1,2 @@ +public class EmptyEventsException extends Exception { +} diff --git a/src/main/java/EmptyToDoException.java b/src/main/java/EmptyToDoException.java new file mode 100644 index 000000000..47180bedb --- /dev/null +++ b/src/main/java/EmptyToDoException.java @@ -0,0 +1,2 @@ +public class EmptyToDoException extends Exception { +} diff --git a/src/main/java/Events.java b/src/main/java/Events.java index 23f91e82c..e4b6ead0e 100644 --- a/src/main/java/Events.java +++ b/src/main/java/Events.java @@ -1,33 +1,43 @@ -public class Events extends Task{ +public class Events extends Task { + private static final int EVENT_INDEX = 6; + private static final int FIRST_COLON_INDEX = 4; + private static final int SECOND_COLON_INDEX = 2; private String timeLine; private String taskLabel = "[E]"; - public Events (String input){ - super(input.substring(6,input.indexOf('/') - 1)); + public Events(String input) throws EmptyEventsException { + super(input.substring(EVENT_INDEX, input.indexOf('/') - 1)); super.setTaskLabel(taskLabel); timeLine = "(" + getStartTime(input) + getEndTime(input) + ")"; + if (input.substring(EVENT_INDEX, input.indexOf('/') - 1).isEmpty()) { + throw new EmptyEventsException(); + } } - public String[] splitInput(String input){ + + public String[] splitInput(String input) { String[] inputAfterSplit = input.split("/", 3); // split twice to generate three strings return inputAfterSplit; } + @Override - public String getStartTime(String input){ + public String getStartTime(String input) { String[] inputAfterSplit = splitInput(input); String startTime = inputAfterSplit[1]; StringBuffer startTimeCorrectFormat = new StringBuffer(startTime); - startTimeCorrectFormat.insert(4,":"); + startTimeCorrectFormat.insert(FIRST_COLON_INDEX, ":"); return startTimeCorrectFormat.toString(); } + @Override - public String getEndTime(String input){ + public String getEndTime(String input) { String[] inputAfterSplit = splitInput(input); String startTime = inputAfterSplit[2]; StringBuffer endTimeCorrectFormat = new StringBuffer(startTime); // convert to StringBuffer for inserting ':' - endTimeCorrectFormat.insert(2,":"); + endTimeCorrectFormat.insert(SECOND_COLON_INDEX, ":"); return endTimeCorrectFormat.toString(); } + @Override - public String toString(){ + public String toString() { return this.taskLabel + this.mark + " " + this.description + " " + this.timeLine; } } diff --git a/src/main/java/NullCommandException.java b/src/main/java/NullCommandException.java new file mode 100644 index 000000000..552e6eaac --- /dev/null +++ b/src/main/java/NullCommandException.java @@ -0,0 +1,2 @@ +public class NullCommandException extends Exception { +} diff --git a/src/main/java/ToDos.java b/src/main/java/ToDos.java index 8c951e678..6965e4f0e 100644 --- a/src/main/java/ToDos.java +++ b/src/main/java/ToDos.java @@ -1,11 +1,17 @@ public class ToDos extends Task { + private static final int TODOS_INDEX = 5; private String taskLabel = "[T]"; - public ToDos (String input){ - super(input.substring(5)); // for ToDos tasks, description = input + + public ToDos(String input) throws EmptyToDoException { + super(input.substring(TODOS_INDEX)); // for ToDos tasks, description = input super.setTaskLabel(taskLabel); + if (input.substring(TODOS_INDEX).isEmpty()) { + throw new EmptyToDoException(); + } } + @Override - public String toString(){ + public String toString() { return this.taskLabel + this.mark + " " + this.description; } } From 90cbc52dbaf0c24d694375f70164300a26b66dea Mon Sep 17 00:00:00 2001 From: Gujimugger Date: Fri, 10 Feb 2023 01:29:38 +0800 Subject: [PATCH 07/19] A-Packages --- src/main/java/{ => Duke}/Duke.java | 11 +++++++++++ .../{ => Duke/Exception}/EmptyDeadlineException.java | 2 ++ .../{ => Duke/Exception}/EmptyEventsException.java | 2 ++ .../java/{ => Duke/Exception}/EmptyToDoException.java | 2 ++ .../{ => Duke/Exception}/NullCommandException.java | 2 ++ src/main/java/{ => Duke/Task}/Deadlines.java | 7 ++++++- src/main/java/{ => Duke/Task}/Events.java | 4 ++++ src/main/java/{ => Duke/Task}/Task.java | 2 ++ src/main/java/{ => Duke/Task}/ToDos.java | 4 ++++ 9 files changed, 35 insertions(+), 1 deletion(-) rename src/main/java/{ => Duke}/Duke.java (93%) rename src/main/java/{ => Duke/Exception}/EmptyDeadlineException.java (69%) rename src/main/java/{ => Duke/Exception}/EmptyEventsException.java (69%) rename src/main/java/{ => Duke/Exception}/EmptyToDoException.java (68%) rename src/main/java/{ => Duke/Exception}/NullCommandException.java (69%) rename src/main/java/{ => Duke/Task}/Deadlines.java (93%) rename src/main/java/{ => Duke/Task}/Events.java (96%) rename src/main/java/{ => Duke/Task}/Task.java (97%) rename src/main/java/{ => Duke/Task}/ToDos.java (89%) diff --git a/src/main/java/Duke.java b/src/main/java/Duke/Duke.java similarity index 93% rename from src/main/java/Duke.java rename to src/main/java/Duke/Duke.java index 85944240f..a7a9e8b6a 100644 --- a/src/main/java/Duke.java +++ b/src/main/java/Duke/Duke.java @@ -1,3 +1,14 @@ +package Duke; + +import Duke.Exception.EmptyDeadlineException; +import Duke.Exception.EmptyEventsException; +import Duke.Exception.EmptyToDoException; +import Duke.Exception.NullCommandException; +import Duke.Task.Deadlines; +import Duke.Task.Events; +import Duke.Task.Task; +import Duke.Task.ToDos; + import java.util.Arrays; import java.util.Scanner; diff --git a/src/main/java/EmptyDeadlineException.java b/src/main/java/Duke/Exception/EmptyDeadlineException.java similarity index 69% rename from src/main/java/EmptyDeadlineException.java rename to src/main/java/Duke/Exception/EmptyDeadlineException.java index e4e3ac67d..9dfeae63b 100644 --- a/src/main/java/EmptyDeadlineException.java +++ b/src/main/java/Duke/Exception/EmptyDeadlineException.java @@ -1,2 +1,4 @@ +package Duke.Exception; + public class EmptyDeadlineException extends Exception { } diff --git a/src/main/java/EmptyEventsException.java b/src/main/java/Duke/Exception/EmptyEventsException.java similarity index 69% rename from src/main/java/EmptyEventsException.java rename to src/main/java/Duke/Exception/EmptyEventsException.java index 4ae4c8325..be113f705 100644 --- a/src/main/java/EmptyEventsException.java +++ b/src/main/java/Duke/Exception/EmptyEventsException.java @@ -1,2 +1,4 @@ +package Duke.Exception; + public class EmptyEventsException extends Exception { } diff --git a/src/main/java/EmptyToDoException.java b/src/main/java/Duke/Exception/EmptyToDoException.java similarity index 68% rename from src/main/java/EmptyToDoException.java rename to src/main/java/Duke/Exception/EmptyToDoException.java index 47180bedb..502c680e1 100644 --- a/src/main/java/EmptyToDoException.java +++ b/src/main/java/Duke/Exception/EmptyToDoException.java @@ -1,2 +1,4 @@ +package Duke.Exception; + public class EmptyToDoException extends Exception { } diff --git a/src/main/java/NullCommandException.java b/src/main/java/Duke/Exception/NullCommandException.java similarity index 69% rename from src/main/java/NullCommandException.java rename to src/main/java/Duke/Exception/NullCommandException.java index 552e6eaac..3e080511a 100644 --- a/src/main/java/NullCommandException.java +++ b/src/main/java/Duke/Exception/NullCommandException.java @@ -1,2 +1,4 @@ +package Duke.Exception; + public class NullCommandException extends Exception { } diff --git a/src/main/java/Deadlines.java b/src/main/java/Duke/Task/Deadlines.java similarity index 93% rename from src/main/java/Deadlines.java rename to src/main/java/Duke/Task/Deadlines.java index 6b21cfba9..039ea58da 100644 --- a/src/main/java/Deadlines.java +++ b/src/main/java/Duke/Task/Deadlines.java @@ -1,10 +1,15 @@ +package Duke.Task; + +import Duke.Exception.EmptyDeadlineException; +import Duke.Task.Task; + public class Deadlines extends Task { private static final int DEADLINE_INDEX = 9; private static final int COLON_INDEX = 2; private String endTime; private String taskLabel = "[D]"; - public Deadlines(String input) throws EmptyDeadlineException{ + public Deadlines(String input) throws EmptyDeadlineException { super(input.substring(DEADLINE_INDEX, input.indexOf('/') - 1)); // Sanitize input by removing "deadline" at the start super.setTaskLabel(taskLabel); endTime = "(" + getEndTime(input) + ")"; diff --git a/src/main/java/Events.java b/src/main/java/Duke/Task/Events.java similarity index 96% rename from src/main/java/Events.java rename to src/main/java/Duke/Task/Events.java index e4b6ead0e..787c89252 100644 --- a/src/main/java/Events.java +++ b/src/main/java/Duke/Task/Events.java @@ -1,3 +1,7 @@ +package Duke.Task; + +import Duke.Exception.EmptyEventsException; + public class Events extends Task { private static final int EVENT_INDEX = 6; private static final int FIRST_COLON_INDEX = 4; diff --git a/src/main/java/Task.java b/src/main/java/Duke/Task/Task.java similarity index 97% rename from src/main/java/Task.java rename to src/main/java/Duke/Task/Task.java index 15394430c..326dd26d8 100644 --- a/src/main/java/Task.java +++ b/src/main/java/Duke/Task/Task.java @@ -1,3 +1,5 @@ +package Duke.Task; + public class Task { protected String taskLabel; protected String description; diff --git a/src/main/java/ToDos.java b/src/main/java/Duke/Task/ToDos.java similarity index 89% rename from src/main/java/ToDos.java rename to src/main/java/Duke/Task/ToDos.java index 6965e4f0e..246ee42f4 100644 --- a/src/main/java/ToDos.java +++ b/src/main/java/Duke/Task/ToDos.java @@ -1,3 +1,7 @@ +package Duke.Task; + +import Duke.Exception.EmptyToDoException; + public class ToDos extends Task { private static final int TODOS_INDEX = 5; private String taskLabel = "[T]"; From 4eee682e01d918332789fa2c66e15c12fc75a38c Mon Sep 17 00:00:00 2001 From: Gujimugger Date: Wed, 15 Feb 2023 18:58:30 +0800 Subject: [PATCH 08/19] Level 6 Complete --- src/main/java/Duke/Duke.java | 45 +++++++++++++++++++----------- src/main/java/Duke/Task/ToDos.java | 1 - 2 files changed, 28 insertions(+), 18 deletions(-) diff --git a/src/main/java/Duke/Duke.java b/src/main/java/Duke/Duke.java index a7a9e8b6a..e97af76ce 100644 --- a/src/main/java/Duke/Duke.java +++ b/src/main/java/Duke/Duke.java @@ -9,6 +9,7 @@ import Duke.Task.Task; import Duke.Task.ToDos; +import java.util.ArrayList; import java.util.Arrays; import java.util.Scanner; @@ -27,6 +28,7 @@ public static void main(String[] args) { private static final int MARK_INDEX = 5; private static final int UNMARK_INDEX = 7; + private static final int DELETE_INDEX = 7; public static void greetLine() { System.out.println("How may I be of service?"); @@ -47,34 +49,34 @@ public static void exitLine() { } public static void addList() { - Task[] list = new Task[100]; + ArrayList list = new ArrayList<>(); String line; Scanner in = new Scanner(System.in); line = in.nextLine(); - int numOfItems = 0; while (!line.equals("bye")) { // condition to shut down program if (line.equals("list")) { // users wants to know all text so far - printCurrentList(list, numOfItems); + printCurrentList(list); } else if (line.startsWith("mark")) { mark(line, list); - printCurrentList(list, numOfItems); } else if (line.startsWith("unmark")) { unmark(line, list); - printCurrentList(list, numOfItems); + } else if (line.startsWith("delete")) { + delete(line, list); } else {// new tasks keyed in by user try { Task newTask = new Task(line); if (line.startsWith("todo")) { newTask = new ToDos(line); + list.add(newTask); } else if (line.startsWith("deadline")) { newTask = new Deadlines(line); - } else if (line.startsWith("event")){ + list.add(newTask); + } else if (line.startsWith("event")) { newTask = new Events(line); + list.add(newTask); } else { throw new NullCommandException(); } - list[numOfItems] = newTask; - ++numOfItems; } catch (EmptyToDoException e) { System.out.println("Sire, you have yet to tell me what is it you want to do."); } catch (EmptyDeadlineException e) { @@ -91,25 +93,34 @@ public static void addList() { } } - public static void mark(String task, Task[] list) { + public static void mark(String task, ArrayList list) { String indexOfTask = task.substring(MARK_INDEX); // get the number of task to be marked - Task taskToBeMarked = list[Integer.parseInt(indexOfTask) - 1]; // convert from 1-based to 0-based + Task taskToBeMarked = list.get(Integer.parseInt(indexOfTask) - 1); // convert from 1-based to 0-based taskToBeMarked.markTask(); System.out.println("Sir, your task has been marked as completed."); + System.out.println(list.get(Integer.parseInt(indexOfTask) - 1)); } - public static void unmark(String task, Task[] list) { + public static void unmark(String task, ArrayList list) { String indexOfTask = task.substring(UNMARK_INDEX); - Task taskToBeMarked = list[Integer.parseInt(indexOfTask) - 1]; // convert from 1-based to 0-based - taskToBeMarked.unmarkTask(); + Task taskToBeUnmarked = list.get(Integer.parseInt(indexOfTask) - 1); + taskToBeUnmarked.unmarkTask(); System.out.println("Sir, your task has been unmarked as requested."); + System.out.println(list.get(Integer.parseInt(indexOfTask) - 1)); } - public static void printCurrentList(Task[] list, int numOfItems) { - Task[] subList = Arrays.copyOf(list, numOfItems); + public static void printCurrentList(ArrayList list) { System.out.println("Your current list of items as requested, sir."); - for (int i = 0; i < subList.length; ++i) { - System.out.println(Integer.toString(i + 1) + "." + subList[i]); + for (int i = 0; i < list.size(); ++i) { + System.out.println((i + 1) + "." + list.get(i)); } } + + public static void delete(String task, ArrayList list) { + String indexOfTask = task.substring(DELETE_INDEX); + System.out.println("Sire, I have removed this task from your schedule"); + System.out.println(list.get(Integer.parseInt(indexOfTask) - 1)); + list.remove(Integer.parseInt(indexOfTask) - 1); + System.out.println("You now have " + list.size() + " items left"); + } } diff --git a/src/main/java/Duke/Task/ToDos.java b/src/main/java/Duke/Task/ToDos.java index 246ee42f4..c67331914 100644 --- a/src/main/java/Duke/Task/ToDos.java +++ b/src/main/java/Duke/Task/ToDos.java @@ -13,7 +13,6 @@ public ToDos(String input) throws EmptyToDoException { throw new EmptyToDoException(); } } - @Override public String toString() { return this.taskLabel + this.mark + " " + this.description; From 21815d8b1aaf7cb227e60592b533156213408b0c Mon Sep 17 00:00:00 2001 From: Gujimugger Date: Wed, 15 Feb 2023 19:07:38 +0800 Subject: [PATCH 09/19] Revert "Level 6 Complete" This reverts commit 4eee682e01d918332789fa2c66e15c12fc75a38c. --- src/main/java/Duke/Duke.java | 45 +++++++++++------------------- src/main/java/Duke/Task/ToDos.java | 1 + 2 files changed, 18 insertions(+), 28 deletions(-) diff --git a/src/main/java/Duke/Duke.java b/src/main/java/Duke/Duke.java index e97af76ce..a7a9e8b6a 100644 --- a/src/main/java/Duke/Duke.java +++ b/src/main/java/Duke/Duke.java @@ -9,7 +9,6 @@ import Duke.Task.Task; import Duke.Task.ToDos; -import java.util.ArrayList; import java.util.Arrays; import java.util.Scanner; @@ -28,7 +27,6 @@ public static void main(String[] args) { private static final int MARK_INDEX = 5; private static final int UNMARK_INDEX = 7; - private static final int DELETE_INDEX = 7; public static void greetLine() { System.out.println("How may I be of service?"); @@ -49,34 +47,34 @@ public static void exitLine() { } public static void addList() { - ArrayList list = new ArrayList<>(); + Task[] list = new Task[100]; String line; Scanner in = new Scanner(System.in); line = in.nextLine(); + int numOfItems = 0; while (!line.equals("bye")) { // condition to shut down program if (line.equals("list")) { // users wants to know all text so far - printCurrentList(list); + printCurrentList(list, numOfItems); } else if (line.startsWith("mark")) { mark(line, list); + printCurrentList(list, numOfItems); } else if (line.startsWith("unmark")) { unmark(line, list); - } else if (line.startsWith("delete")) { - delete(line, list); + printCurrentList(list, numOfItems); } else {// new tasks keyed in by user try { Task newTask = new Task(line); if (line.startsWith("todo")) { newTask = new ToDos(line); - list.add(newTask); } else if (line.startsWith("deadline")) { newTask = new Deadlines(line); - list.add(newTask); - } else if (line.startsWith("event")) { + } else if (line.startsWith("event")){ newTask = new Events(line); - list.add(newTask); } else { throw new NullCommandException(); } + list[numOfItems] = newTask; + ++numOfItems; } catch (EmptyToDoException e) { System.out.println("Sire, you have yet to tell me what is it you want to do."); } catch (EmptyDeadlineException e) { @@ -93,34 +91,25 @@ public static void addList() { } } - public static void mark(String task, ArrayList list) { + public static void mark(String task, Task[] list) { String indexOfTask = task.substring(MARK_INDEX); // get the number of task to be marked - Task taskToBeMarked = list.get(Integer.parseInt(indexOfTask) - 1); // convert from 1-based to 0-based + Task taskToBeMarked = list[Integer.parseInt(indexOfTask) - 1]; // convert from 1-based to 0-based taskToBeMarked.markTask(); System.out.println("Sir, your task has been marked as completed."); - System.out.println(list.get(Integer.parseInt(indexOfTask) - 1)); } - public static void unmark(String task, ArrayList list) { + public static void unmark(String task, Task[] list) { String indexOfTask = task.substring(UNMARK_INDEX); - Task taskToBeUnmarked = list.get(Integer.parseInt(indexOfTask) - 1); - taskToBeUnmarked.unmarkTask(); + Task taskToBeMarked = list[Integer.parseInt(indexOfTask) - 1]; // convert from 1-based to 0-based + taskToBeMarked.unmarkTask(); System.out.println("Sir, your task has been unmarked as requested."); - System.out.println(list.get(Integer.parseInt(indexOfTask) - 1)); } - public static void printCurrentList(ArrayList list) { + public static void printCurrentList(Task[] list, int numOfItems) { + Task[] subList = Arrays.copyOf(list, numOfItems); System.out.println("Your current list of items as requested, sir."); - for (int i = 0; i < list.size(); ++i) { - System.out.println((i + 1) + "." + list.get(i)); + for (int i = 0; i < subList.length; ++i) { + System.out.println(Integer.toString(i + 1) + "." + subList[i]); } } - - public static void delete(String task, ArrayList list) { - String indexOfTask = task.substring(DELETE_INDEX); - System.out.println("Sire, I have removed this task from your schedule"); - System.out.println(list.get(Integer.parseInt(indexOfTask) - 1)); - list.remove(Integer.parseInt(indexOfTask) - 1); - System.out.println("You now have " + list.size() + " items left"); - } } diff --git a/src/main/java/Duke/Task/ToDos.java b/src/main/java/Duke/Task/ToDos.java index c67331914..246ee42f4 100644 --- a/src/main/java/Duke/Task/ToDos.java +++ b/src/main/java/Duke/Task/ToDos.java @@ -13,6 +13,7 @@ public ToDos(String input) throws EmptyToDoException { throw new EmptyToDoException(); } } + @Override public String toString() { return this.taskLabel + this.mark + " " + this.description; From 21238c7326674438b9789a4f6c3ab8cb8e0f00f0 Mon Sep 17 00:00:00 2001 From: Gujimugger Date: Wed, 15 Feb 2023 19:09:10 +0800 Subject: [PATCH 10/19] Revert "Revert "Level 6 Complete"" This reverts commit 21815d8b1aaf7cb227e60592b533156213408b0c. --- src/main/java/Duke/Duke.java | 45 +++++++++++++++++++----------- src/main/java/Duke/Task/ToDos.java | 1 - 2 files changed, 28 insertions(+), 18 deletions(-) diff --git a/src/main/java/Duke/Duke.java b/src/main/java/Duke/Duke.java index a7a9e8b6a..e97af76ce 100644 --- a/src/main/java/Duke/Duke.java +++ b/src/main/java/Duke/Duke.java @@ -9,6 +9,7 @@ import Duke.Task.Task; import Duke.Task.ToDos; +import java.util.ArrayList; import java.util.Arrays; import java.util.Scanner; @@ -27,6 +28,7 @@ public static void main(String[] args) { private static final int MARK_INDEX = 5; private static final int UNMARK_INDEX = 7; + private static final int DELETE_INDEX = 7; public static void greetLine() { System.out.println("How may I be of service?"); @@ -47,34 +49,34 @@ public static void exitLine() { } public static void addList() { - Task[] list = new Task[100]; + ArrayList list = new ArrayList<>(); String line; Scanner in = new Scanner(System.in); line = in.nextLine(); - int numOfItems = 0; while (!line.equals("bye")) { // condition to shut down program if (line.equals("list")) { // users wants to know all text so far - printCurrentList(list, numOfItems); + printCurrentList(list); } else if (line.startsWith("mark")) { mark(line, list); - printCurrentList(list, numOfItems); } else if (line.startsWith("unmark")) { unmark(line, list); - printCurrentList(list, numOfItems); + } else if (line.startsWith("delete")) { + delete(line, list); } else {// new tasks keyed in by user try { Task newTask = new Task(line); if (line.startsWith("todo")) { newTask = new ToDos(line); + list.add(newTask); } else if (line.startsWith("deadline")) { newTask = new Deadlines(line); - } else if (line.startsWith("event")){ + list.add(newTask); + } else if (line.startsWith("event")) { newTask = new Events(line); + list.add(newTask); } else { throw new NullCommandException(); } - list[numOfItems] = newTask; - ++numOfItems; } catch (EmptyToDoException e) { System.out.println("Sire, you have yet to tell me what is it you want to do."); } catch (EmptyDeadlineException e) { @@ -91,25 +93,34 @@ public static void addList() { } } - public static void mark(String task, Task[] list) { + public static void mark(String task, ArrayList list) { String indexOfTask = task.substring(MARK_INDEX); // get the number of task to be marked - Task taskToBeMarked = list[Integer.parseInt(indexOfTask) - 1]; // convert from 1-based to 0-based + Task taskToBeMarked = list.get(Integer.parseInt(indexOfTask) - 1); // convert from 1-based to 0-based taskToBeMarked.markTask(); System.out.println("Sir, your task has been marked as completed."); + System.out.println(list.get(Integer.parseInt(indexOfTask) - 1)); } - public static void unmark(String task, Task[] list) { + public static void unmark(String task, ArrayList list) { String indexOfTask = task.substring(UNMARK_INDEX); - Task taskToBeMarked = list[Integer.parseInt(indexOfTask) - 1]; // convert from 1-based to 0-based - taskToBeMarked.unmarkTask(); + Task taskToBeUnmarked = list.get(Integer.parseInt(indexOfTask) - 1); + taskToBeUnmarked.unmarkTask(); System.out.println("Sir, your task has been unmarked as requested."); + System.out.println(list.get(Integer.parseInt(indexOfTask) - 1)); } - public static void printCurrentList(Task[] list, int numOfItems) { - Task[] subList = Arrays.copyOf(list, numOfItems); + public static void printCurrentList(ArrayList list) { System.out.println("Your current list of items as requested, sir."); - for (int i = 0; i < subList.length; ++i) { - System.out.println(Integer.toString(i + 1) + "." + subList[i]); + for (int i = 0; i < list.size(); ++i) { + System.out.println((i + 1) + "." + list.get(i)); } } + + public static void delete(String task, ArrayList list) { + String indexOfTask = task.substring(DELETE_INDEX); + System.out.println("Sire, I have removed this task from your schedule"); + System.out.println(list.get(Integer.parseInt(indexOfTask) - 1)); + list.remove(Integer.parseInt(indexOfTask) - 1); + System.out.println("You now have " + list.size() + " items left"); + } } diff --git a/src/main/java/Duke/Task/ToDos.java b/src/main/java/Duke/Task/ToDos.java index 246ee42f4..c67331914 100644 --- a/src/main/java/Duke/Task/ToDos.java +++ b/src/main/java/Duke/Task/ToDos.java @@ -13,7 +13,6 @@ public ToDos(String input) throws EmptyToDoException { throw new EmptyToDoException(); } } - @Override public String toString() { return this.taskLabel + this.mark + " " + this.description; From d5393f2d177cd8666eef5c3070ee3cba20ff9561 Mon Sep 17 00:00:00 2001 From: Gujimugger Date: Fri, 17 Feb 2023 11:12:51 +0800 Subject: [PATCH 11/19] Fixing going back to master --- src/.idea/workspace.xml | 61 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 61 insertions(+) create mode 100644 src/.idea/workspace.xml diff --git a/src/.idea/workspace.xml b/src/.idea/workspace.xml new file mode 100644 index 000000000..a4dceeceb --- /dev/null +++ b/src/.idea/workspace.xml @@ -0,0 +1,61 @@ + + + + + + + + + + + + + + + + + + + + + + + { + "keyToString": { + "RunOnceActivity.OpenProjectViewOnStart": "true", + "RunOnceActivity.ShowReadmeOnStart": "true", + "WebServerToolWindowFactoryState": "false", + "last_opened_file_path": "/Users/wangsilang/Desktop/Codes/CS2113/iP/ip/src", + "node.js.detected.package.eslint": "true", + "node.js.detected.package.tslint": "true", + "node.js.selected.package.eslint": "(autodetect)", + "node.js.selected.package.tslint": "(autodetect)", + "vue.rearranger.settings.migration": "true" + } +} + + + + + 1676455852136 + + + + + + \ No newline at end of file From d98e8002ce93d10707b7e42ec81d1501de6ee231 Mon Sep 17 00:00:00 2001 From: Gujimugger Date: Fri, 17 Feb 2023 17:22:52 +0800 Subject: [PATCH 12/19] Level 7 complete --- src/main/java/Duke/Duke.java | 55 ++++++++++++++++++++++++++++++++++-- 1 file changed, 53 insertions(+), 2 deletions(-) diff --git a/src/main/java/Duke/Duke.java b/src/main/java/Duke/Duke.java index e97af76ce..765bfea19 100644 --- a/src/main/java/Duke/Duke.java +++ b/src/main/java/Duke/Duke.java @@ -10,8 +10,12 @@ import Duke.Task.ToDos; import java.util.ArrayList; -import java.util.Arrays; import java.util.Scanner; +import java.io.File; +import java.io.IOException; +import java.io.FileWriter; +import java.io.FileNotFoundException; + public class Duke { public static void main(String[] args) { @@ -21,6 +25,11 @@ public static void main(String[] args) { + "| |_| | |_| | < __/\n" + "|____/ \\__,_|_|\\_\\___|\n"; System.out.println("Hello from\n" + logo); + try { + printFileContents("dukeData.txt"); + } catch (FileNotFoundException e){ + System.out.println("File not found"); + } greetLine(); addList(); exitLine(); @@ -31,7 +40,7 @@ public static void main(String[] args) { private static final int DELETE_INDEX = 7; public static void greetLine() { - System.out.println("How may I be of service?"); + System.out.println("How may I be of service today?"); } public static void echo() { @@ -58,10 +67,13 @@ public static void addList() { printCurrentList(list); } else if (line.startsWith("mark")) { mark(line, list); + dukeDataStorage(arraylistToStringConverter(list)); } else if (line.startsWith("unmark")) { unmark(line, list); + dukeDataStorage(arraylistToStringConverter(list)); } else if (line.startsWith("delete")) { delete(line, list); + dukeDataStorage(arraylistToStringConverter(list)); } else {// new tasks keyed in by user try { Task newTask = new Task(line); @@ -77,6 +89,7 @@ public static void addList() { } else { throw new NullCommandException(); } + dukeDataStorage(arraylistToStringConverter(list)); } catch (EmptyToDoException e) { System.out.println("Sire, you have yet to tell me what is it you want to do."); } catch (EmptyDeadlineException e) { @@ -123,4 +136,42 @@ public static void delete(String task, ArrayList list) { list.remove(Integer.parseInt(indexOfTask) - 1); System.out.println("You now have " + list.size() + " items left"); } + + public static void dukeDataStorage(String taskToBeStored) { + File f = new File("dukeData.txt"); + try { + if (!f.exists()) { + f.createNewFile(); + } + writeToFile("dukeData.txt", taskToBeStored); + } catch (IOException e) { + System.out.println("File creation of writing invalid"); + } + } + + private static void writeToFile(String filePath, String textToAdd) throws IOException { + FileWriter fw = new FileWriter(filePath); + fw.write(textToAdd); + fw.close(); + } + + private static void printFileContents(String filePath) throws FileNotFoundException { + File f = new File(filePath); // create a File for the given file path + if (!f.exists()) { // for first log in, there is no file + return; + } + System.out.println("Good day sire, I have listed down your current plan below for you:"); + Scanner s = new Scanner(f); // create a Scanner using the File as the source + while (s.hasNext()) { + System.out.println(s.nextLine()); + } + } + + private static String arraylistToStringConverter(ArrayList list) { + String output = ""; + for (Task t : list) { + output = output + t + System.lineSeparator(); + } + return output; + } } From a9eebd04dcddda31206dacf6bd563091c01fd729 Mon Sep 17 00:00:00 2001 From: Gujimugger Date: Fri, 17 Feb 2023 20:08:37 +0800 Subject: [PATCH 13/19] A-Jar --- src/main/java/Duke/Duke.java | 67 +++++++++++++++++++++++++----- src/main/java/Duke/Task/Task.java | 20 +++++++-- src/main/java/META-INF/MANIFEST.MF | 3 ++ 3 files changed, 76 insertions(+), 14 deletions(-) create mode 100644 src/main/java/META-INF/MANIFEST.MF diff --git a/src/main/java/Duke/Duke.java b/src/main/java/Duke/Duke.java index 765bfea19..ca9e92a27 100644 --- a/src/main/java/Duke/Duke.java +++ b/src/main/java/Duke/Duke.java @@ -9,6 +9,7 @@ import Duke.Task.Task; import Duke.Task.ToDos; +import java.nio.file.Files; import java.util.ArrayList; import java.util.Scanner; import java.io.File; @@ -16,7 +17,6 @@ import java.io.FileWriter; import java.io.FileNotFoundException; - public class Duke { public static void main(String[] args) { String logo = " ____ _ \n" @@ -25,19 +25,25 @@ public static void main(String[] args) { + "| |_| | |_| | < __/\n" + "|____/ \\__,_|_|\\_\\___|\n"; System.out.println("Hello from\n" + logo); + ArrayList list = new ArrayList<>(); try { - printFileContents("dukeData.txt"); - } catch (FileNotFoundException e){ + list = stringToArraylistConverter(printFileContents("dukeData.txt")); + } catch (FileNotFoundException e) { System.out.println("File not found"); } greetLine(); - addList(); + addList(list); exitLine(); } private static final int MARK_INDEX = 5; private static final int UNMARK_INDEX = 7; private static final int DELETE_INDEX = 7; + private static final int BRACKETSKIP_INDEX = 7; + private static final int FIRSTBRACKET_FRONT = 0; + private static final int FIRSTBRACKET_BACK = 3; + private static final int SECONDBRACKET_FRONT = 3; + private static final int SECONDBRACKET_BACK = 6; public static void greetLine() { System.out.println("How may I be of service today?"); @@ -57,8 +63,7 @@ public static void exitLine() { System.out.println("Glad I could be of help!"); } - public static void addList() { - ArrayList list = new ArrayList<>(); + public static void addList(ArrayList list) { String line; Scanner in = new Scanner(System.in); line = in.nextLine(); @@ -155,23 +160,65 @@ private static void writeToFile(String filePath, String textToAdd) throws IOExce fw.close(); } - private static void printFileContents(String filePath) throws FileNotFoundException { + private static String printFileContents(String filePath) throws FileNotFoundException { File f = new File(filePath); // create a File for the given file path + String fileContent = ""; if (!f.exists()) { // for first log in, there is no file - return; + return ""; } System.out.println("Good day sire, I have listed down your current plan below for you:"); Scanner s = new Scanner(f); // create a Scanner using the File as the source while (s.hasNext()) { - System.out.println(s.nextLine()); + String taskStored = s.nextLine(); + System.out.println(taskStored); + fileContent = fileContent + taskStored + System.lineSeparator(); } + return fileContent; } private static String arraylistToStringConverter(ArrayList list) { String output = ""; for (Task t : list) { - output = output + t + System.lineSeparator(); + output = output + t.toString() + System.lineSeparator(); } return output; } + + private static ArrayList stringToArraylistConverter(String fileContent) { + ArrayList list = new ArrayList<>(); + if (fileContent.equals("")) { + return list; + } + String[] bufferArray = fileContent.split(System.lineSeparator()); + for (String t : bufferArray) { + Task task = new Task(t); + try { + if (t.substring(FIRSTBRACKET_FRONT, FIRSTBRACKET_BACK).equals("[T]")) { + String todoDetail = "todo " + t.substring(BRACKETSKIP_INDEX); + task = new ToDos(todoDetail); + task.setMark(t.substring(SECONDBRACKET_FRONT, SECONDBRACKET_BACK)); + } else if (t.substring(FIRSTBRACKET_FRONT, FIRSTBRACKET_BACK).equals("[D]")) { + String deadlineDetail = "deadline " + t.substring(BRACKETSKIP_INDEX, t.indexOf("(")) + "/" + + t.substring(t.indexOf("(") + 1, t.indexOf(")")); + task = new Deadlines(deadlineDetail); + task.setMark(t.substring(SECONDBRACKET_FRONT, SECONDBRACKET_BACK)); + } else { + String eventDetail = "event " + t.substring(BRACKETSKIP_INDEX, t.indexOf("(")) + "/" + + t.substring(t.indexOf("(") + 1, t.indexOf("to")) + "/" + + t.substring(t.indexOf("to"), t.indexOf(")")); + eventDetail = eventDetail.replace(":", ""); + task = new Events(eventDetail); + task.setMark(t.substring(SECONDBRACKET_FRONT, SECONDBRACKET_BACK)); + } + } catch (EmptyToDoException e) { + System.out.println("Corrupt todo detected, it is empty"); + } catch (EmptyDeadlineException e) { + System.out.println("Corrupt Deadline detected, it is empty"); + } catch (EmptyEventsException e) { + System.out.println("Corrupt Events detected, it is empty"); + } + list.add(task); + } + return list; + } } diff --git a/src/main/java/Duke/Task/Task.java b/src/main/java/Duke/Task/Task.java index 326dd26d8..2d4409060 100644 --- a/src/main/java/Duke/Task/Task.java +++ b/src/main/java/Duke/Task/Task.java @@ -4,30 +4,42 @@ public class Task { protected String taskLabel; protected String description; protected String mark; + public Task(String input) { this.description = input; this.taskLabel = "To be replaced by labels"; this.mark = "[ ]"; } + public String getTaskLabel() { return taskLabel; } + public String getDescription() { return description; } - public String getStartTime(String input){ + + public String getStartTime(String input) { return "To be overridden by subclass' methods"; } - public String getEndTime(String input){ + + public String getEndTime(String input) { return "To be overridden by subclass' methods"; } + public void setTaskLabel(String taskLabel) { this.taskLabel = taskLabel; } - public void markTask(){ + + public void markTask() { this.mark = "[X]"; } - public void unmarkTask(){ + + public void unmarkTask() { this.mark = "[ ]"; } + + public void setMark(String mark) { + this.mark = mark; + } } diff --git a/src/main/java/META-INF/MANIFEST.MF b/src/main/java/META-INF/MANIFEST.MF new file mode 100644 index 000000000..76381b309 --- /dev/null +++ b/src/main/java/META-INF/MANIFEST.MF @@ -0,0 +1,3 @@ +Manifest-Version: 1.0 +Main-Class: Duke.Duke + From 7688011a67396925076cb7b3d9f4dce63b2d400f Mon Sep 17 00:00:00 2001 From: Gujimugger Date: Fri, 3 Mar 2023 21:37:03 +0800 Subject: [PATCH 14/19] A-MoreOOP --- src/main/java/Duke/Duke.java | 296 ++++++++--------------------- src/main/java/Duke/Parser.java | 49 +++++ src/main/java/Duke/Storage.java | 117 ++++++++++++ src/main/java/Duke/Task/ToDos.java | 1 + src/main/java/Duke/TaskList.java | 99 ++++++++++ src/main/java/Duke/Ui.java | 79 ++++++++ 6 files changed, 429 insertions(+), 212 deletions(-) create mode 100644 src/main/java/Duke/Parser.java create mode 100644 src/main/java/Duke/Storage.java create mode 100644 src/main/java/Duke/TaskList.java create mode 100644 src/main/java/Duke/Ui.java diff --git a/src/main/java/Duke/Duke.java b/src/main/java/Duke/Duke.java index ca9e92a27..009fb2314 100644 --- a/src/main/java/Duke/Duke.java +++ b/src/main/java/Duke/Duke.java @@ -1,224 +1,96 @@ package Duke; -import Duke.Exception.EmptyDeadlineException; -import Duke.Exception.EmptyEventsException; -import Duke.Exception.EmptyToDoException; -import Duke.Exception.NullCommandException; -import Duke.Task.Deadlines; -import Duke.Task.Events; -import Duke.Task.Task; -import Duke.Task.ToDos; - -import java.nio.file.Files; -import java.util.ArrayList; -import java.util.Scanner; -import java.io.File; -import java.io.IOException; -import java.io.FileWriter; -import java.io.FileNotFoundException; - public class Duke { - public static void main(String[] args) { - String logo = " ____ _ \n" - + "| _ \\ _ _| | _____ \n" - + "| | | | | | | |/ / _ \\\n" - + "| |_| | |_| | < __/\n" - + "|____/ \\__,_|_|\\_\\___|\n"; - System.out.println("Hello from\n" + logo); - ArrayList list = new ArrayList<>(); - try { - list = stringToArraylistConverter(printFileContents("dukeData.txt")); - } catch (FileNotFoundException e) { - System.out.println("File not found"); - } - greetLine(); - addList(list); - exitLine(); - } - - private static final int MARK_INDEX = 5; - private static final int UNMARK_INDEX = 7; - private static final int DELETE_INDEX = 7; - private static final int BRACKETSKIP_INDEX = 7; - private static final int FIRSTBRACKET_FRONT = 0; - private static final int FIRSTBRACKET_BACK = 3; - private static final int SECONDBRACKET_FRONT = 3; - private static final int SECONDBRACKET_BACK = 6; - - public static void greetLine() { - System.out.println("How may I be of service today?"); - } - - public static void echo() { - String line; - Scanner in = new Scanner(System.in); - line = in.nextLine(); - while (!line.equals("bye")) { - System.out.println(line); - line = in.nextLine(); - } + private Ui ui; + private Storage storage; + private TaskList tasklist; + private Parser parser; + private final int PARSERINDEX = 1; + + public Duke(String filePath) { + ui = new Ui(); + storage = new Storage(); + tasklist = new TaskList(filePath); + parser = new Parser(); } - public static void exitLine() { - System.out.println("Glad I could be of help!"); - } - - public static void addList(ArrayList list) { - String line; - Scanner in = new Scanner(System.in); - line = in.nextLine(); - while (!line.equals("bye")) { // condition to shut down program - if (line.equals("list")) { // users wants to know all text so far - printCurrentList(list); - } else if (line.startsWith("mark")) { - mark(line, list); - dukeDataStorage(arraylistToStringConverter(list)); - } else if (line.startsWith("unmark")) { - unmark(line, list); - dukeDataStorage(arraylistToStringConverter(list)); - } else if (line.startsWith("delete")) { - delete(line, list); - dukeDataStorage(arraylistToStringConverter(list)); - } else {// new tasks keyed in by user - try { - Task newTask = new Task(line); - if (line.startsWith("todo")) { - newTask = new ToDos(line); - list.add(newTask); - } else if (line.startsWith("deadline")) { - newTask = new Deadlines(line); - list.add(newTask); - } else if (line.startsWith("event")) { - newTask = new Events(line); - list.add(newTask); - } else { - throw new NullCommandException(); - } - dukeDataStorage(arraylistToStringConverter(list)); - } catch (EmptyToDoException e) { - System.out.println("Sire, you have yet to tell me what is it you want to do."); - } catch (EmptyDeadlineException e) { - System.out.println("Sire, what is it that is due your specified time?"); - } catch (EmptyEventsException e) { - System.out.println("Sire, your event is unclear. Please specify."); - } catch (StringIndexOutOfBoundsException e) { - System.out.println("Don't hold back Sire. I am here to serve."); - } catch (NullCommandException e) { - System.out.println("Sire, I am not trained to understand gibberish."); - } + public void run() { + ui.greet(); + while (parser.getIsRunning()) { + String commandToBeParsed = ui.readCommand(); + String commandParsed = parser.parseCommand(commandToBeParsed); + if (commandParsed.startsWith("B")) { // bye from user, terminate program + parser.setIsRunning(false); + } else if (commandParsed.startsWith("L")) { // print list + tasklist.printCurrentList(); + } else if (commandParsed.startsWith("F")) { // find tasks in list + tasklist.printTasksFound(commandParsed.substring(PARSERINDEX)); + } else if (commandParsed.startsWith("M")) { // mark task + tasklist.mark(commandParsed.substring(PARSERINDEX)); + } else if (commandParsed.startsWith("U")) { // unmark task + tasklist.unmark(commandParsed.substring(PARSERINDEX)); + } else if (commandParsed.startsWith("D")) { // delete task + tasklist.delete(commandParsed.substring(PARSERINDEX)); + } else if (commandParsed.startsWith("XIOB")) { // index out of bound error + ui.printErrorMessage("Index out of bound error. Please try again Sire"); + } else if (commandParsed.startsWith("XNC")) { // null command error + ui.printErrorMessage("Sire, I am not trained to understand gibberish."); + } else { // task keyed in by users + tasklist.addTask(commandParsed.substring(PARSERINDEX)); } - line = in.nextLine(); // read in next line of text - } - } - - public static void mark(String task, ArrayList list) { - String indexOfTask = task.substring(MARK_INDEX); // get the number of task to be marked - Task taskToBeMarked = list.get(Integer.parseInt(indexOfTask) - 1); // convert from 1-based to 0-based - taskToBeMarked.markTask(); - System.out.println("Sir, your task has been marked as completed."); - System.out.println(list.get(Integer.parseInt(indexOfTask) - 1)); - } - - public static void unmark(String task, ArrayList list) { - String indexOfTask = task.substring(UNMARK_INDEX); - Task taskToBeUnmarked = list.get(Integer.parseInt(indexOfTask) - 1); - taskToBeUnmarked.unmarkTask(); - System.out.println("Sir, your task has been unmarked as requested."); - System.out.println(list.get(Integer.parseInt(indexOfTask) - 1)); - } - - public static void printCurrentList(ArrayList list) { - System.out.println("Your current list of items as requested, sir."); - for (int i = 0; i < list.size(); ++i) { - System.out.println((i + 1) + "." + list.get(i)); } + ui.bye(); } - public static void delete(String task, ArrayList list) { - String indexOfTask = task.substring(DELETE_INDEX); - System.out.println("Sire, I have removed this task from your schedule"); - System.out.println(list.get(Integer.parseInt(indexOfTask) - 1)); - list.remove(Integer.parseInt(indexOfTask) - 1); - System.out.println("You now have " + list.size() + " items left"); - } - - public static void dukeDataStorage(String taskToBeStored) { - File f = new File("dukeData.txt"); - try { - if (!f.exists()) { - f.createNewFile(); - } - writeToFile("dukeData.txt", taskToBeStored); - } catch (IOException e) { - System.out.println("File creation of writing invalid"); - } - } - - private static void writeToFile(String filePath, String textToAdd) throws IOException { - FileWriter fw = new FileWriter(filePath); - fw.write(textToAdd); - fw.close(); - } - - private static String printFileContents(String filePath) throws FileNotFoundException { - File f = new File(filePath); // create a File for the given file path - String fileContent = ""; - if (!f.exists()) { // for first log in, there is no file - return ""; - } - System.out.println("Good day sire, I have listed down your current plan below for you:"); - Scanner s = new Scanner(f); // create a Scanner using the File as the source - while (s.hasNext()) { - String taskStored = s.nextLine(); - System.out.println(taskStored); - fileContent = fileContent + taskStored + System.lineSeparator(); - } - return fileContent; - } - - private static String arraylistToStringConverter(ArrayList list) { - String output = ""; - for (Task t : list) { - output = output + t.toString() + System.lineSeparator(); - } - return output; + public static void main(String[] args) { + new Duke("dukeData.txt").run(); } - private static ArrayList stringToArraylistConverter(String fileContent) { - ArrayList list = new ArrayList<>(); - if (fileContent.equals("")) { - return list; - } - String[] bufferArray = fileContent.split(System.lineSeparator()); - for (String t : bufferArray) { - Task task = new Task(t); - try { - if (t.substring(FIRSTBRACKET_FRONT, FIRSTBRACKET_BACK).equals("[T]")) { - String todoDetail = "todo " + t.substring(BRACKETSKIP_INDEX); - task = new ToDos(todoDetail); - task.setMark(t.substring(SECONDBRACKET_FRONT, SECONDBRACKET_BACK)); - } else if (t.substring(FIRSTBRACKET_FRONT, FIRSTBRACKET_BACK).equals("[D]")) { - String deadlineDetail = "deadline " + t.substring(BRACKETSKIP_INDEX, t.indexOf("(")) + "/" + - t.substring(t.indexOf("(") + 1, t.indexOf(")")); - task = new Deadlines(deadlineDetail); - task.setMark(t.substring(SECONDBRACKET_FRONT, SECONDBRACKET_BACK)); - } else { - String eventDetail = "event " + t.substring(BRACKETSKIP_INDEX, t.indexOf("(")) + "/" + - t.substring(t.indexOf("(") + 1, t.indexOf("to")) + "/" + - t.substring(t.indexOf("to"), t.indexOf(")")); - eventDetail = eventDetail.replace(":", ""); - task = new Events(eventDetail); - task.setMark(t.substring(SECONDBRACKET_FRONT, SECONDBRACKET_BACK)); - } - } catch (EmptyToDoException e) { - System.out.println("Corrupt todo detected, it is empty"); - } catch (EmptyDeadlineException e) { - System.out.println("Corrupt Deadline detected, it is empty"); - } catch (EmptyEventsException e) { - System.out.println("Corrupt Events detected, it is empty"); - } - list.add(task); - } - return list; - } +// public static void addList(ArrayList list) { +// String line; +// Scanner in = new Scanner(System.in); +// line = in.nextLine(); +// while (!line.equals("bye")) { // condition to shut down program +// if (line.equals("list")) { // users wants to know all text so far +// Ui.printCurrentList(list); +// } else if (line.startsWith("mark")) { +// TaskList.mark(line, list); +// Storage.dukeDataStorage(Storage.arraylistToStringConverter(list)); +// } else if (line.startsWith("unmark")) { +// TaskList.unmark(line, list); +// Storage.dukeDataStorage(Storage.arraylistToStringConverter(list)); +// } else if (line.startsWith("delete")) { +// TaskList.delete(line, list); +// Storage.dukeDataStorage(Storage.arraylistToStringConverter(list)); +// } else {// new tasks keyed in by user +// try { +// Task newTask = new Task(line); +// if (line.startsWith("todo")) { +// newTask = new ToDos(line); +// list.add(newTask); +// } else if (line.startsWith("deadline")) { +// newTask = new Deadlines(line); +// list.add(newTask); +// } else if (line.startsWith("event")) { +// newTask = new Events(line); +// list.add(newTask); +// } else { +// throw new NullCommandException(); +// } +// Storage.dukeDataStorage(Storage.arraylistToStringConverter(list)); +// } catch (EmptyToDoException e) { +// System.out.println("Sire, you have yet to tell me what is it you want to do."); +// } catch (EmptyDeadlineException e) { +// System.out.println("Sire, what is it that is due your specified time?"); +// } catch (EmptyEventsException e) { +// System.out.println("Sire, your event is unclear. Please specify."); +// } catch (StringIndexOutOfBoundsException e) { +// System.out.println("Don't hold back Sire. I am here to serve."); +// } catch (NullCommandException e) { +// System.out.println("Sire, I am not trained to understand gibberish."); +// } +// } +// line = in.nextLine(); // read in next line of text +// } +// } } diff --git a/src/main/java/Duke/Parser.java b/src/main/java/Duke/Parser.java new file mode 100644 index 000000000..dbd594d70 --- /dev/null +++ b/src/main/java/Duke/Parser.java @@ -0,0 +1,49 @@ +package Duke; + +import Duke.Exception.NullCommandException; +import Duke.Task.Task; + +public class Parser { + private boolean isRunning = true; + + public String parseCommand(String line) { + if (line.equals("bye")) { + return "B"; + } else if (line.equals("list")) { + return "L"; + } else if (line.startsWith("mark")) { + return "M" + line; + } else if (line.startsWith("unmark")) { + return "U" + line; + } else if (line.startsWith("delete")) { + return "D" + line; + } else if (line.startsWith("find")) { + return "F" + line; + } else { + try { + Task newTask = new Task(line); + if (line.startsWith("todo")) { + return "T" + line; + } else if (line.startsWith("deadline")) { + return "A" + line; + } else if (line.startsWith("event")) { + return "E" + line; + } else { + throw new NullCommandException(); + } + } catch (StringIndexOutOfBoundsException e) { + return "XIOB"; + } catch (NullCommandException e) { + return "XNC"; + } + } + } + + public boolean getIsRunning() { + return this.isRunning; + } + + public void setIsRunning(boolean bool) { + this.isRunning = bool; + } +} diff --git a/src/main/java/Duke/Storage.java b/src/main/java/Duke/Storage.java new file mode 100644 index 000000000..4ec07a1e9 --- /dev/null +++ b/src/main/java/Duke/Storage.java @@ -0,0 +1,117 @@ +package Duke; + +import Duke.Exception.EmptyDeadlineException; +import Duke.Exception.EmptyEventsException; +import Duke.Exception.EmptyToDoException; +import Duke.Task.Deadlines; +import Duke.Task.Events; +import Duke.Task.Task; +import Duke.Task.ToDos; + +import java.io.File; +import java.io.FileNotFoundException; +import java.io.FileWriter; +import java.io.IOException; +import java.util.ArrayList; +import java.util.Scanner; + +public class Storage { + private static final int BRACKETSKIP_INDEX = 7; + private static final int FIRSTBRACKET_FRONT = 0; + private static final int FIRSTBRACKET_BACK = 3; + private static final int SECONDBRACKET_FRONT = 3; + private static final int SECONDBRACKET_BACK = 6; + + private static void writeToFile(String filePath, String textToAdd) throws IOException { + FileWriter fw = new FileWriter(filePath); + fw.write(textToAdd); + fw.close(); + } + + public static void dukeDataStorage(String taskToBeStored) { + File f = new File("dukeData.txt"); + try { + if (!f.exists()) { + f.createNewFile(); + } + writeToFile("dukeData.txt", taskToBeStored); + } catch (IOException e) { + + System.out.println("File creation of writing invalid"); + } + } + + public static void printFileContents(String filePath) throws FileNotFoundException { + File f = new File(filePath); // create a File for the given file path + if (!f.exists()) { // for first log in, there is no file + return; + } + System.out.println("Good day sire, I have listed down your current plan below for you:"); + Scanner s = new Scanner(f); // create a Scanner using the File as the source + while (s.hasNext()) { + String taskStored = s.nextLine(); + System.out.println(taskStored); + } + } + + public static String parseFileContentsToString(String filePath) throws FileNotFoundException { + File f = new File(filePath); // create a File for the given file path + String fileContent = ""; + if (!f.exists()) { // for first log in, there is no file + return fileContent; + } + Scanner s = new Scanner(f); // create a Scanner using the File as the source + while (s.hasNext()) { + String taskStored = s.nextLine(); + fileContent = fileContent + taskStored + System.lineSeparator(); + } + return fileContent; + } + + public static String arraylistToStringConverter(ArrayList list) { + String output = ""; + for (Task t : list) { + output = output + t.toString() + System.lineSeparator(); + } + return output; + } + + public static ArrayList stringToArraylistConverter(String fileContent) { + ArrayList list = new ArrayList<>(); + if (fileContent.equals("")) { + return list; + } + String[] bufferArray = fileContent.split(System.lineSeparator()); + for (String t : bufferArray) { + Task task = new Task(t); + try { + if (t.substring(FIRSTBRACKET_FRONT, FIRSTBRACKET_BACK).equals("[T]")) { + String todoDetail = "todo " + t.substring(BRACKETSKIP_INDEX); + task = new ToDos(todoDetail); + task.setMark(t.substring(SECONDBRACKET_FRONT, SECONDBRACKET_BACK)); + } else if (t.substring(FIRSTBRACKET_FRONT, FIRSTBRACKET_BACK).equals("[D]")) { + String deadlineDetail = "deadline " + t.substring(BRACKETSKIP_INDEX, t.indexOf("(")) + "/" + + t.substring(t.indexOf("(") + 1, t.indexOf(")")); + task = new Deadlines(deadlineDetail); + task.setMark(t.substring(SECONDBRACKET_FRONT, SECONDBRACKET_BACK)); + } else { + String eventDetail = "event " + t.substring(BRACKETSKIP_INDEX, t.indexOf("(")) + "/" + + t.substring(t.indexOf("(") + 1, t.indexOf("to")) + "/" + + t.substring(t.indexOf("to"), t.indexOf(")")); + eventDetail = eventDetail.replace(":", ""); + task = new Events(eventDetail); + task.setMark(t.substring(SECONDBRACKET_FRONT, SECONDBRACKET_BACK)); + } + } catch (EmptyToDoException e) { + System.out.println("Corrupt todo detected, it is empty"); + } catch (EmptyDeadlineException e) { + System.out.println("Corrupt Deadline detected, it is empty"); + } catch (EmptyEventsException e) { + System.out.println("Corrupt Events detected, it is empty"); + } + list.add(task); + } + return list; + } +} + diff --git a/src/main/java/Duke/Task/ToDos.java b/src/main/java/Duke/Task/ToDos.java index c67331914..a4da8fb3f 100644 --- a/src/main/java/Duke/Task/ToDos.java +++ b/src/main/java/Duke/Task/ToDos.java @@ -1,6 +1,7 @@ package Duke.Task; import Duke.Exception.EmptyToDoException; +import Duke.Ui; public class ToDos extends Task { private static final int TODOS_INDEX = 5; diff --git a/src/main/java/Duke/TaskList.java b/src/main/java/Duke/TaskList.java new file mode 100644 index 000000000..2465ab32e --- /dev/null +++ b/src/main/java/Duke/TaskList.java @@ -0,0 +1,99 @@ +package Duke; + +import Duke.Exception.EmptyDeadlineException; +import Duke.Exception.EmptyEventsException; +import Duke.Exception.EmptyToDoException; +import Duke.Exception.NullCommandException; +import Duke.Task.Deadlines; +import Duke.Task.Events; +import Duke.Task.Task; +import Duke.Task.ToDos; + +import java.io.FileNotFoundException; +import java.util.ArrayList; + +public class TaskList { + private static final int MARK_INDEX = 5; + private static final int UNMARK_INDEX = 7; + private static final int DELETE_INDEX = 7; + + private static final int FIND_INDEX = 5; + public static ArrayList list; + + public TaskList(String filepath) { + try { + list = Storage.stringToArraylistConverter(Storage.parseFileContentsToString(filepath)); + } catch (FileNotFoundException e) { + System.out.println("Illegal file path"); + } + } + + public void addTask(String line) { + Ui.addTaskSuccess(); + try { + Task newTask = new Task(line); + if (line.startsWith("todo")) { + newTask = new ToDos(line); + } else if (line.startsWith("deadline")) { + newTask = new Deadlines(line); + } else if (line.startsWith("event")) { + newTask = new Events(line); + } else { + throw new NullCommandException(); + } + this.list.add(newTask); + Ui.printTask(newTask); + Ui.printListSize(this.list); + Storage.dukeDataStorage(Storage.arraylistToStringConverter(this.list)); + } catch (EmptyToDoException e) { + System.out.println("Sire, you have yet to tell me what is it you want to do."); + } catch (EmptyDeadlineException e) { + System.out.println("Sire, what is it that is due your specified time?"); + } catch (EmptyEventsException e) { + System.out.println("Sire, your event is unclear. Please specify."); + } catch (StringIndexOutOfBoundsException e) { + System.out.println("Don't hold back Sire. I am here to serve."); + } catch (NullCommandException e) { + System.out.println("Sire, I am not trained to understand gibberish."); + } + } + + + public void delete(String task) { + String indexOfTask = task.substring(DELETE_INDEX); + Ui.deleteSuccess(this.list, indexOfTask); + this.list.remove(Integer.parseInt(indexOfTask) - 1); + Ui.printListSize(this.list); + Storage.dukeDataStorage(Storage.arraylistToStringConverter(this.list)); + } + + public void mark(String task) { + String indexOfTask = task.substring(MARK_INDEX); // get the number of task to be marked + Task taskToBeMarked = this.list.get(Integer.parseInt(indexOfTask) - 1); // convert from 1-based to 0-based + taskToBeMarked.markTask(); + Ui.markSuccess(list, indexOfTask); + Storage.dukeDataStorage(Storage.arraylistToStringConverter(this.list)); + } + + public void unmark(String task) { + String indexOfTask = task.substring(UNMARK_INDEX); + Task taskToBeUnmarked = this.list.get(Integer.parseInt(indexOfTask) - 1); + taskToBeUnmarked.unmarkTask(); + Ui.unmarkSuccess(list, indexOfTask); + Storage.dukeDataStorage(Storage.arraylistToStringConverter(this.list)); + } + + public void printTasksFound (String task) { + String taskToBeFound = task.substring(FIND_INDEX); + Ui.findSuccess(); + for (int i = 0; i < this.list.size(); ++i) { + if (this.list.get(i).getDescription().contains(taskToBeFound)) { + Ui.printTask(this.list.get(i)); + } + } + } + + public void printCurrentList() { + Ui.printCurrentList(this.list); + } +} diff --git a/src/main/java/Duke/Ui.java b/src/main/java/Duke/Ui.java new file mode 100644 index 000000000..6f1ec8bbf --- /dev/null +++ b/src/main/java/Duke/Ui.java @@ -0,0 +1,79 @@ +package Duke; + +import Duke.Task.Task; + +import java.util.ArrayList; +import java.util.Scanner; + +public class Ui { + private Scanner scanner; + + public Ui() { + this.scanner = new Scanner(System.in); + } + + public void greet() { + String logo = " ____ _ \n" + + "| _ \\ _ _| | _____ \n" + + "| | | | | | | |/ / _ \\\n" + + "| |_| | |_| | < __/\n" + + "|____/ \\__,_|_|\\_\\___|\n"; + System.out.println("Hello from\n" + logo); + System.out.println("How may I be of service today?"); + } + + public void bye() { + System.out.println("Glad I could be of help!"); + } + + public String readCommand() { + return scanner.nextLine(); + } + + public static void addTaskSuccess() { + System.out.println("As per requested Sire, this task has been added to your calendar."); + } + + public static void printTask(Task task) { + System.out.println(task); + } + + public void showLine(String line) { + System.out.println(line); + } + + public static void markSuccess(ArrayList list, String indexOfTask) { + System.out.println("Sir, your task has been marked as completed."); + System.out.println(list.get(Integer.parseInt(indexOfTask) - 1)); + } + + public static void unmarkSuccess(ArrayList list, String indexOfTask) { + System.out.println("Sir, your task has been unmarked as requested."); + System.out.println(list.get(Integer.parseInt(indexOfTask) - 1)); + } + + public static void deleteSuccess(ArrayList list, String indexOfTask) { + System.out.println("Sire, I have removed this task from your schedule"); + System.out.println(list.get(Integer.parseInt(indexOfTask) - 1)); + } + + public static void findSuccess() { + System.out.println("Here are the matching items Sire:"); + } + + public static void printListSize(ArrayList list) { + System.out.println("You now have " + list.size() + " items left"); + } + + public static void printCurrentList(ArrayList list) { + System.out.println("Your current list of items as requested, sir."); + for (int i = 0; i < list.size(); ++i) { + System.out.println((i + 1) + "." + list.get(i)); + } + } + + public void printErrorMessage(String errorMessage) { + System.out.println(errorMessage); + } +} + From c240a47bbe4001b394869be649c48f63aa67523b Mon Sep 17 00:00:00 2001 From: Gujimugger Date: Fri, 3 Mar 2023 23:04:58 +0800 Subject: [PATCH 15/19] Level-9, A-JavaDoc --- src/main/java/Duke/Duke.java | 50 -------------------------- src/main/java/Duke/Parser.java | 20 +++++++++-- src/main/java/Duke/Storage.java | 44 +++++++++++++++-------- src/main/java/Duke/Task/Deadlines.java | 9 +++++ src/main/java/Duke/Task/Events.java | 16 +++++++++ src/main/java/Duke/Task/Task.java | 4 +++ src/main/java/Duke/Task/ToDos.java | 3 ++ src/main/java/Duke/TaskList.java | 40 ++++++++++++++++++--- src/main/java/Duke/Ui.java | 39 +++++++++++++++++--- 9 files changed, 150 insertions(+), 75 deletions(-) diff --git a/src/main/java/Duke/Duke.java b/src/main/java/Duke/Duke.java index 009fb2314..037352410 100644 --- a/src/main/java/Duke/Duke.java +++ b/src/main/java/Duke/Duke.java @@ -31,8 +31,6 @@ public void run() { tasklist.unmark(commandParsed.substring(PARSERINDEX)); } else if (commandParsed.startsWith("D")) { // delete task tasklist.delete(commandParsed.substring(PARSERINDEX)); - } else if (commandParsed.startsWith("XIOB")) { // index out of bound error - ui.printErrorMessage("Index out of bound error. Please try again Sire"); } else if (commandParsed.startsWith("XNC")) { // null command error ui.printErrorMessage("Sire, I am not trained to understand gibberish."); } else { // task keyed in by users @@ -45,52 +43,4 @@ public void run() { public static void main(String[] args) { new Duke("dukeData.txt").run(); } - -// public static void addList(ArrayList list) { -// String line; -// Scanner in = new Scanner(System.in); -// line = in.nextLine(); -// while (!line.equals("bye")) { // condition to shut down program -// if (line.equals("list")) { // users wants to know all text so far -// Ui.printCurrentList(list); -// } else if (line.startsWith("mark")) { -// TaskList.mark(line, list); -// Storage.dukeDataStorage(Storage.arraylistToStringConverter(list)); -// } else if (line.startsWith("unmark")) { -// TaskList.unmark(line, list); -// Storage.dukeDataStorage(Storage.arraylistToStringConverter(list)); -// } else if (line.startsWith("delete")) { -// TaskList.delete(line, list); -// Storage.dukeDataStorage(Storage.arraylistToStringConverter(list)); -// } else {// new tasks keyed in by user -// try { -// Task newTask = new Task(line); -// if (line.startsWith("todo")) { -// newTask = new ToDos(line); -// list.add(newTask); -// } else if (line.startsWith("deadline")) { -// newTask = new Deadlines(line); -// list.add(newTask); -// } else if (line.startsWith("event")) { -// newTask = new Events(line); -// list.add(newTask); -// } else { -// throw new NullCommandException(); -// } -// Storage.dukeDataStorage(Storage.arraylistToStringConverter(list)); -// } catch (EmptyToDoException e) { -// System.out.println("Sire, you have yet to tell me what is it you want to do."); -// } catch (EmptyDeadlineException e) { -// System.out.println("Sire, what is it that is due your specified time?"); -// } catch (EmptyEventsException e) { -// System.out.println("Sire, your event is unclear. Please specify."); -// } catch (StringIndexOutOfBoundsException e) { -// System.out.println("Don't hold back Sire. I am here to serve."); -// } catch (NullCommandException e) { -// System.out.println("Sire, I am not trained to understand gibberish."); -// } -// } -// line = in.nextLine(); // read in next line of text -// } -// } } diff --git a/src/main/java/Duke/Parser.java b/src/main/java/Duke/Parser.java index dbd594d70..4a63ee71b 100644 --- a/src/main/java/Duke/Parser.java +++ b/src/main/java/Duke/Parser.java @@ -6,6 +6,14 @@ public class Parser { private boolean isRunning = true; + /** + * Parse the input from user to determine what to do with the given input by appending + * a characteristic letter in front. + * + * @param line input from user to be parsed. + * @return a string of user's input with characteristic letter appended to the front. + * @throws NullCommandException If input is in invalid format. + */ public String parseCommand(String line) { if (line.equals("bye")) { return "B"; @@ -31,18 +39,26 @@ public String parseCommand(String line) { } else { throw new NullCommandException(); } - } catch (StringIndexOutOfBoundsException e) { - return "XIOB"; } catch (NullCommandException e) { return "XNC"; } } } + /** + * Gets the boolean value of parser object, for termination check of program + * + * @return boolean value of isRunning. + */ public boolean getIsRunning() { return this.isRunning; } + /** + * Sets the boolean value of parser object, to terminate the program + * + * @param bool boolean value of parser object to be set. + */ public void setIsRunning(boolean bool) { this.isRunning = bool; } diff --git a/src/main/java/Duke/Storage.java b/src/main/java/Duke/Storage.java index 4ec07a1e9..22caa1c9d 100644 --- a/src/main/java/Duke/Storage.java +++ b/src/main/java/Duke/Storage.java @@ -22,12 +22,19 @@ public class Storage { private static final int SECONDBRACKET_FRONT = 3; private static final int SECONDBRACKET_BACK = 6; + private static void writeToFile(String filePath, String textToAdd) throws IOException { FileWriter fw = new FileWriter(filePath); fw.write(textToAdd); fw.close(); } + /** + * Write the data to the default file location + * + * @param taskToBeStored info to be written to the file. + * @throws IOException If default file location is invalid. + */ public static void dukeDataStorage(String taskToBeStored) { File f = new File("dukeData.txt"); try { @@ -36,24 +43,17 @@ public static void dukeDataStorage(String taskToBeStored) { } writeToFile("dukeData.txt", taskToBeStored); } catch (IOException e) { - System.out.println("File creation of writing invalid"); } } - public static void printFileContents(String filePath) throws FileNotFoundException { - File f = new File(filePath); // create a File for the given file path - if (!f.exists()) { // for first log in, there is no file - return; - } - System.out.println("Good day sire, I have listed down your current plan below for you:"); - Scanner s = new Scanner(f); // create a Scanner using the File as the source - while (s.hasNext()) { - String taskStored = s.nextLine(); - System.out.println(taskStored); - } - } - + /** + * Parse data stored in file into String object. + * + * @param filePath file path of data file to be read. + * @return String object representing all the data in the data file. + * @throws FileNotFoundException If file path is invalid. + */ public static String parseFileContentsToString(String filePath) throws FileNotFoundException { File f = new File(filePath); // create a File for the given file path String fileContent = ""; @@ -68,6 +68,13 @@ public static String parseFileContentsToString(String filePath) throws FileNotFo return fileContent; } + /** + * Parse data stored in an arraylist to a single String object to be stored in data file. Used + * in writing to data file. + * + * @param list arraylist to be parsed. + * @return String object representing all the data in the data file. + */ public static String arraylistToStringConverter(ArrayList list) { String output = ""; for (Task t : list) { @@ -76,6 +83,15 @@ public static String arraylistToStringConverter(ArrayList list) { return output; } + /** + * Parse data stored as a single String object into an arrayList. Used in reading from data file. + * + * @param fileContent a String object representing data in the file. + * @return arraylist which stores all the tasks stored in file as elements. + * @throws EmptyDeadlineException If task read is empty. + * @throws EmptyToDoException If task read is empty. + * @throws EmptyEventsException If task read is empty. + */ public static ArrayList stringToArraylistConverter(String fileContent) { ArrayList list = new ArrayList<>(); if (fileContent.equals("")) { diff --git a/src/main/java/Duke/Task/Deadlines.java b/src/main/java/Duke/Task/Deadlines.java index 039ea58da..78835cf91 100644 --- a/src/main/java/Duke/Task/Deadlines.java +++ b/src/main/java/Duke/Task/Deadlines.java @@ -9,6 +9,9 @@ public class Deadlines extends Task { private String endTime; private String taskLabel = "[D]"; + /** + * Represents a Deadlines object which is identified by the type D. Contains description and deadline info. + */ public Deadlines(String input) throws EmptyDeadlineException { super(input.substring(DEADLINE_INDEX, input.indexOf('/') - 1)); // Sanitize input by removing "deadline" at the start super.setTaskLabel(taskLabel); @@ -20,6 +23,12 @@ public Deadlines(String input) throws EmptyDeadlineException { // Method of StringBuffer operation taken from // https://www.geeksforgeeks.org/insert-a-string-into-another-string-in-java/ + /** + * Returns the deadline of the task. + * + * @param input user input to be parsed. + * @return deadline of the tasked from parsing. + */ @Override public String getEndTime(String input) { String deadline = input.substring(input.indexOf('/') + 1); // endTime of task is the string after '/' diff --git a/src/main/java/Duke/Task/Events.java b/src/main/java/Duke/Task/Events.java index 787c89252..7fbd77d5d 100644 --- a/src/main/java/Duke/Task/Events.java +++ b/src/main/java/Duke/Task/Events.java @@ -8,6 +8,10 @@ public class Events extends Task { private static final int SECOND_COLON_INDEX = 2; private String timeLine; private String taskLabel = "[E]"; + /** + * Represents an Events object which is identified by the type E. Contains description, start time + * and end time. + */ public Events(String input) throws EmptyEventsException { super(input.substring(EVENT_INDEX, input.indexOf('/') - 1)); super.setTaskLabel(taskLabel); @@ -22,6 +26,12 @@ public String[] splitInput(String input) { return inputAfterSplit; } + /** + * Returns the starting time of the task. + * + * @param input user input to be parsed. + * @return starting time of the tasked from parsing. + */ @Override public String getStartTime(String input) { String[] inputAfterSplit = splitInput(input); @@ -31,6 +41,12 @@ public String getStartTime(String input) { return startTimeCorrectFormat.toString(); } + /** + * Returns the ending time of the task. + * + * @param input user input to be parsed. + * @return ending time of the tasked from parsing. + */ @Override public String getEndTime(String input) { String[] inputAfterSplit = splitInput(input); diff --git a/src/main/java/Duke/Task/Task.java b/src/main/java/Duke/Task/Task.java index 2d4409060..38729d433 100644 --- a/src/main/java/Duke/Task/Task.java +++ b/src/main/java/Duke/Task/Task.java @@ -1,5 +1,9 @@ package Duke.Task; +/** + * Represents a Task object which is identified by the type of task it is (taskLabel), its content (description) + * and whether it is completed or not (mark). + */ public class Task { protected String taskLabel; protected String description; diff --git a/src/main/java/Duke/Task/ToDos.java b/src/main/java/Duke/Task/ToDos.java index a4da8fb3f..8a06b2588 100644 --- a/src/main/java/Duke/Task/ToDos.java +++ b/src/main/java/Duke/Task/ToDos.java @@ -3,6 +3,9 @@ import Duke.Exception.EmptyToDoException; import Duke.Ui; +/** + * Represents a ToDos object which is identified by the type of task T. Contains only description. + */ public class ToDos extends Task { private static final int TODOS_INDEX = 5; private String taskLabel = "[T]"; diff --git a/src/main/java/Duke/TaskList.java b/src/main/java/Duke/TaskList.java index 2465ab32e..9c8995967 100644 --- a/src/main/java/Duke/TaskList.java +++ b/src/main/java/Duke/TaskList.java @@ -20,6 +20,9 @@ public class TaskList { private static final int FIND_INDEX = 5; public static ArrayList list; + /** + * Represents an arraylist of Task objects that can be modified. + */ public TaskList(String filepath) { try { list = Storage.stringToArraylistConverter(Storage.parseFileContentsToString(filepath)); @@ -28,6 +31,15 @@ public TaskList(String filepath) { } } + /** + * Adds a Task object to the TaskList. + * + * @param line input from user indicating the task to be added. + * @throws EmptyToDoException If line is empty. + * @throws EmptyDeadlineException If line is empty. + * @throws EmptyEventsException If line is empty. + * @throws IndexOutOfBoundsException If line's input format violates that of Deadlines or Events object. + */ public void addTask(String line) { Ui.addTaskSuccess(); try { @@ -38,8 +50,6 @@ public void addTask(String line) { newTask = new Deadlines(line); } else if (line.startsWith("event")) { newTask = new Events(line); - } else { - throw new NullCommandException(); } this.list.add(newTask); Ui.printTask(newTask); @@ -53,12 +63,14 @@ public void addTask(String line) { System.out.println("Sire, your event is unclear. Please specify."); } catch (StringIndexOutOfBoundsException e) { System.out.println("Don't hold back Sire. I am here to serve."); - } catch (NullCommandException e) { - System.out.println("Sire, I am not trained to understand gibberish."); } } - + /** + * Deletes the Task object from the TaskList. + * + * @param task input from user indicating the task to be deleted. + */ public void delete(String task) { String indexOfTask = task.substring(DELETE_INDEX); Ui.deleteSuccess(this.list, indexOfTask); @@ -67,6 +79,11 @@ public void delete(String task) { Storage.dukeDataStorage(Storage.arraylistToStringConverter(this.list)); } + /** + * Marks the Task object in the TaskList as done. + * + * @param task input from user indicating the task to be marked. + */ public void mark(String task) { String indexOfTask = task.substring(MARK_INDEX); // get the number of task to be marked Task taskToBeMarked = this.list.get(Integer.parseInt(indexOfTask) - 1); // convert from 1-based to 0-based @@ -75,6 +92,11 @@ public void mark(String task) { Storage.dukeDataStorage(Storage.arraylistToStringConverter(this.list)); } + /** + * Unmarks the Task object in the TaskList as undone. + * + * @param task input from user indicating the task to be unmarked. + */ public void unmark(String task) { String indexOfTask = task.substring(UNMARK_INDEX); Task taskToBeUnmarked = this.list.get(Integer.parseInt(indexOfTask) - 1); @@ -83,6 +105,11 @@ public void unmark(String task) { Storage.dukeDataStorage(Storage.arraylistToStringConverter(this.list)); } + /** + * Prints the Task object in the TaskList. + * + * @param task task object to be printed. + */ public void printTasksFound (String task) { String taskToBeFound = task.substring(FIND_INDEX); Ui.findSuccess(); @@ -93,6 +120,9 @@ public void printTasksFound (String task) { } } + /** + * Prints the current TaskList. + */ public void printCurrentList() { Ui.printCurrentList(this.list); } diff --git a/src/main/java/Duke/Ui.java b/src/main/java/Duke/Ui.java index 6f1ec8bbf..1d5470a8a 100644 --- a/src/main/java/Duke/Ui.java +++ b/src/main/java/Duke/Ui.java @@ -2,6 +2,8 @@ import Duke.Task.Task; +import java.io.File; +import java.io.FileNotFoundException; import java.util.ArrayList; import java.util.Scanner; @@ -19,6 +21,11 @@ public void greet() { + "| |_| | |_| | < __/\n" + "|____/ \\__,_|_|\\_\\___|\n"; System.out.println("Hello from\n" + logo); + try { + printFileContents("dukeData.txt"); + } catch (FileNotFoundException e) { + printErrorMessage("File not found"); + } System.out.println("How may I be of service today?"); } @@ -38,10 +45,6 @@ public static void printTask(Task task) { System.out.println(task); } - public void showLine(String line) { - System.out.println(line); - } - public static void markSuccess(ArrayList list, String indexOfTask) { System.out.println("Sir, your task has been marked as completed."); System.out.println(list.get(Integer.parseInt(indexOfTask) - 1)); @@ -61,10 +64,20 @@ public static void findSuccess() { System.out.println("Here are the matching items Sire:"); } + /** + * Prints out the number of elements in the list. + * + * @param list arraylist whose number of elements is to be printed out. + */ public static void printListSize(ArrayList list) { System.out.println("You now have " + list.size() + " items left"); } + /** + * Prints out all tasks currently in the list. + * + * @param list arraylist whose elements are to be printed out. + */ public static void printCurrentList(ArrayList list) { System.out.println("Your current list of items as requested, sir."); for (int i = 0; i < list.size(); ++i) { @@ -72,6 +85,24 @@ public static void printCurrentList(ArrayList list) { } } + /** + * Prints out all tasks saved in the data file. + * + * @param filePath file path of the data file whose content is to be printed out. + * @throws FileNotFoundException If file path is invalid. + */ + public void printFileContents(String filePath) throws FileNotFoundException { + File f = new File(filePath); // create a File for the given file path + if (!f.exists()) { // for first log in, there is no file + return; + } + System.out.println("Good day sire, I have listed down your current plan below for you:"); + Scanner s = new Scanner(f); // create a Scanner using the File as the source + while (s.hasNext()) { + String taskStored = s.nextLine(); + System.out.println(taskStored); + } + } public void printErrorMessage(String errorMessage) { System.out.println(errorMessage); } From fde76d508d756f10c50396b0d6398fed4f2da62d Mon Sep 17 00:00:00 2001 From: JangusRoundstone <88696064+JangusRoundstone@users.noreply.github.com> Date: Fri, 3 Mar 2023 23:39:28 +0800 Subject: [PATCH 16/19] Create user guide for Duke --- docs/README.md | 170 +++++++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 156 insertions(+), 14 deletions(-) diff --git a/docs/README.md b/docs/README.md index 8077118eb..c5818a880 100644 --- a/docs/README.md +++ b/docs/README.md @@ -1,29 +1,171 @@ -# User Guide +# Duke: Your Personal Agenda Assistant 📑 -## Features +Duke is a Java personal agenda keeper. He is smart enough to assist in your daily activity planning. Below are his functionalities: -### Feature-ABC +1. [Add Task](#add) + 1. [Todo](#t) + 2. [Event](#e) + 3. [Deadline](#d) +2. [Mark/Unmark Task](#mum) + 1. [Mark Task](#mt) + 2. [Unmark Task](#u) +3. [Delete Task](#dt) +4. [List Task](#lt) +5. [Find Task](#ft) +6. [Exit](#end) +-------------------------------------------------------------------- +# NOTE: +* Follow the input format as mentioned below to avoid errors. +-------------------------------------------------------------------- -Description of the feature. +# 1. Add Task -### Feature-XYZ +You can add 3 types of tasks, Todos, Events and Deadlines. -Description of the feature. +## 1.1. Todo +* COMMAND: todo {task} -## Usage -### `Keyword` - Describe action +Input: -Describe the action and its outcome. +```todo return book``` -Example of usage: +Output: +``` +As per requested Sire, this task has been added to your calendar. +[T][ ] return book +You now have 7 items left +``` + + +## 1.2. Event +* COMMAND: event {task} \from {string} \to {string} + +Input: + +```event meeting with friend /from 4pm /to 6pm``` + +Output: +``` +As per requested Sire, this task has been added to your calendar. +[E][ ] meeting with friend (from: 4pm to: 6pm) +You now have 8 items left +``` + +## 1.3. Deadline +* Command: deadline {task} \by {string} + +Input: + +```deadline finish CS2113 assignment/by Sunday``` + +Output: +``` +As per requested Sire, this task has been added to your calendar. +[D][ ] finish CS2113 assignmen (by: Sunday) +You now have 9 items left +``` + + +# 2. Mark/Unmark Task + +Mark the task at the index keyed in by users as done, or unmark it as unfinished. +For index of all current tasks, please see [List Task](#lt). + +## 2.1. Mark Task +* COMMAND: mark {enter task_index} + +Input: + +```mark 1``` + +Output: + +``` +Sir, your task has been marked as completed. +[T][X] Finish CS2113 iP +``` + +## 2.2. Unmark Task +* COMMAND: unmark {enter task_index} + +Input: + +```unmark 2``` + +Output: + +``` +Sir, your task has been unmarked as requested. +[T][ ] sleep +``` + +# 3. Delete Task + +Delete task at keyed in index as follows: + +* COMMAND: delete {enter task_index} + +Input: + +```delete 1``` + +Output: + +``` +Sire, I have removed this task from your schedule +[T][X] Finish CS2113 iP +You now have 8 items left +``` + +# 4. List Task + +List all tasks in the list as follows: + +* COMMAND: list + +Input: + +```list``` -`keyword (optional arguments)` +Output: -Expected outcome: +``` +Your current list of items as requested, sir. +1.[T][ ] sleep +2.[E][ ] project meeting (from: Mon 2pm to: 4pm) +3.[T][ ] return book +4.[E][ ] meeting with friend (from: 4pm to: 6pm) +``` + +# 5. Find Task + +Find the desired tasks by keying in a term they contain as follows: -Description of the outcome. +* COMMAND: find {keyword} +Input: + +```find friend``` + +Output: ``` -expected output +Here are the matching items Sire: +[E][ ] meeting with friend (from: 4pm to: 6pm) ``` + + +# 6. Exit + +Exit the program as follows: + +Input: + +```bye``` + +Output: +``` +Glad I could be of help! +``` + +# End of user guide From e20233745e6e95a4aeb4fb8e6e26dfd56b4b6dc0 Mon Sep 17 00:00:00 2001 From: Gujimugger Date: Sun, 5 Mar 2023 23:32:41 +0800 Subject: [PATCH 17/19] branch-Level-9 --- src/main/java/Duke/Duke.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/Duke/Duke.java b/src/main/java/Duke/Duke.java index 037352410..0d358eaff 100644 --- a/src/main/java/Duke/Duke.java +++ b/src/main/java/Duke/Duke.java @@ -1,7 +1,7 @@ package Duke; public class Duke { - private Ui ui; + private Ui ui; private Storage storage; private TaskList tasklist; private Parser parser; From 806f8740f25b1ad2e324418c6dce7f64d5253b4e Mon Sep 17 00:00:00 2001 From: Gujimugger Date: Sun, 5 Mar 2023 23:36:52 +0800 Subject: [PATCH 18/19] branch-A-JavaDoc --- src/main/java/Duke/Ui.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/Duke/Ui.java b/src/main/java/Duke/Ui.java index 1d5470a8a..a017528ed 100644 --- a/src/main/java/Duke/Ui.java +++ b/src/main/java/Duke/Ui.java @@ -8,7 +8,7 @@ import java.util.Scanner; public class Ui { - private Scanner scanner; + private Scanner scanner; public Ui() { this.scanner = new Scanner(System.in); From 399c136985d2b8d73ea86354feb1f9caa39e0f88 Mon Sep 17 00:00:00 2001 From: Gujimugger Date: Sun, 5 Mar 2023 23:53:01 +0800 Subject: [PATCH 19/19] Published UG JAR released --- src/main/java/Duke/Ui.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/Duke/Ui.java b/src/main/java/Duke/Ui.java index 1d5470a8a..a42222cda 100644 --- a/src/main/java/Duke/Ui.java +++ b/src/main/java/Duke/Ui.java @@ -7,7 +7,7 @@ import java.util.ArrayList; import java.util.Scanner; -public class Ui { +public class Ui { private Scanner scanner; public Ui() {