Previously there were a few lines that were partially
covered by tests. This commit fixes that by adding tests
for those lines.

Fix bug regarding name-based deletion

Updated the Developer Guide to include comprehensive documentation for the
Filter and ShowAll commands. This enhancement outlines the implementation
details, rationale, and design considerations for these features.

- The Filter Command section explains its parsing and execution process,
  highlighting the use of predicates for dynamic employee filtering based on
  specified criteria like name, role, team, and tags.
- The ShowAll Command section describes its functionality to reset and display
  the complete list of employees, detailing its integration with the model to
  clear any active filters.

This documentation provides clarity on the features' workings, assisting
developers in understanding and maintaining the codebase. The choice of
implementation for each command is justified with a focus on flexibility,
user experience, and adherence to the application's architectural standards.

The detailed documentation ensures that future enhancements or modifications
to these features can be made efficiently and with a thorough understanding
of their initial design and purpose.

Updated the Developer Guide to include comprehensive documentation for the
Filter and ShowAll commands. This enhancement outlines the implementation
details, rationale, and design considerations for these features.

- The Filter Command section explains its parsing and execution process,
  highlighting the use of predicates for dynamic employee filtering based on
  specified criteria like name, role, team, and tags.
- The ShowAll Command section describes its functionality to reset and display
  the complete list of employees, detailing its integration with the model to
  clear any active filters.

This documentation provides clarity on the features' workings, assisting
developers in understanding and maintaining the codebase. The choice of
implementation for each command is justified with a focus on flexibility,
user experience, and adherence to the application's architectural standards.

The detailed documentation ensures that future enhancements or modifications
to these features can be made efficiently and with a thorough understanding
of their initial design and purpose.

Update developer guide

…to 'Employee' in UML diagrams

The Developer Guide has been updated to include details about the
implementation of the delete command. This includes the handling of
deletion by name in case of duplicate names and deletion by unique id.
This information provides clarity on how these features are implemented
and can assist other developers in understanding the codebase.

Update Developer Guide with delete command details

Update Developer Guide with UID info

update DG to include AddCommand implementation

This commit introduces a new Description class in the task package.
The Description class represents a Task's description in the address
book. It includes validation checks to ensure that the description
is not blank.

The class includes methods for constructing a Description object,
validating a description string, and overriding the toString, equals,
and hashCode methods.

This new class provides a structured way to handle task descriptions,
improving code readability and maintainability.

This commit introduces a new Task class in the task package. The Task
class represents a task with a Description and a boolean status
indicating if the task is done.

The class includes methods for constructing a Task object, marking
and unmarking a task as done, and overriding the toString, equals,
and hashCode methods.

This new class provides a structured way to handle tasks, improving
code readability and maintainability.

This commit introduces a new TodoList class in the todoList package.
The TodoList class represents a list of tasks for each employee.

The class includes methods for adding, removing, marking, and
unmarking tasks, and overriding the toString method.

This new class provides a structured way to manage tasks, improving
code readability and maintainability.

This commit adds unit tests for the Description, Task, and TodoList
classes in the task and todoList packages.

The tests cover the main functionalities of these classes, including
validating descriptions, checking task equality, and managing tasks
in a todo list.

These tests help ensure the correctness of the code and facilitate
future refactoring and enhancement.

The application currently lacks a way to add tasks to an employee's
todo list. This is a crucial feature for task management in a team.

To address this, the AddTaskCommand class was added. This class extends
the Command class and implements the functionality to add a task to an
employee's todo list. The command takes a unique employee id and a task
description as input, and adds a new task with the given description to
the todo list of the corresponding employee.

This addition improves the application's task management capabilities
and allows users to assign tasks to employees.

The Description class previously allowed any string to be used as a
task description. This could lead to undesired behavior, such as
descriptions with special characters or blank descriptions.

To improve data integrity, the Description class has been modified to
only allow alphanumeric characters and spaces in descriptions. In
addition, descriptions cannot be blank, null, or consist only of
whitespace.

This change ensures that all task descriptions adhere to the defined
format and improves the robustness of the application.

The application currently lacks a way to parse user input for the
addTask command. This is a crucial feature for task management in a team.

To address this, the AddTaskCommandParser class was added. This class
implements the Parser interface and provides a parse method that creates
an instance of the AddTaskCommand class from a given user input string.

