Authors: Audrey Reinhard (https://github.com/audy910), Rewa El Masri (https://github.com/rewamasri), Amrutha Pannala (https://github.com/AmPannala07), Gage Shaddock (https://github.com/Gage1999)
This project is meant to be a task scheduler that will recommend timing for tasks based on chronotype. A chronotype describes energy levels throughout the day, so it helps identify peak times for specific tasks such as brain-intensive, social, or physically active tasks. The user will initially take a test that will tell their chronotype. After their chronotype is determined, the user will be able to enter tasks and tag them with what type of task, when it needs to be done, a priority level, and an estimated time to complete. The program will then create a week-overview that will contain all the tasks that need to be done and a schedule for the best time to do them. There will also be an ideal wake-up, wind-down, and sleep time. The data will save so a user can go back to their schedule and edit at any time.
Here is a graphical representation of different chronotype energy levels:
This program interests us because as Computer Science/Engineering majors, our schedules are very full and we are always looking for better ways to optimize our schedules. We are taking into account that people's brains work differently and the stereotypical way to schedule our days within this major doesn't work for everyone, so we want to customize it and chronotypes offer a good amount of information on what methods will best work for them.
What languages/tools/technologies do you plan to use? (This list may change over the course of the project)
We are planning on programming the project in C++ and using QT for the user interface.
User will input answers to the quiz that determines chronotype and we will output their chronotype. After this, user will input tasks with details on expected duration, timeline, etc and we will output an optimized task schedule.
- Learn chronotype: A chronotype describes energy levels throughout the day, so it helps identify peak times for specific tasks such as brain-intensive, social, or physically active tasks
- Enter tasks: Tasks will be entered with the following entries: task name, task decription, due date, duration estimated for task, task classification (brain intensive, physical, social), priority level. Tasks can be edited.
- Get a customized schedule that aligns with chronotype based on quiz answers
- Able to retake quiz and update profile since chronotypes have the ability to change over time and schedule will adjust accordingly
When first-time users open the application, they will be directed to the Chronotype quiz. Whenever they hit the next button, the next set of questions and answers will populate on the same screen. When the quiz is finished and the user selects submit, they will be directed to the main window or home screen, which contains the bulk of the app. From here, the user can select to add a new task, which will redirect them to the create a task window. Once the information is entered and the user selects save, the user will be redirected to the home screen. When tasks are added, they will populate under the weekly schedule, which is part of the home screen. When a user clicks on a task, the task window will open and populate with the specific details of that task. On this page, a user and choose to either exit and return home, or edit the task. If the user chooses to edit the task, they will put the task window into edit mode. From here the user can edit the task details, choose to save, and then be redirected home. Under the main window, there will also be a button to move tasks. If this button is clicked, the tasks will become moveable, but the window will stay the same.
- Question Box: Displays quiz questions to determine the user’s chronotype.
- Answer Options: Four choices per question
- Next Button: Proceeds to the next question.
- Determines the user’s chronotype based on their responses.
- Once completed, the system assigns the appropriate chronotype and customizes the main dashboard accordingly.
- Greeting Message: Welcomes the user and displays their assigned chronotype.
- Upcoming Tasks Checklist: Shows a list of immediate tasks.
- Retake Quiz Button: Allows users to retake the quiz tp update their chronotype as that can change over time.
- Move Tasks -> Refresh Button: Schedule and coming up will update when pressed.
- Add Task Button: Opens the task entry form.
- Task Grid: Displays tasks organized by day of the week. Includes times of day (e.g., Wake Up, Wind Down) to structure tasks based on the user's chronotype.
- Task Items: Clickable entries representing tasks, which can be marked as complete.
- Provides a structured overview of tasks, adapted to the user’s chronotype.
- Allows users to plan, edit, and track their productivity.
- Task Name Entry Field: Users input the task title.
- Due Date Entry Field: Users specify the task deadline.
- Priority Slider: Adjusts task urgency.
- Extra Details Field: Users can enter additional task notes.
- Task Type Selection: Brain Intensive, Physical, Social
- Save Button: Saves the task.
- Enables users to create or modify tasks with categorized details like priority, type, and deadlines.
- Task Name Display
- Assigned Date and Time
- Due Date
- Extra Details Section
- Task Type Selection (Brain Intensive, Physical, Social)
- Edit Button: Allows task modifications.
- Allows users to view and modify existing tasks.
- List of Classes: ScheduleWindow, CalendarWidget, ComingUpWidget, TaskWidget, TaskAreaWidget, TaskShowDialog, TaskNewDialog, TaskEditDialog, TestDialog,
- Project is composed of a main window called ScheduleWindow that contains a CalendarWidget, a ComingUpWidget, and a Ui_ScheduleWindow class generated by the ui form
- The ScheduleWindow also holds the users chronotype which is then passed to the CalendarWidget so it can recommend an appropriate schedule
- The ComingUpWidget is responsible for displaying tasks due soon, which are stored in a vector based on their due dates.
- Recieves data from the CalendarWidget, responsible for updating the task lists to reflect any changes, and will allow users to mark the task as completed
- The CalendarWidget is composed of a vector of TaskWidgets and a 2D vector of TaskAreaWidgets
- A TaskWidget is meant to contain a button and a checkbox, the button will allow for the user to open a dialog with the task information displayed, the checkbox will allow the user to mark the task as finished
- A TaskAreaWidget is meant to be a placeholder for a task that is ready to receive a drag and dropped TaskWidget
- drag and drop functions are implemented to wait for and receive a dragged TaskWidget
- When a TaskWidget button is clicked, the calendar widget is responsible for creating a TaskShowDialog that is displayed using the TaskShowDialog class
- The TaskShowDialog class displays detailed information about the tasks that was stored in the TaskWidget, meant to retrieve and present the task details in the Ui_TaskShowDialog class generated by the ui form
- This class is populated by the CalendarWidget when the TaskWidget button is clicked
- TaskNewDialog allows users to create new tasks with new task details based on their, such as their names, due date, priority, and chronotype description, and add them to the calendar
- The TaskEditDialog class allows users to edit a preexisting task in CalendarWidget to update any new user information, the save button in ui_TaskEditDialog will allow users to save any changes
- The TestDialog class is responsible for displaying and managing the chronotype test questions, which links directly to a Test object that fetches the information to be displayed
- The Test object fetches the questions to be asked, and stores and calculates user results from the data in order to determine their chronotype
The Calendar Widget: The Calendar Widget was responsible for displaying the tasks and reccomending an appropriate schedule, so we implemented the Single Responsibility Principle to the Calendar Widget in order to create a seperate class that handles the scheduling. Since the SRP states that a class should focus on a single responsibility, we introduced a new class responsible for generating a reccomended schedule based on task attributes such as due date, priority, and duration. This change improved our code as it is easier to update scheduling logic without affecting other classes, as well as allowing easier unit testing.
Chronotype Interface Class: In the Calendar Widget the chronotype is defined as an int, and in order to increase efficiency we utilized the Open Closed Principle to implement an interface that returns a list of times for certain categories in a compact format. The OPC relates that software entities should be open for extension but closed for modification, so we created a Chronotype Interface class that can be inherited by a specific chronotype so in the future we can implement new chronotypes with their own schedules. This principle allows us to prevent modifying existing code to support a new chronotype, and allows for an easier system when handling chronotype responsibilities.
TestDialogClass: We utilized the Dependancy Inversion Principle in order to make the TestDialog class depend on an abstract Test class, as the current class diagram depends on a very specific type of chronotype test. The Dependancy Inversion Principle argues that high level modules should not depend on low level modules, therefore in order to be able to introduce a new type of test in the future without modifying TestDialog, we utilized abstraction. For example, if we wanted to add a type of test that doesn't prompt the user and instead measures sleep patterns, this test can inherit from the abstract Test class and provide it's own implementation. This change allows us to make a more modular system and code specific test implementations that do not affect TestDialog.
This is the main window.
Opens when New Task button is pressed. Details are saved and will be added to schedule on refresh after saving.
Opens on first launch and when Retake Quiz button is pressed. Chronotype and schedule update when quiz is completed with a new result.
Opens when a task is pressed on the schedule containing the saved details of the task.
Whenever a task is added or completed, press the Refresh button and your schedule as well as upcoming tasks will update. Coming Up sorts tasks based on nearest due date. To mark a task as complete, mark the checkbox within the task box on the calendar.
Ensure you have Qt 6 installed.
bash
brew install qr
Download and instal Qt from Qt's official site [QT's Official Site] (https://www.qt.io/product/development-tools)
git clone <repository-url>
cd cs100_project
mkdir build && cd build
cmake .
make
- Open QT Creator
- Select "cs100_project.pro" or "CMakeLists.txt"
- Click Build & Run
macdeployqt cs100_project.app --verbose=2
sudo codesign --force --deep --sign - cs100_project.app
windeployqt cs100_project.exe
If the windeployqt command does not work, you will need to open where QT is installed, find windeployqt, and add its directory to system path variables. Its directory should be somewhere along the lines of "C:\Qt\6.8.2\mingw_64\bin".
open cs100_project.app
./cs100_project.exe
Alternatively, for Windows, you can download the file at this link and unzip this file. Then open the app under cs100_project.exe. https://drive.google.com/file/d/16QGPbXAEbcwWxTQjZA3Va_wbm0tIMAnp/view?usp=sharing
We leveraged the built-in Qt testing framework to rigorously test the frontend components of our Task Scheduler application, ensuring seamless user interaction. Our testing process involved systematically verifying that all buttons, including RetakeQuiz, NewTask, and Refresh, performed their intended actions by simulating user interactions and confirming that the correct signals were emitted and received by their respective slots. Additionally, we validated that every button in the interface was tested at least once, guaranteeing a reliable, user-friendly experience with a fully functional front end.
On the backend, we employed the Google Test framework to perform comprehensive unit testing on all core functions of the application. We ensured that each function was thoroughly tested, covering a range of possible inputs and edge cases to verify expected behavior. For functions with multiple execution paths, we designed test cases to account for every possible scenario, reinforcing the application's stability and correctness. Through this structured testing approach, we enhanced the overall reliability and maintainability of our Task Scheduler application.