Merge pull request nus-cs2113-AY2324S1#11 from AY2324S1-CS2113-F11-3/master

Update

Author: Cheezeblokz

data/events/event.txt

@@ -1,3 +1,2 @@
-submit v1.0 | 2023-10-29T23:59:59 | 2023-10-30T23:59:59 
-eat dinner | 2023-12-20T19:00 | 2023-12-20T20:00 
-Do HW | 2023-12-20T12:30:30 | 2023-12-20T12:30:30 
+hello | 2023-12-20T12:30:30 | 2023-12-20T12:30:30 
+EC3333 | 2023-12-20T12:30:30 | 2023-12-20T12:30:40 

docs/README.md

@@ -1,6 +1,8 @@
-# Duke
+# TaskLinker
 
-{Give product intro here}
+TaskLinker is a CLI-tool for helping university students memorize flashcards
+and track their flashcard and general academic progress in the courses they are
+taking.
 
 Useful links:
 * [User Guide](UserGuide.md)

src/main/java/seedu/duke/Duke.java

@@ -31,7 +31,7 @@ private void run() {
                 fc.processInput(input);
             } else if (cm.isResponsible(input)) {
                 cm.processInput(input);
-            } else if (input.equals("exit program")) {
+            } else if (input.equals("exit")) {
                 System.out.println("    You are exiting TaskLinker! Bye!");
                 break;
             } else if (input.startsWith("help")) {
@@ -61,6 +61,7 @@ private void printHelp() {
             "delete all events",
             "find event",
             "list events",
+            "exit",
         };
 
         for (String commandFormat : commandFormats) {

src/main/java/seedu/duke/calendar/Calendar.java

@@ -3,5 +3,10 @@
 package seedu.duke.calendar;
 
 public class Calendar {
+    /**
+     * The class is here for integrating Flashcard goals with the Calendar.
+     * Any other features related to the Calendar can be added here in the future.
+     */
+
     EventList eventList;
 }

src/main/java/seedu/duke/calendar/CalendarCommandParser.java

@@ -10,20 +10,89 @@
 import seedu.duke.calendar.command.FindEventCommand;
 import seedu.duke.calendar.command.ListCalendarEventsCommand;
 
+import seedu.duke.calendar.Exceptions.AddEventException;
+import seedu.duke.calendar.Exceptions.DeleteEventException;
+import seedu.duke.calendar.Exceptions.DeleteAllException;
+import seedu.duke.calendar.Exceptions.FindEventException;
+import seedu.duke.calendar.Exceptions.ListEventException;
+
+import java.util.Scanner;
+
 public class CalendarCommandParser {
+
+    /**
+     * The manageException method is used to throw exceptions if those exceptions have
+     * been encountered. Each if case handles different exception errors. The method
+     * has one parameter (String userInput), which is used to check if the input has
+     * anything else after it.
+     * @param userInput is taken to check if the condition matches the exception.
+     * @throws AddEventException is thrown if the user only inputs add and nothing else.
+     * @throws DeleteEventException is thrown if the user only inputs delete all and nothing else.
+     * @throws DeleteAllException is thrown if the user only inputs delete and nothing else.
+     * @throws FindEventException is thrown if the user only inputs find and nothing else.
+     * @throws ListEventException is thrown if the user only inputs list and nothing else.
+     */
+
+    public static void manageException(String userInput) throws AddEventException, DeleteEventException,
+            DeleteAllException, FindEventException, ListEventException {
+
+        Scanner input = new Scanner(userInput);
+        String command = input.next();
+
+        if (command.equals("add") && !input.hasNext()) {
+            throw new AddEventException();
+        }
+        if (command.equals("delete all") && !input.hasNext()) {
+            throw new DeleteAllException();
+        }
+        if (command.equals("delete") && !input.hasNext()) {
+            throw new DeleteEventException();
+        }
+        if (command.equals("find") && !input.hasNext()) {
+            throw new FindEventException();
+        }
+        if (command.equals("list") && !input.hasNext()) {
+            throw new ListEventException();
+        }
+    }
+
+    /**
+     * The parseInput method is used to catch any exceptions that could occur. The method
+     * has one parameter (String input). The input is used for asserting that it is not null.
+     * If any exceptions are caught, then the corresponding messages are displayed.
+     * Last resort unknown command will run if the command is not recognized.
+     * @param input is used to check whether input is null or not.
+     * @return runs the commands
+     */
+
     public EventCommand parseInput(String input) {
+        // using asser to check whether the input is null.
         assert input != null : "input is null";
 
-        if (input.startsWith("add event")) {
-            return new AddEventCommand(input);
-        } else if (input.startsWith("delete event")) {
-            return new DeleteEventCommand();
-        } else if (input.startsWith("list events")) {
-            return new ListCalendarEventsCommand();
-        } else if (input.startsWith("delete all events")) {
-            return new DeleteAllEventsCommand();
-        } else if (input.startsWith("find event")) {
-            return new FindEventCommand();
+        try {
+            manageException(input);
+            if (input.startsWith("add event")) {
+                return new AddEventCommand();
+            } else if (input.startsWith("delete event")) {
+                return new DeleteEventCommand();
+            } else if (input.startsWith("list events")) {
+                return new ListCalendarEventsCommand();
+            } else if (input.startsWith("delete all events")) {
+                return new DeleteAllEventsCommand();
+            } else if (input.startsWith("find event")) {
+                return new FindEventCommand();
+            }
+
+        } catch (AddEventException exception) {
+            System.out.println("☹ OOPS!!! The description of an add cannot be empty.");
+        } catch (DeleteAllException exception) {
+            System.out.println("☹ OOPS!!! The description of a delete all cannot be empty.");
+        } catch (DeleteEventException exception) {
+            System.out.println("☹ OOPS!!! The description of a delete cannot be empty.");
+        } catch (FindEventException exception) {
+            System.out.println("☹ OOPS!!! The description of an find cannot be empty.");
+        } catch (ListEventException exception) {
+            System.out.println("☹ OOPS!!! The description of a list cannot.");
         }
 
         return new UnknownCommand();

src/main/java/seedu/duke/calendar/CalendarManager.java

@@ -18,6 +18,12 @@ public class CalendarManager {
 
     private EventStorage storage;
 
+    /**
+     * The CalendarManager initializes the accesses to other classes.
+     * It also loads events from the storage.
+     * @param events is used to initialize the EventList.
+     */
+
     public CalendarManager(ArrayList<Event> events) {
 
         EventDirectory eventdirectory = new EventDirectory();
@@ -39,32 +45,46 @@ public CalendarManager(ArrayList<Event> events) {
 
     }
 
+    // getStorage is used for getting the storage
     public EventStorage getStorage(){
         return this.storage;
     }
 
+    /**
+     * validCommand is used for checking whether the command is valid, and
+     * not an instance of UnknownCommand.
+     * @param input is used for converting the input into command.
+     * @return returns whether the command is instance of UnknownCommand or not.
+     */
+
     public boolean validCommand(String input) {
         EventCommand command = calendarCommandParser.parseInput(input);
 
         return !(command instanceof UnknownCommand);
     }
 
+    // isResponsible calls the validCommand method.
     public boolean isResponsible(String input) {
         return validCommand(input);
     }
 
+    // processInput is used for saving the events in the EventList.
     public void processInput(String input) {
         startCalendar(input);
 
         storage.saveEvents(eventList.getEvent());
     }
 
+    /**
+     * startCalender starts the Calendar features and uses the input as a command.
+     * @param input is used for converting the input into command.
+     */
+
     public void startCalendar(String input) {
         EventCommand command = calendarCommandParser.parseInput(input);
         assert !(command instanceof seedu.duke.calendar.command.UnknownCommand) :
                 "Command cannot be " + "unknown";
         calendarUi.executeCommand(command);
         //calendarCommandParser.parseInput(command);
     }
-
 }

src/main/java/seedu/duke/calendar/CalendarUi.java

@@ -8,11 +8,17 @@ public class CalendarUi {
     private Scanner scanner;
     private EventList eventList;
 
+    // CalendarUi is the constructor method for CalendarUi class.
     public CalendarUi (EventList eventList) {
         scanner = new Scanner(System.in);
         this.eventList = eventList;
     }
 
+    /**
+     * executeCommand is used for starting the calendar part of the program.
+     * @param command is used for relaying the command entered by the user.
+     */
+
     public void executeCommand(EventCommand command) {
         command.execute(scanner, eventList);
     }

src/main/java/seedu/duke/calendar/Event.java

@@ -9,36 +9,44 @@ public class Event {
     private LocalDateTime from;
     private LocalDateTime to;
 
+    // Event is a constructor method for Event class.
     public Event(String name, LocalDateTime from, LocalDateTime to) {
         this.name = name;
         this.from = from;
         this.to = to;
     }
 
+    // getName returns the name of the event.
     public String getName() {
         return name;
     }
 
+    // setName is used for setting the event name.
     public void setName(String name) {
         this.name = name;
     }
 
+    // getFrom is used for getting the start time of an Event.
     public LocalDateTime getFrom() {
         return from;
     }
 
+    // setFrom is used for setting the start time of an Event.
     public void setFrom(LocalDateTime from) {
         this.from = from;
     }
 
+    // getFrom is used for getting the end time of an Event.
     public LocalDateTime getTo() {
         return to;
     }
 
+    // setFrom is used for setting the end time of an Event.
     public void setTo(LocalDateTime to) {
         this.to = to;
     }
 
+    // toString is used for formatting the print version of an Event.
     @Override
     public String toString() {
         return "Event '" + name + '\'' +

src/main/java/seedu/duke/calendar/EventDirectory.java

@@ -85,8 +85,8 @@ public String defaultDirectory() {
     /**
      * return directory of flashcard txt file
      * for version 2
-     * @param path
-     * @return
+     * @param path is used for storing file path
+     * @return is used to get the path to the file
      */
     public String eventDirectory(String path) {
         return this.path + path;

src/main/java/seedu/duke/calendar/EventList.java

@@ -7,40 +7,56 @@
 public class EventList {
     private ArrayList<Event> eventList;
 
+    // EventList is a constructor method
     public EventList(ArrayList<Event> eventList) {
         this.eventList = eventList;
     }
 
+    // addEvent is used for adding an event to the EventList.
     public void addEvent(Event event) {
         eventList.add(event);
     }
 
+    // getEvent is used to get an event from the EventList.
     public ArrayList<Event> getEvent() {
         return eventList;
     }
 
-    // for logging
+    // getSize is used for getting the size of EventList.
     public int getSize() {
         return eventList.size();
     }
 
-    public void findEvent(String keyword) {
+    // findEvent is used for finding a specific event from the EventList.
+    public int findEvent(String keyword) {
         int count = 0;
         for (Event event: eventList) {
             if (event.getName().contains(keyword)) {
                 System.out.println((++count) + ". " + event);
             }
         }
+
+        return count;
     }
 
-    public void deleteEvent(String name) {
-        eventList.removeIf(event -> event.getName().equals(name));
+    // deleteEvent is used for deleting an event from the EventList
+    public int deleteEvent(String name) {
+        int size = eventList.size();
+        if (size > 0) {
+            eventList.removeIf(event -> event.getName().equals(name));
+        } else {
+            System.out.println("The Calendar is empty");
+        }
+
+        return size;
     }
 
+    // deleteAllEvents is used for deleting all events in the EventList.
     public void deleteAllEvents() {
         eventList.clear();
     }
 
+    // toString formats the print version of EventList.
     @Override
     public String toString() {
         return "EventStorage{" +