In addition, the AddressBookParser class was updated to handle the
addTask command. The parseCommand method of this class was modified to
recognize the addTask command word and call the AddTaskCommandParser.

These changes improve the application's task management capabilities
and allow users to assign tasks to employees using the addTask command.

Improve UI aesthetics

The Task class now includes two new methods: isValidTaskString and
parseTaskString. The isValidTaskString method checks if a given string
is a valid representation of a task, while the parseTaskString method
converts a valid task string into a Task object.

These methods are necessary for the storage of tasks. When tasks are
stored as strings in a JSON file, these methods will be used to validate
the task strings and convert them back into Task objects when the data
is loaded. This ensures that the tasks are stored and loaded correctly,
and any invalid task strings are detected and handled appropriately.

The JsonAdaptedEmployee class has been updated to handle tasks. It now
includes a list of JsonAdaptedTask objects, which represent the tasks
of each employee in a format suitable for JSON storage. The constructor
and toModelType method have been updated to convert between Task and
JsonAdaptedTask objects.

A new JsonAdaptedTask class has been created to handle the conversion
between Task and JsonAdaptedTask objects. This class includes a
constructor that takes a Task object, a getTaskString method that
returns the task string, and a toModelType method that converts the
JsonAdaptedTask back into a Task.

These changes are necessary for the storage of tasks. When tasks are
stored as strings in a JSON file, these classes will be used to validate
the task strings and convert them back into Task objects when the data
is loaded. This ensures that the tasks are stored and loaded correctly,
and any invalid task strings are detected and handled appropriately.

Merge 44-todo-list

The application lacked the ability to mark tasks
as completed or revert them to incomplete, which
limited the user interaction and task management
capabilities.

To enhance the functionality and usability of the
task management feature, the following changes
have been implemented:

* Added `MarkTaskCommand` and `UnmarkTaskCommand`
classes to handle the marking and unmarking of
tasks.
* Created `MarkTaskCommandParser` and
`UnmarkTaskCommandParser` classes to parse the
user input into respective commands.

This approach allows users to easily manage
the completion status of tasks, improving the
overall user experience and making the task
management feature more robust.

The chosen design pattern aligns with the
existing command and parser structure,
ensuring consistency and maintainability
of the codebase.

73 add mark unmark command

Main updates are that each tasklist now has a size function, allows us to query the number of
completed tasks and uncompleted task as well.
Using these metrics, we also have completition rate - the total tasks completed / total tasks.

Main change here is that completition rate is displayed on the employee's card.

But still needs update on the data model and null exception handling.

Modified Employee.java to include new methods for task completion rate and attribute

Updated TaskList.java to reflect changes in completion rate

Updated EmployeeCard.java and EmployeeListCard.fxml to display task completion related information in the UI

This commit fixes a bug in the calculation of the completion rate in the TaskList class. Previously, the division of getCompletedTasks by size was being treated as an integer, which could lead to incorrect results due to integer division.

The division has been cast to double to ensure that it is treated as a floating-point division. This provides a more accurate completion rate.

Additionally, the completion rate is now rounded to the nearest two decimal places to provide a more readable output. It is also converted to a percentage for better understanding.

The changes were made in the getCompletionRate method of the TaskList class and employee class's getCompletionRate method.

Previously, the test cases were taking completion rate as a parameter in the JsonAdaptedEmployee constructor.
This is no longer needed as the entire calculation for completion rate is now done in the frontend.

Update the Employee toString method to include tasks and added a TaskList getter method.

This commit adds unit tests for the size(), getCompletedTasks(), getPendingTasks(), and getCompletionRate() methods in the TaskList class.
These tests ensure that the methods correctly calculate the number of tasks, completed tasks, pending tasks, and the completion rate respectively.

The EmployeeBuilder class now supports adding tasks to an Employee during its creation.
This is done using the withTask method, which takes a task description as a parameter
and adds a new Task to the Employee's task list.

This commit does the following:

- Adds null checks to the Employee constructor for all parameters.
- Adds test cases to EmployeeTest to verify that the constructor throws a NullPointerException when any of its parameters are null.
- The only exception is UID which is handled differently.

