PROJECT: Invités

Overview

PREFACE

This section features the role and contributions I had over the course of this project

Invités is a desktop application used by people who manage and plan events to streamline their processes and better manage the events that they are handling.
The user interacts with it mainly using a Command Line Interface (CLI), and it has a Graphical User Interface (GUI) created with the JavaFX library.

Responsibility - In this project, I was assigned the task of creating an easy to use system to manage the attendance within the application.

To implement a feature like that in this application, I would need a method to uniquely identify each guest in the guest list. This is necessary as having identifiers that can give more than one result will increase the burden of the event planner as they will have to choose which entry would be modified, when this application is supposed to be helping them. Identifying the right person quickly in an event is essential for running the event smoothly. Also considering the fact that names, phone numbers, emails cannot be considered unique in a setting such as a public event, creating a unique ID (UID) was needed. After creating the UID, the process of marking attendance is made easier as each UID represents one person in the guest list.

Project scope - Invités is an event management system that provides an intuitive platform for event planners to better organise and manage the reception during small or large events such as school orientation camps, committee events or more formal occasions such as weddings. The main features that streamline the processes of the event planner is the ability to send mass emails to attendees, keep track of payments, as well as attendance tracking during the event itself. If the event planner used other applications to store his data, they can easily import their data over from CSV files that can be generated from Microsoft Excel.

Team

The list below shows all our team members and what we have contributed to the application Invités:

Names

Major Feature

Aaryam Srivastava

Mass Email Communication

Sandhya Gopakumar

Events Management

Sarah Taaher Bonna

Guest List Management

Tan Tze Guang

Attendance Management

Tan Wei Ming

Data Sharing

Summary of contributions

PREFACE

