AthletiCLI
++ Your all-in-one solution to track, analyse, and optimize your athletic performance. +
+
+
+ 
+ 
+ :green_book: User Guide + | + :blue_book: Developer Guide + | + :orange_book: About Us +
++ Your all-in-one solution to track, analyse, and optimize your athletic performance. +
+
+
+
+
+ :green_book: User Guide + | + :blue_book: Developer Guide + | + :orange_book: About Us +
+
+
+**Main components of the architecture**
+
+[`AthletiCLI`](https://github.com/AY2324S1-CS2113-T17-1/tp/blob/master/src/main/java/athleticli/AthletiCLI.java) is in charge of the app launch and shut down.
+
+The bulk of the AthletiCLI’s work is done by the following components, with each of them corresponds to a package:
+
+* [`Ui`](https://github.com/AY2324S1-CS2113-T17-1/tp/tree/master/src/main/java/athleticli/ui): Interacts with the user via the command line.
+* [`Parser`](https://github.com/AY2324S1-CS2113-T17-1/tp/tree/master/src/main/java/athleticli/parser): Parses the commands input by the users.
+* [`Storage`](https://github.com/AY2324S1-CS2113-T17-1/tp/tree/master/src/main/java/athleticli/storage): Reads data from, and writes data to, the hard disk.
+* [`Data`](https://github.com/AY2324S1-CS2113-T17-1/tp/tree/master/src/main/java/athleticli/data): Holds the data of AthletiCLI in memory.
+* [`Commands`](https://github.com/AY2324S1-CS2113-T17-1/tp/tree/master/src/main/java/athleticli/commands): Contains multiple command executors.
+
+Other components:
+
+* [`Exceptions`](https://github.com/AY2324S1-CS2113-T17-1/tp/tree/master/src/main/java/athleticli/exceptions): Represents exceptions used by multiple other components.
+* [`Common`](https://github.com/AY2324S1-CS2113-T17-1/tp/tree/master/src/main/java/athleticli/common): Contains configurations that shared by other components.
+
+### Overview
+
+The class diagram shows the relationship between `AthletiCLI`, `Ui`, `Parser`, and `Data`.
+
+
+
+### Data Component
+
+The class diagram shows how the `Data` component is constructed with multiple classes.
+
+
+
+### Parser Component
+
+The class diagram shows how the `Parser` component is constructed with multiple classes.
+
+
+
+**How the architecture components interact with each other**
+
+The _Sequence Diagram_ below shows how the components interact with each other for the scenario where the user issues the command `help add-diet`.
+
+
+
+This diagram involves the interaction between `AthletiCLI`, `Ui`, `Parser`, `Commands` components and the user.
+
+The `Storage` component only interacts with the `Data` component. The _Sequence Diagram_ below shows how they interact with each other for the scenario where a `save` command is executed.
+
+
+
+For simplicity, only 1 `StorableList` is drawn instead of the actual 6.
+
+---
+
+## Implementation
+
+### Diet Management in AthletiCLI
+
+#### [Implemented] Adding, Editing, Deleting, Listing, and Finding Diets
+
+Regardless of the operation you are performing on diets (adding, editing, deleting, listing, or finding), the process
+follows a general five-step pattern in AthletiCLI:
+
+**Step 1 - Input Processing:** The user's input is passed through AthletiCLI to the `Parser` class. Examples of user
+inputs include:
+
+- `add-diet calories/500 protein/20 carb/50 fat/10 datetime/2021-09-01 06:00` for adding a diet.
+- `edit-diet 1 calories/500 protein/20 carb/50 fat/10 datetime/2021-09-01 06:00` for editing a diet at index 1.
+- `delete-diet 1` for deleting a diet at index 1.
+- `list-diet` for listing all diets.
+- `find-diet 2021-09-01` for finding all diets on 1st September 2021.
+
+**Step 2 - Command Identification:** The `Parser` class identifies the type of diet operation and calls the
+appropriate `DietParser` method to parse the necessary parameters (if any). For example, the `add-diet` command will
+call the `DietParser#parseDiet()` method, which will return a `Diet` object.
+
+**Step 3 - Command Creation**: An instance of the corresponding command class is created (e.g., `AddDietCommand`,
+`EditDietCommand`, etc.) using the returned object (if any) from the `DietParser` and returned to AthletiCLI.
+
+**Step 4 - Command Execution**: AthletiCLI executes the command, interacting with the data instance of DietList to
+perform the required operation. For example, the `AddDietCommand` will add the `Diet` object to the `DietList` object,
+while the `EditDietCommand` will edit the `Diet` object at the specified index in the `DietList` object.
+
+**Step 5 - Result Display**: A message is returned post-execution and passed through AthletiCLI to the UI for
+display to the user. This is useful for informing the user of the success or failure of the operation.
+
+By following these general steps, AthletiCLI ensures a streamlined process for managing diet-related tasks.
+
+Here is the sequence diagram for the `edit-diet` command to illustrate the five-step process:
+
+
+
+> The diagram shows the interaction between the `AthletiCLI`, `Parser`, `Command`, and `Data` components.
+> The use of HashMaps in the `DietParser` class allows for a more flexible and extensible design, as it facilitates
+> the modification of necessary parameters without requiring the user to specify all parameters in the command. For
+> example, the user can choose to edit only the calories and protein of a diet, without specifying the carb and fat values.
+
+
+#### [Implemented] Setting Up of Diet Goals
+
+This following sequence diagram show how the 'set-diet-goal' command works:
+
+
+
+**Step 1:** The input from the user ("set-diet-goal WEEKLY fat/1") runs through AthletiCLI to the Parser Class.
+
+**Step 2:** The Parser Class will identify the request as setting up a diet goal and pass in the parameters
+"WEEKLY fat/1".
+
+**Step 3:** A temporary dietGoalList is created to store newly created diet goals. In this case, a weekly healthy goal
+for fat with a target value of 1mg.
+
+**Step 4:** The inputs are validated against our lists of approved diet goals.
+
+**Step 5:** For each of the diet goals that are valid, if it is a healthy goal, a HealthyDietGoal object will be created and stored in the
+temporary dietGoalList, else an UnhealthyDietGoal will be created instead.
+
+**Step 6:** The Parser then creates for an instance of SetDietGoalCommand and returns the instance to
+AthletiCLI.
+
+**Step 7:** AthletiCLI will execute the SetDietGoalCommand. This adds the dietGoals that are present in the
+temporary list into the data instance of DietGoalList which will be kept for records.
+
+**Step 8:** After executing the SetDietGoalCommand, SetDietGoalCommand returns a message that is passed to
+AthletiCLI to be passed to UI(not shown) for display.
+
+#### [Proposed] Future Implementation of DietGoalList Class
+
+The current implementation of DietGoalList is an ArrayList. This is because the number of nutrients currently is 4. O(n^2)
+operations can be treated as O(1). Furthermore, DietGoalListClass gets to inherits from superclass like its other goals' counterpart.
+However, it is not efficient in searching for a particular dietGoal especially when the number of goals and time span for goals increases.
+At any instance of time, there could only be the existence of one dietGoal.
+Verifying if there is an existence of a diet goal using an ArrayList takes O(n) time, where n is the number of dietGoals.
+The proposed change will be to change the underlying data structure to a hashmap in the future for amortised O(1) time complexity
+for checking the presence of a dietGoal.
+
+### Activity Management in AthletiCLI
+
+#### [Implemented] Adding activities
+
+The `add-activity` feature is a core functionality which allows users to record new activities in the application.
+The feature is designed in a modular and extendable way, ensuring seamless integration of future enhancements and
+especially new activity types.
+
+The architecture of the `add-activity` feature is composed of the following main components.
+1. `AthletiCLI`: Facilitates the mechanism. It captures the user input and initiates the parsing and execution.
+2. `Parser` (`Activity Parser`): Interprets the user input, generating both the appropriate command object and
+ the activity instance.
+3. `AddActivityCommand`: Encapsulates the execution of the `add-activity` command, adding the activity to the data.
+4. `ActivityChanges`: Contains the arguments of the activity to be added. It is used to transfer the data from the
+ parser to the activity in a modular way.
+5. `Activity`: Represents the activity to be added. It is a superclass for specific activity types like Run, Swim and
+ Cycle.
+6. `Data`: Manages the current state of the activity list.
+7. `ActivityList`: Maintains the list of all activities added to the application.
+
+
+Class Relationships:
+
+Below is a class diagram illustrating the relationships between the data components `Activity`,`Data` and
+`ActivityList`:
+
+
+
+> The diagram shows the inheritance relationship between the `Activity` class and the specific activity types `Run`,
+> `Swim` and `Cycle`, each with unique attributes and methods. This design becomes especially crucial in future
+> development cycles with added parameters and activity types. The `ActivityList` aggregates these instances.
+
+Usage Scenario and Process Flow:
+
+The process of adding an activity involves several steps, each handled by different components.
+Given below is an example usage scenario on how the add mechanism behaves.
+
+**Step 1 - Input Capture:** The user issues an `add-activity ...` (or `add-run`, etc.) command which is
+captured and forwarded to the Parser by the running AthletiCLI instance.
+
+**Step 2 - Activity Parsing:** The ActivityParser interprets the raw input to obtain the arguments of the activity.
+Given that all parameters are provided correctly and no exception is thrown, a new activity object is created.
+
+This diagram illustrates the activity parsing process in more detail:
+The `ActivityChanges` object plays a key role in the parsing process. It is used for storing the
+different attributes of the activity that are to be added. Later, the `ActivityParser`
+will use the `ActivityChanges` to create the `Activity` object.
+> This way of transferring data between the parser and the activity is more flexible which is suitable for future
+> extensions of the activity types and allows for a more modular design. This design and most of the methods can be reused
+> for the `edit-activity` mechanism, which works in the same way with slight modifications due to optional parameters.
+
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
AthletiCLI object.
+ */
+ private AthletiCLI() {
+ LogManager.getLogManager().reset();
+ try {
+ logger.addHandler(new FileHandler("%t/athleticli-log.txt"));
+ } catch(IOException e) {
+ logger.addHandler(new ConsoleHandler());
+ }
+ }
+
+ /**
+ * Creates an `AthletiCLI` object and runs it.
+ *
+ * @param args Arguments obtained from the command line.
+ */
+ public static void main(String[] args) {
+ new AthletiCLI().run();
+ }
+
+ /**
+ * Displays the welcome interface, continuously reads user input
+ * and executes corresponding instructions until exiting.
+ */
+ private void run() {
+ logger.entering(getClass().getName(), "run");
+ ui.showWelcome();
+ try {
+ data.load();
+ } catch (AthletiException e) {
+ ui.showException(e);
+ data.clear();
+ }
+ boolean isExit = false;
+ boolean isShutdownHookAdded = false;
+ while (!isExit) {
+ final String rawUserInput = ui.getUserCommand();
+ try {
+ logger.info("Command read: " + rawUserInput);
+ final Command command = Parser.parseCommand(rawUserInput);
+ final String[] feedback = command.execute(data);
+ ui.showMessages(feedback);
+ logger.info("Command executed successfully");
+ isExit = command.isExit();
+ /* add shutdown hook if the first valid command is not exit */
+ if (!isExit && !isShutdownHookAdded) {
+ /* save data when the JVM begins its shutdown sequence */
+ Runtime.getRuntime().addShutdownHook(runSaveCommand);
+ isShutdownHookAdded = true;
+ }
+ } catch (AthletiException e) {
+ ui.showException(e);
+ logger.warning("Exception caught: " + e);
+ }
+ }
+ logger.exiting(getClass().getName(), "run");
+ }
+}
diff --git a/src/main/java/athleticli/commands/ByeCommand.java b/src/main/java/athleticli/commands/ByeCommand.java
new file mode 100644
index 0000000000..afb77333d5
--- /dev/null
+++ b/src/main/java/athleticli/commands/ByeCommand.java
@@ -0,0 +1,26 @@
+package athleticli.commands;
+
+import athleticli.data.Data;
+import athleticli.exceptions.AthletiException;
+import athleticli.ui.Message;
+
+public class ByeCommand extends Command {
+ /**
+ * Returns true if this is a ByeCommand object, otherwise returns false.
+ *
+ * @return true if this is a ByeCommand object, otherwise returns false.
+ */
+ @Override
+ public boolean isExit() {
+ return true;
+ }
+
+ /**
+ * Returns the bye message to be shown to the user.
+ *
+ * @return The messages to be shown to the user.
+ */
+ public String[] execute(Data data) throws AthletiException {
+ return new String[] {Message.MESSAGE_BYE};
+ }
+}
diff --git a/src/main/java/athleticli/commands/Command.java b/src/main/java/athleticli/commands/Command.java
new file mode 100644
index 0000000000..3015f2d6b4
--- /dev/null
+++ b/src/main/java/athleticli/commands/Command.java
@@ -0,0 +1,27 @@
+package athleticli.commands;
+
+import athleticli.data.Data;
+import athleticli.exceptions.AthletiException;
+
+/**
+ * Defines the basic methods of a command.
+ */
+public abstract class Command {
+ /**
+ * Executes the command and returns the messages to be shown to the user.
+ *
+ * @param data The current data.
+ * @return The messages to be shown to the user.
+ * @throws AthletiException
+ */
+ public abstract String[] execute(Data data) throws AthletiException;
+
+ /**
+ * Returns true if this is a ByeCommand object, otherwise returns false.
+ *
+ * @return true if this is a ByeCommand object, otherwise returns false.
+ */
+ public boolean isExit() {
+ return false;
+ }
+}
diff --git a/src/main/java/athleticli/commands/FindCommand.java b/src/main/java/athleticli/commands/FindCommand.java
new file mode 100644
index 0000000000..05291bdc28
--- /dev/null
+++ b/src/main/java/athleticli/commands/FindCommand.java
@@ -0,0 +1,36 @@
+package athleticli.commands;
+
+import java.time.LocalDate;
+import java.util.stream.Stream;
+
+import athleticli.commands.activity.FindActivityCommand;
+import athleticli.commands.diet.FindDietCommand;
+import athleticli.commands.sleep.FindSleepCommand;
+import athleticli.data.Data;
+import athleticli.exceptions.AthletiException;
+
+public class FindCommand extends Command {
+ protected LocalDate date;
+
+ public FindCommand(LocalDate date) {
+ this.date = date;
+ }
+
+ /**
+ * Returns the records to be shown to the user.
+ *
+ * @param data The current data.
+ * @return The records to be shown to the user.
+ * @throws AthletiException
+ */
+ @Override
+ public String[] execute(Data data) throws AthletiException {
+ var activities = Stream.of(new FindActivityCommand(date).execute(data));
+ var diets = Stream.of(new FindDietCommand(date).execute(data));
+ var sleeps = Stream.of(new FindSleepCommand(date).execute(data));
+ return Stream.of(activities, diets, sleeps)
+ .reduce(Stream::concat)
+ .orElseGet(Stream::empty)
+ .toArray(String[]::new);
+ }
+}
diff --git a/src/main/java/athleticli/commands/HelpCommand.java b/src/main/java/athleticli/commands/HelpCommand.java
new file mode 100644
index 0000000000..556d04be5a
--- /dev/null
+++ b/src/main/java/athleticli/commands/HelpCommand.java
@@ -0,0 +1,125 @@
+package athleticli.commands;
+
+import static java.util.Map.entry;
+
+import java.util.Map;
+
+import athleticli.data.Data;
+import athleticli.exceptions.AthletiException;
+import athleticli.parser.CommandName;
+import athleticli.ui.Message;
+
+public class HelpCommand extends Command {
+ private static final String[] HELP_ALL = {
+ /* Activity Management */
+ "\nActivity Management:",
+ Message.HELP_ADD_ACTIVITY,
+ Message.HELP_ADD_RUN,
+ Message.HELP_ADD_SWIM,
+ Message.HELP_ADD_CYCLE,
+ Message.HELP_DELETE_ACTIVITY,
+ Message.HELP_LIST_ACTIVITY,
+ Message.HELP_EDIT_ACTIVITY,
+ Message.HELP_EDIT_RUN,
+ Message.HELP_EDIT_SWIM,
+ Message.HELP_EDIT_CYCLE,
+ Message.HELP_FIND_ACTIVITY,
+ Message.HELP_SET_ACTIVITY_GOAL,
+ Message.HELP_EDIT_ACTIVITY_GOAL,
+ Message.HELP_DELETE_ACTIVITY_GOAL,
+ Message.HELP_LIST_ACTIVITY_GOAL,
+ /* Diet Management */
+ "\nDiet Management:",
+ Message.HELP_ADD_DIET,
+ Message.HELP_EDIT_DIET,
+ Message.HELP_DELETE_DIET,
+ Message.HELP_LIST_DIET,
+ Message.HELP_FIND_DIET,
+
+ Message.HELP_SET_DIET_GOAL,
+ Message.HELP_EDIT_DIET_GOAL,
+ Message.HELP_DELETE_DIET_GOAL,
+ Message.HELP_LIST_DIET_GOAL,
+ /* Sleep Management */
+ "\nSleep Management:",
+ Message.HELP_ADD_SLEEP,
+ Message.HELP_LIST_SLEEP,
+ Message.HELP_DELETE_SLEEP,
+ Message.HELP_EDIT_SLEEP,
+ Message.HELP_FIND_SLEEP,
+ Message.HELP_SET_SLEEP_GOAL,
+ Message.HELP_EDIT_SLEEP_GOAL,
+ Message.HELP_LIST_SLEEP_GOAL,
+ /* Misc */
+ "\nMisc:",
+ Message.HELP_FIND,
+ Message.HELP_SAVE,
+ Message.HELP_BYE,
+ Message.HELP_HELP,
+ "\n" + Message.HELP_DETAILS
+ };
+ private static final Map