[CS2113-T10-1] EasInternship

.gitignore

@@ -2,6 +2,7 @@
 /.idea/
 /out/
 /*.iml
+/data/
 
 # Gradle build files
 /.gradle/
@@ -13,5 +14,8 @@ src/main/resources/docs/
 *.iml
 bin/
 
+# data files
+data/EasInternship.txt
 /text-ui-test/ACTUAL.TXT
 text-ui-test/EXPECTED-UNIX.TXT
+META-INF/MANIFEST.MF

META-INF/MANIFEST.MF

@@ -0,0 +1,3 @@
+Manifest-Version: 1.0
+Main-Class: seedu.duke.EasInternship
+

README.md

@@ -1,7 +1,24 @@
+//@@ jadenlimjc
 # Duke project template
 
 This is a project template for a greenfield Java project. It's named after the Java mascot _Duke_. Given below are instructions on how to use it.
 
+
+## Product Description
+This product aims to streamline the tracking of internship applications for the user, where the user is able to store key details of the internship as well as save and edit the status of the application. 
+
+**By using this tool, the user can:**
+
+**Store Important seedu.duke.Internship Information:** Users can input and store key details such as the role, company, duration, required skills, application deadlines, and any additional notes.
+
+**Track Application Status:** Users can save the current status of their application (e.g., not applied, applied, interview scheduled, offer received) and update it as the application progresses.
+
+**Edit and Manage Internships:** Users have the ability to edit saved internships as needed, modify statuses, update deadlines, or remove outdated internships from the list.
+
+**Filter Internships by Key Criteria:** The user can filter the tracked internships by relevant skills, application status, or upcoming deadlines, allowing for better organization and prioritization.
+
+**Monitor Deadlines Easily:** The tool helps ensure users stay on top of their internship deadlines by flagging or sorting applications with approaching deadlines.
+
 ## Setting up in Intellij
 
 Prerequisites: JDK 17 (use the exact version), update Intellij to the most recent version.
@@ -25,6 +42,18 @@ Prerequisites: JDK 17 (use the exact version), update Intellij to the most recen
    What is your name?
    ```
    Type some word and press enter to let the execution proceed to the end.
+**CS2113 T10 Team 1**
+
+**Jaden Lim Jie Chen**
+
+**Tan Ting Hui**
+
+**Jai Vinod Kumar Rahul**
+
+**Man Kit Yu****
+
+
+
 
 ## Build automation using Gradle
 

build.gradle

@@ -43,4 +43,5 @@ checkstyle {
 
 run{
     standardInput = System.in
+    enableAssertions = true;
 }

data/EasInternship.txt

@@ -0,0 +1,4 @@
+1 | ABC | XYZ | 01/01 | 01/01 |  | Application Pending | No Deadlines set.
+2 | software engineer | abs | 01/01 | 03/24 | python, c++, backend | Application Completed | No Deadlines set.
+3 | lawyer | lolo pte ltd | 04/23 | 01/01 | source, terry | Application Completed | Application deadline -date 03/12/04
+4 | Technician | Nokia | 12/22 | 12/30 | java, c++ | Application Pending | interview round 1 -date 26/04/24 - interview round 2 -date 14/05/24

docs/AboutUs.md

@@ -1,9 +1,8 @@
 # About us
 
-Display | Name | Github Profile | Portfolio 
---------|:----:|:--------------:|:---------:
-![](https://via.placeholder.com/100.png?text=Photo) | John Doe | [Github](https://github.com/) | [Portfolio](docs/team/johndoe.md)
-![](https://via.placeholder.com/100.png?text=Photo) | Don Joe | [Github](https://github.com/) | [Portfolio](docs/team/johndoe.md)
-![](https://via.placeholder.com/100.png?text=Photo) | Ron John | [Github](https://github.com/) | [Portfolio](docs/team/johndoe.md)
-![](https://via.placeholder.com/100.png?text=Photo) | John Roe | [Github](https://github.com/) | [Portfolio](docs/team/johndoe.md)
-![](https://via.placeholder.com/100.png?text=Photo) | Don Roe | [Github](https://github.com/) | [Portfolio](docs/team/johndoe.md)
+Display |   Name    |             Github Profile              | Portfolio 
+--------|:---------:|:---------------------------------------:|:---------:
+![](/images/jaden.png) | Jaden Lim | [Github](https://github.com/jadenlimjc) | [Portfolio](https://www.linkedin.com/in/jadenlimjc/)
+![](https://via.placeholder.com/100.png?text=Photo) | Yu Man Kit | [Github](https://github.com/Toby-Yu) | [Portfolio](toby-yu)
+![](https://via.placeholder.com/100.png?text=Photo) | Rahul | [Github](https://github.com/rahuljai-05) | [Portfolio](rahuljai-05)
+![](https://via.placeholder.com/100.png?text=Photo) | Tan Ting Hui | [Github](https://github.com/Ridiculouswifi) | [Portfolio](ridiculouswifi)

docs/DeveloperGuide.md

@@ -8,8 +8,237 @@
 
 {Describe the design and implementation of the product. Use UML diagrams and short code snippets where applicable.}
 
+### EasInternship (main class)
 
-## Product scope
+1. [Design](#design)
+   1. [Architecture](#architecture)
+   2. [UI Component](#ui-component)
+   3. [Logic Component](#logic-component)
+   4. [Model Component](#model-component)
+   5. [Storage Component](#storage-component)
+2. [Implementation](#implementation)
+   1. [Parsing Input](#parsing-input)
+   2. [Command Execution](#command-execution)
+   3. [Task Management](#task-management) 
+   4. [AddCommand Implementation](#addcommand-implementation)
+   5. [DeleteCommand Implementation](#deletecommand-implementation)
+   6. [SortCommand Implementation](#sortcommand-implementation)
+   7. [UpdateCommand Implementation](#updatecommand-implementation)
+
+---
+
+## 1. Design
+
+### 1.1 Architecture
+The architecture of EasInternship is designed to follow the MVC (Model-View-Controller) pattern to facilitate separation of concerns, modularity, and maintainability.
+
+- **View (UI)**: Responsible for interacting with the user by displaying output and reading input.
+- **Controller (Command and Parser)**: Responsible for parsing user input and invoking the appropriate commands.
+- **Model (InternshipList)**: Manages the state of the application, including the list of internships and tasks.
+- **Storage**: Responsible for loading and saving data from and to the disk.
+
+---
+
+### 1.2 UI Component
+
+The UI component is responsible for displaying information to the user and reading input. It interacts with the user by printing messages and prompts, and retrieves commands for the rest of the application to process.
+
+### 1.3 Logic Component
+
+The logic component is handled by the `Parser` and `Command` classes. The `Parser` interprets the user's input and returns a command object, which is then executed to perform the desired operation.
+
+### 1.4 Model Component
+
+The model component includes the `Internship`, `InternshipList`, `Deadline` and `DeadlineList` classes.
+
+`Internship`: Represents the individual internship entries.
+
+`InternshipList`: Manages a collection of Internship objects, providing methods for adding, retrieving, updating, sorting and removing internships.
+
+`Deadline`: Represents each individual deadline associated with an internship, holding data specific to that deadline (description, date).
+
+Each `Internship` object contains a `Deadline` list, and has methods to add, retrieve or remove deadlines associated with that internship.
+
+This is represented with the class diagram below:
+
+![](UML/Internship-Model_Component.png)
+
+### 1.5 Storage Component
+
+The storage component is responsible for saving the current state of the `InternshipList` to a file and loading it back when the application is restarted. This ensures that users' progress is preserved between sessions.
+The data from the internshipList is saved into a .txt file.
+
+There are two main functions, `loadFromFile` and `saveFromFile`.
+
+The following sequence diagrams depict how the Storage Functions work.
+![](UML/loadFromFile.png)
+![](UML/saveToFile.png)
+
+
+## 2. Implementation
+
+### 2.1 Parsing Input
+
+The `Parser` class is responsible for parsing the input strings provided by the user. It breaks down the input into individual components like the command and its accompanying arguments. After parsing, it returns a `Command` object.
+
+### 2.2 Command Execution
+
+The `Command` class and its subclasses handle the execution of specific commands. Once a command is parsed, it is executed with the required arguments, and the result is displayed to the user.
+
+### 2.3 Task Management
+
+The `InternshipList` class handles adding, removing, and retrieving internships from the list. It interacts with both the UI and the storage components to ensure that updates are reflected in the user interface and persisted to disk.
+
+---
+
+### Overview
+
+The `EasInternship` class serves as the entry point of the application. It manages the application's main loop, where the user is continually prompted for input, and commands are processed in response. The class is responsible for initializing the UI, loading saved data, and handling user input until the user chooses to exit the program.
+
+### Key Responsibilities
+
+- **Initialization**: Initializes the necessary components for the application, such as the `Ui`, `InternshipList`, and `Parser` classes. It also loads any saved data from the storage into the `InternshipList`.
+- **Main Loop**: Continuously prompts the user for input. The input is parsed by the `Parser`, and the corresponding `Command` is executed. If the user enters the exit command, the loop terminates.
+- **Command Processing**: After parsing the user input, the corresponding `Command` object is executed. The application catches and displays any errors that occur during command execution.
+- **Saving State**: Upon exiting, the current state of the `InternshipList` is saved to a file to ensure persistence across sessions.
+
+### Flow of Execution
+
+1. **Welcome Message**: The `Ui` class displays a welcome message to the user.
+2. **Load Data**: The `Storage` class loads any saved internships into the `InternshipList`.
+3. **Input Loop**: The application enters a loop, prompting the user for input.
+4. **Command Parsing**: The `Parser` interprets the input and returns the appropriate `Command`.
+5. **Command Execution**: The command is executed, and the `InternshipList` is updated accordingly.
+6. **Exit Flow**: If the user enters the exit command, the `InternshipList` is saved, and the application displays a goodbye message.
+
+### Methods
+
+- `public static void main(String[] args)`: The entry point of the application. It handles initialization, the main user input loop, and command execution.
+
+### Error Handling
+
+If the user inputs an unknown command or a command fails during execution, the `Ui` class displays an appropriate error message. This ensures that the application can continue running despite errors in user input.
+
+---
+
+### AddCommand Implementation
+
+#### Overview:
+The `AddCommand` class is responsible for adding internship listings to the Internship List. It extends the `Command` class, providing the add functionality as part of the command execution framework.
+
+#### Design:
+- The `AddCommand` class processes user input to determine what fields to add to the new internship listing.
+- If no arguments or invalid arguments are given, it prompts the user with an error message indicating which fields are erroneous.
+
+#### Key Methods:
+- `execute(ArrayList<String> args)`: Handles addition logic based on the inputs provided. If the user provides an appropriate "role" and "company", the internship is added to the listing. Otherwise, the user is prompted with which fields are missing. The user also can input start and end dates of the internship during the addition.
+- **`getUsage()`**: Returns a string showing the correct usage of the `add` command and the expected input.
+
+#### Example Usage Scenario:
+- The user enters `add -role Software Engineer -company Google`, and the execute method adds the internship to the InternshipList The start and end dates are defaulted to 01/01.
+
+
+- The user enters `add -role Software Engineer -company Facebook -from 10/24 -to 06/25`, and the execute method adds the internship with the specified dates to the InternshipList.
+
+
+- The user enters `add -role Software Engineer`. The execute method detects that no company has been specified and adds `company` to the list of invalid flags. uiCommand is then called and prints an error statement of all invalid flags detected.
+
+#### Sequence Diagram:
+
+The following sequence diagram shows how the `AddCommand` is executed:
+![AddCommandSequenceDiagram](UML/AddCommand_Sequence_Diagram.png)
+
+### DeleteCommand Implementation
+
+#### Overview: 
+The `DeleteCommand` class is responsible for deleting internship listings from the Internship List. It extends the `Command` class, providing the delete functionality as part of the command execution framework.
+
+#### Design:
+- The `DeleteCommand` class processes user input to determine which `Internship` to remove from the `InternshipList`.
+- If no arguments or invalid arguments are given, it prompts the user with an error message indicating which fields are erroneous.
+
+#### Key Methods:
+- `execute(ArrayList<String> args)` : Handles deletion logic based on the inputs provided. If the user provides an appropriate `internshipID`, the `Internship` is deleted from the `InternshipList`. Otherwise, if an inappropriate or no `internshipID` is specified, the user is prompted that the `internshipID` is invalid.
+
+
+- `getUsage()`: Returns a string showing the correct usage of the `delete` command and the expected input.
+
+#### Example Usage Scenario:
+- The user enters `delete 1`. The execute method removes the `Internship` from the `InternshipList` if the `internshipID` is valid.
+- The user enters `delete -1`. The execute method detects that the `internshipID` is invalid. uiCommand is called and prints an output `Invalid integer, please provide a valid internship ID`.
+
+#### Sequence Diagram
+The following sequence diagram shows how the `DeleteCommand` is executed:
+![DeleteCommandSequenceDiagram](UML/DeleteCommand_Sequence_Diagram.png)
+
+
+
+### SortCommand Implementation
+
+#### Overview:
+The `SortCommand` class is responsible for sorting the internship listings based on different criteria such as the internship role, skills and status (alphabetically) , the application deadline (by start and end dates). It extends the `Command` class, providing the sorting functionality as part of the command execution framework.
+
+#### Design:
+- The `SortCommand` class processes user input to determine which sorting method to apply (e.g., role or deadline).
+- If no arguments or invalid arguments are given, it defaults to listing internships by ID.
+
+#### Key Methods:
+- **`execute(ArrayList<String> args)`**: Handles sorting logic based on the first argument provided. The valid sort options include:
+   - `"alphabet"`: Sorts internships by role alphabetically.
+   - `"duration"`: Sorts internships by duration (start and end dates).
+   - `"deadline"`: Sorts internships by deadline.
+   - `"skills"`: Sorts internships by the first skill in the skills list alphabetically.
+   - `"status"`: Sorts internships by status alphabetically.
+- If the user provides an invalid sort option, the command returns an error and defaults to listing internships by ID.
+- **`getUsage()`**: Returns a string showing the correct usage of the `sort` command, including valid options like "alphabet", "deadline", "duration", "skills", and "status".
+
+#### Example Usage Scenario:
+1. The user enters `sort alphabet`, and the `execute` method sorts the internships by role.
+2. The user enters `sort deadline`, and the internships are sorted by their start and end dates.
+3. The user enters `sort skills`, and the internships are sorted by the first skill alphabetically.
+4. The user enters `sort status`, and the internships are sorted by their status alphabetically.
+5. If the user enters an invalid sort option, the command returns an error and lists the internships by ID.
+
+#### Sequence Diagram:
+The following sequence diagram shows how the `SortCommand` is executed:
+![](UML/loadFromFile.png)
+
+
+### UpdateCommand Implementation
+
+#### Overview
+The `UpdateCommand` class is responsible for updating the fields of an internship. It extends the `Command` class, providing an updating functionality as part of the command execution framework.
+
+#### Design
+- The `UpdateCommand` class processes the user input to determine which internship and which field to update.
+- If the internship ID is not valid, it will print a message accordingly.
+- If the field is not valid, it will print a message indicating the erroneous field.
+- If the value provided with the field is not valid, it will also print a message indicating the erroneous value.
+
+#### Key Methods
+- `execute(ArrayList<String> args)`: Handles the logic to find the internship entry and determine which field to update. The valid fields include:
+  - `status`: Updates the status of the internship.
+  - `skills`: Adds skills to the relevant field of the internship
+  - `role`: Updates the role of the internship
+  - `company`: Updates the company of the internship
+  - `from`: Updates the start date of the internship
+  - `to`: Updates the end date of the internship
+  - `deadlines`: Updates the deadlines of the internship
+- `isValidValue(String[] words)`: Checks if there was a new value provided for the selected field.
+- `updateOneField(String[] words, int internshipIndex)`: Called within `execute(args)` to invoke the appropriate method to update the field.
+- `getUsage()`: Returns a string showing the correct usage of the `update` command.
+
+#### Example Usage Scenario:
+- The user enters `update 2 -status Application Completed`, and the `execute` method finds the internship with ID `2` and updates its `status` to `Application Completed`.
+- The user enters `update 4 -status Application Completed`, if `4` is not a valid ID, the `execute` method will print a message to show the ID is out of bounds.
+- The user enters `update 2 -skills`, no value is given after the `-skills` flag, the `isValidValue` method returns false and prints a message to indicate the need for a value.
+- The user enters `update 2 -from Tomorrow`, `Tomorrow` is not a valid date, the `execute` method prints message to indicate it is an invalid value.
+
+#### Sequence Diagram
+The following sequence diagram shows how the `UpdateCommand` is executed:
+![](UML/UpdateCommand_Sequence_Diagram.png)
+
+### Product scope
 ### Target user profile
 
 {Describe the target user profile}

docs/UML/AddCommand.puml

@@ -0,0 +1,63 @@
+@startuml
+title AddCommand Sequence Diagram
+
+participant User
+participant AddCommand
+participant uiCommand
+participant Internship
+participant InternshipList
+
+
+User->AddCommand:execute(args)
+activate AddCommand #red
+AddCommand-->uiCommand:clearInvalidFlags()
+activate uiCommand #green
+AddCommand->AddCommand : Initialize variables
+
+loop for each arg in args
+  AddCommand -> AddCommand : split arg into flag and data
+  alt flag == "role"
+    AddCommand -> AddCommand: hasRole = true
+    alt data is present
+      AddCommand-> AddCommand: set role
+    else
+      AddCommand -> uiCommand: addInvalidFlag("role")
+    end
+  else flag -- "company"
+    AddCommand -> AddCommand: hasCompany = true
+    alt data is present
+      AddCommand->AddCommand: set company
+    else
+      AddCommand->uiCommand: addInvalidFlag("company")
+    end
+  else flag == "from"
+        alt data is present
+            AddCommand -> AddCommand: set startDate
+        else
+            AddCommand -> uiCommand: addInvalidFlag("from")
+        end
+    else flag == "to"
+        alt data is present
+            AddCommand -> AddCommand: set endDate
+        else
+            AddCommand -> uiCommand: addInvalidFlag("to")
+        end
+    else
+        AddCommand -> uiCommand: addInvalidFlag(flag)
+    end
+end
+
+alt invalid flags found
+  AddCommand->uiCommand: printInvalidFlags()
+else all required flags present
+  AddCommand -> Internship: new Internship(role, company, startDate, endDate)
+  activate Internship #blue
+  AddCommand-> InternshipList: addInternship(newInternship)
+  activate InternshipList #aquamarine
+  deactivate Internship
+  deactivate InternshipList
+  AddCommand -> uiCommand: showEditedInternship(newInternship, "add")
+  deactivate uiCommand
+end
+
+@enduml