This section is a summary of my contributions to the project. It showcases my ability to work on a software project with a team of people

  • Major Feature: added the function to mark attendance of the attendees in the Guest list

    • What it does: This function allows the person planning an event to keep track of the number of attendees whom have arrived at the event by marking them as present or absent during the event itself.

    • Justification: This feature is necessary in the implementation of our guest list as it is a core feature that gives the event planner peace of mind as it is a tool for them to ensure that the event is run smoothly.

    • Highlights: This feature is a core feature that required creating the Unique ID for each guest, else it would have to be more complex to handle identification mediums that could potentially identify more than one person at a time.

  • Sub feature: added the function to generate Unique ID (UID) for attendees

    • What it does: This function allows the event planner to not have to think of a large number of UID for guests of the event.

    • Justification: This feature is necessary in the implementation of our guest list as it streamlines the identification of each guest especially for the receptionists for the event. It provides a unique identification to each guest which allows our program to pick out the right person without needing to handle people whom have the same name or same phone numbers.

    • Highlights: This enhancement affects existing commands and commands to be added in future. The implementation too was challenging as it required changes to existing commands.

  • Code contributed: [Functional code]

  • Other contributions:

    • Documentation:

      • Did cosmetic tweaks to existing contents of the User Guide: #190 #139 #313

      • Added more documentation in to the existing contents of the Developer Guide: #190 #139 #313

    • Enhancements to existing features:

      • Added generation of UID into the add_guest command

    • Community:

      • Reported bugs and suggestions for another team in the cohort (examples: #187 #205)

      • Reviewed Pull requests from team members to give timely feedback (examples: #135 #138 #152 #157 #203 #232 #284)

    • Tools:

      • Integrated a Github plugin (CircleCI) to my personal forked repository

Contributions to the User Guide

PREFACE

Given below are sections I contributed to the User Guide. They showcase my ability to write documentation which targets end-users.
The implementation of the mark and unmark commands are found in the Logic component of the application.

Marking a guest as present : mark

Marks a guest as present using a unique ID (UID) that was assigned to them upon adding them into the guest list. This will also update the attendance​ field associated with the guest to PRESENT.
Format: mark [UID]

UID does not use the u/ prefix.
UID only accepts a string of numbers alphanumeric characters between 5 to 20 characters inclusive, other characters will trigger an invalid command format error.

Examples:

  • mark 543654 You will set the guest with UID 543654 as PRESENT.

  • mark A345654M You will set the guest with UID A345654M as PRESENT.

  • mark ALPHA You will set the guest with UID ALPHA as PRESENT.

markCommandSuccess

Figure 3 - User interface after Mark Command : Successful execution of MarkCommand

Marking a guest as absent : unmark

Marks a guest as absent using a unique ID (UID) that was assigned to them upon adding them into the guest list. This will also update the attendance​ field associated with the guest to ABSENT.
Format: mark [UID]

UID does not use the u/ prefix.
UID only accepts a string of numbers alphanumeric characters between 5 to 20 characters inclusive, other characters will trigger an invalid command format error.

Examples:

  • unmark 543654 You will set the guest with UID 543654 as ABSENT.

  • mark A345654M You will set the guest with UID A345654M as ABSENT.

  • mark ALPHA You will set the guest with UID ALPHA as ABSENT.

unmarkCommandSuccess

Figure 4 - User interface after Unmark Command : Successful execution of UnmarkCommand

Starting mass attendance marking : start_marking - Coming in v2.0

This feature has not been implemented yet. Our team plans to implement this feature in an upcoming version, v2.0.

Start the mass attendance marking mode. Allows you to mark attendance without using the mark prefix. This command will allow you to continuously mark the attendance of the attendees by keying in their Unique ID (UID) into the command line interface Format: start_marking + [UID]…​

You are unable to use other commands once this mode is active.
You will need to use the stop_marking command to deactivate this mode to use other commands

Examples:

  • start_marking + 00001 + 708944 + 928372 + 00003…​
    You will mark the guests with UID of 00001, 708944, 928372, 00003 as PRESENT.

Stopping mass attendance marking : stop_marking - Coming in v2.0

This feature has not been implemented yet. Our team plans to implement this feature in an upcoming version, v2.0.

Stops the mass attendance marking mode. Deactivates the start_marking mode to enable usage of other commands in the program
Format: stop_marking

Examples:

  • start_marking + 00001 + stop_marking
    Initiate start_marking mark the person with UID 00001 then exit the mode with stop_marking.

Contributions to the Developer Guide

PREFACE

Given below are sections that I have contributed to the Developer Guide. They showcase my ability to write technical documentation and the technical depth of my contributions to the project.
The implementation of the mark and unmark commands are found in the Logic component of the application.

Mark/Unmark Command

The mark/unmark mechanism is facilitated by Model. Given below is an example usage scenario and how the mark/unmark command executes at each step:

Step 1. The user launches the application for the first time. The VersionedAddressBook will be initialized with the initial address book state and the currentStatePointer pointing to that single address book state.

Step 2. The user executes the command import guestlist.csv to import a list of guest and add them to the current state of the AddressBook.

Alternatively, the user can execute the command add_guest n/John Doe p/98765432 e/johnd@gmail.com pa/PAID a/ABSENT u/00001 t/NORMAL to create an instance of one guest and add them to the current state of AddressBook.

Step 3. The user will execute the command mark 00001 to set the attendance of the Person to PRESENT.

Step 4. An instance of getPersonList is retrieved from the model using MODEL#getAddressBook#getPersonList. A linear search is then executed on the getPersonList to find a Person with the same Unique ID (UID) as 00001.

If there is no matching UID found, a COMMANDEXCEPTION will be thrown to indicate nobody in the list has the phone number. If there is more than one instance of the same UID, a COMMANDEXCEPTION will be thrown to indicate that there are more than one instance of the same UID. In this case, edit_guest will not work. The user has to delete the entry and add_guest for the deleted entry.

Step 5. After retrieving the information from the discovered Person, another Person is created with the same fields with the exception of the attendance field being changed from ABSENT to PRESENT.

Step 6. Finally, the entry is updated using MODEL#updatePerson to transfer the new information into the Model before commitAddressBook is executed to save the state of the AddressBook.

The following sequence diagram shows how the mark operation works:

MarkCommandSequenceDiagram
Figure 1. Mark Command Sequence Diagram

The following sequence diagram shows how the ummark operation works:

UnmarkCommandSequenceDiagram
Figure 2. Unmark Command Sequence Diagram

Design Considerations

Aspect: How mark/unmark executes

  • Alternative 1 (current choice): access the PersonList model to execute marking of attendance.

    • Pros: Able to mark the attendance of anybody within the list even when it is filtered. Prevents the bug of a person filtering the list to only show a single instance of the multiple similar UID to mark their attendance.

    • Cons: Some changes might be hard to detect when displaying a filtered list.

  • Alternative 2: access the filteredPersonList model to execute the marking of attendance.

    • Pros: Able to work with a smaller set of people in the list. Changes made are immediately observable.

    • Cons: Introduces bugs such as avoiding the similar UID check within the current instance of the guest list. If the filtered list does not immediately have the UID that needs to be used, the user has to call list command first. Increasing the chance of human error in the system.

The implementation of the generate Unique ID (UID) function is found in the Logic component of the application within the add_guest command.

Extension made to add_guest: Generate Unique ID (UID) on creation of an entry into the list

This feature is facilitated by the usage of the Model.
Given below is an example of the execution of the added functionality of the add_guest command.

Step 1. The user launches the application for the first time. The VersionedAddressBook will be initialized with the initial address book state and the currentStatePointer pointing to that single address book state.

Step 2. The user executes the add_guest command with the following non-null fields: add_guest n/John Doe p/98765432 e/johnd@gmail.com pa/PAID a/ABSENT u/00000 t/NORMAL.

Step 3. The addCommandParser extracts the relevant information from the command and returns a Person model that was built with the given arguments.

Step 4. The add_guest.execute function receives the generated Person model and checks for duplicates of the same Person as well as duplicates of the same UID in the VersionedAddressBook.

If the checks fail, COMMANDEXCEPTION will be thrown to indicate the existence of more than one of the same UID or Person

Step 5. The function will test the equality between the UID given in the generated Person and the DEFAULT_TO_GENERATE_UID which is u/00000. From here the program will do one of 2 different things.

Step 6a. If the UID given is not the same as DEFAULT_TO_GENERATE_UID:
The program will treat this as a user defined UID and add the Person into the Model without generating a new UID.

Step 6b. Alternatively, If the UID input in step 2 is the same as DEFAULT_TO_GENERATE_UID:
The program will create a new Person model with the same arguments with the exception of UID. The UID is then generated randomly in the generateUid() function. Another check is done to ensure that the UID does not already exist in the VersionedAddressBook. This is done in a loop to ensure the UID is unique before adding the Person into the Model by executing addPerson().

Step 7. After adding the Person into the Model, the program commits the changes by executing commitAddressBook to save the state of the AddressBook..

The following sequence diagram shows how the add_guest command works:

AddCommandSequenceDiagram
Figure 3. Add Command Sequence Diagram

Design Considerations

Aspect: Whether to only generate UID or to allow the user to define UID

  • Alternative 1 (current choice): give the user the freedom to choose between defining their own UID or letting the program generate one itself.

    • Pros: Able to write tests for the command that will not fail. A company or event may already be using some sort of unique identification, this can be used by the event planner to uniquely identify attendees. If there is none, the user can just let the program generate one for them.

    • Cons: Increased code complexity

  • Alternative 2: only let the user define the UID for all attendees of the event.

    • Pros: Decreased code complexity

    • Cons: User will face great difficulty in creating UID for a large group of people if there is no unique identifier available for the attendees already.

  • Alternative 3: only generate the UID for all the attendees in the list, user input for the UID is not allowed.

    • Pros: Decreased code complexity

    • Cons: Unable to write meaningful tests if the the actual output is going to be random. Users may already have a way to uniquely identify the attendees to the event but the event planner cannot make use of that method.

Generation of UID details in add_guest command

  1. Setting the UID for each guest in the guest list.

    1. Test case: add_guest n/John p/98765432 e/f@gmail.com pa/PAID a/ABSENT u/00000 t/NORMAL t/NoShrimp t/NORMAL
      Expected: As the field for the UID is set to 00000, the program will generate a random 6 digit UID for the user.

    2. Test case: add_guest n/Doe p/98725432 e/g@gmail.com pa/PAID a/ABSENT u/00001 t/NORMAL t/NoShrimp t/NORMAL
      Expected: As the field for the UID is set to 00001, the program will treat this is a User defined UID and add the person with the UID set to 00001.

    3. Test case: add_guest n/Jon p/98765422 e/d@gmail.com pa/PAID a/PRESENT u/0000 t/NORMAL t/NoShrimp t/NORMAL
      Expected: As the field for the UID is set to 0000 which is an invalid input as the UID has to be at least 5 characters, the program will display an error message.

    4. Test case: add_guest n/Do p/98765232 e/g@gmail.com pa/PAID a/PRESENT u/000000000000000000001 t/NORMAL t/NoShrimp t/NORMAL
      ExpectedL As the field for the UID is set to 000000000000000000001 which has 21 characters which is an invalid input as the UID cannot be more than 20 characters, the program will display an error message.

Marking Attendance details

  1. Marking attendance using the Unique ID (UID) to set the attendance to PRESENT with the mark command.

    1. Prerequisites: The guest list must be populated with guests. At least one guest has the UID 00001.

    2. Test case: mark 00001
      Expected: The person whose UID is 00001 will have the attendance field marked as PRESENT.

    3. Test case: mark [UID not in the guest list]
      Expected: An error will show that there is no such person in the guest list.

    4. Test case: mark 0001
      Expected: The UID is in the wrong format and will show an error message.

    5. Test case: mark 0101010101010101010101010101
      Expected: the UID is in the wrong format and will show an error message.

  2. Marking attendance using the Unique ID (UID) to set the attendance to ABSENT with the unmark command.

    1. Prerequisites: The guest list must be populated with guests. At least one guest has the UID 00001.

    2. Test case: unmark 00001
      Expected: The person whose UID is 00001 will have the attendance field marked as ABSENT.

    3. Other test cases: similar to mark command as shown above