The user guide previously did not detail the extensive
filtering capabilities of the application, specifically
omitting the ability to filter employees by name, tags,
role, and team in the filter feature section. This
omission limited the guide's usefulness and completeness.

To rectify this and provide a thorough understanding of
the filter command, the following enhancements have
been made:

* Updated the `filter` section to encompass filtering by
  name, tags, role, and team, reflecting the full
  functionality of the command.
* Revised examples to showcase the versatility of
  filtering by different criteria, both individually and
  in combination.

These updates ensure the user guide accurately mirrors the
application's features, empowering users to leverage the
filter command to its full potential.

By documenting all filtering options, the guide now
serves as a complete reference, enhancing user
comprehension and effectiveness in employing the
application’s filtering capabilities.

This commit introduces new test cases for the EmployeeCard UI component. The tests are designed to verify the correct behavior of the updateTaskList method.
In particular, the tests ensure that:
- The updateTaskList method correctly updates the task list of an EmployeeCard instance.
- The task list of an EmployeeCard instance reflects the tasks associated with the corresponding Employee instance.

The tests are implemented in the EmployeeCardTest class, which extends ApplicationTest to provide a JavaFX testing environment.

Add comprehensive filtering options to user guide

Previously, `ShowAllCommand` and `ListCommand`
duplicated functionality, leading to confusion.
To improve user experience, `ShowAllCommand` was
removed, ensuring `ListCommand` suffices for
listing all entities.

Changes made:
- Removed `ShowAllCommand` to prevent function
  overlap with `ListCommand`.
- Tested `ListCommand` to confirm it meets all
  listing needs.

This simplification enhances usability, making the
application more intuitive and efficient. Now,
`ListCommand` alone offers a complete listing
solution, streamlining the command suite.

Remove redundant ShowAllCommand

Add documentation for addTask, mark and unmark in user guide

This commit removes the test cases for the EmployeeCard class. These tests have been causing continuous integration failures on GitHub Actions, specifically on the Ubuntu runner.

The issue appears to be that these tests enter an infinite loop when run on Ubuntu, causing the CI process to hang indefinitely. This behavior is not observed when the tests are run locally or on other operating systems.

Given the persistent nature of this issue and the impact it has on the overall CI process, the decision has been made to remove these test cases. Future work will need to investigate the root cause of this issue and reimplement the tests in a way that is compatible with all testing environments.

This commit introduces a new test case to the EmployeeTest class. The test, constructor_nullTasks_throwsNullPointerException, verifies that the constructor of the Employee class throws a NullPointerException when it is provided with a null 	asks argument.

This test is important to ensure the robustness of the Employee class. It confirms that the class behaves as expected when it encounters invalid input, in this case, a null 	asks argument. This helps to prevent potential issues that could arise from null pointer exceptions in other parts of the codebase.

This commit adds comprehensive test cases for both constructors in the Employee class. The first constructor takes a list of tasks as an additional parameter, while the second does not.

The tests ensure that all fields must be present and not null, as per the requirements of the constructors. This helps to maintain the integrity of the Employee objects created and ensures that they are always in a valid state.

This commit adds a new test method in EmployeeTest.java that tests the Employee constructor.

The test verifies that all fields are correctly initialized when an Employee object is created using the constructor.

update ug and ui

This commit removes unnecessary testing code that was causing confusion and clutter in the codebase. The tests removed were either duplicates, outdated, or not providing significant coverage. This cleanup should make the test suite easier to maintain and understand.

Branch statistics

…s tasklist

This commit overhauls sections of the User Guide to incorporate the newly introduced Completion Rate Statistics feature, along with detailed instructions on task management enhancements such as �ddTask, mark, unmark, and deleteTask. Changes include:

- Detailed explanation of the Completion Rate Statistics feature, highlighting its integration into ContactSwift for monitoring employee productivity through task completion rates.
- Added sections for �ddTask, mark, unmark, and deleteTask commands, complete with examples and tips for effective use.
- Revised the guide's tone to be more friendly yet slightly more formal, balancing professionalism with approachability.
- Enhanced user experience with more illustrations!

These updates aim to provide users with comprehensive insights into utilizing the latest features for optimal contact management and productivity tracking in ContactSwift.

update ui.png and index.md

Update User Guide with v1.3 features