A lightweight Calendar-Based Task & Event Management System built with C++, featuring a custom HTTP server, user authentication, task scheduling, event management, invitation handling, and a browser-based interface.
Developed as an advanced programming project and later refined into a portfolio-ready software engineering project.
Calendar Task Manager is a web-based task and event scheduling system implemented entirely in C++ using an educational HTTP framework.
The application enables users to create personal accounts, manage daily tasks, organize calendar events, invite other users, and generate reports through an interactive browser interface.
Unlike a traditional console application, this project follows a client-server architecture where the backend processes HTTP requests and dynamically serves web pages to users.
The project demonstrates object-oriented design principles, modular software architecture, HTTP request handling, session management, and full-stack interaction between C++ backend components and HTML/CSS/JavaScript frontend pages.
- ✅ Calendar-based task scheduling
- ✅ Event management system
- ✅ User authentication
- ✅ Session management
- ✅ Invitation handling
- ✅ Report generation
- ✅ HTTP server implementation
- ✅ Dynamic request handling
- ✅ Browser-based interface
- ✅ Modular object-oriented architecture
- Overview
- Screenshots
- Features
- Technology Stack
- Architecture
- Project Structure
- Installation
- Running the Project
- Usage
- Folder Structure
- Future Improvements
- Lessons Learned
- Academic Context
- License
- Author
Screenshots below demonstrate the primary workflow of the application.
| Login | Dashboard |
|---|---|
 |
 |
| Sign Up | Add Task |
|---|---|
 |
 |
| Edit Task | Delete Task |
|---|---|
 |
 |
| Add Event | Invitations |
|---|---|
 |
 |
| Reports | Error Page |
|---|---|
 |
 |
- User registration
- User authentication
- Login & logout
- Session-based authentication
- Create new tasks
- Edit existing tasks
- Delete tasks
- Calendar scheduling
- Daily task organization
- Create calendar events
- Invite users
- Manage event information
- Calendar integration
- Daily reports
- Task summaries
- Event summaries
- Browser-based interface
- HTTP request processing
- Dynamic page rendering
- Static page serving
The project combines a native C++ backend with a lightweight web interface to deliver a complete browser-based task management application.
| Category | Technology |
|---|---|
| Programming Language | C++20 |
| Backend | Custom HTTP Server (APHTTP) |
| Frontend | HTML5 |
| Styling | CSS3 |
| Client-side | JavaScript |
| Build System | GNU Make |
| Data Storage | CSV Files |
| Operating System | Linux |
| Development Paradigm | Object-Oriented Programming |
The application follows a modular architecture where each component has a well-defined responsibility.
Browser
│
HTTP Request
│
APHTTP Server
│
Route Matching
│
Request Handler
│
Business Logic Layer
│
Models & Utility Components
│
CSV Data Storage
The backend is intentionally divided into multiple layers to improve maintainability, readability, and scalability.
Responsible for:
- Receiving client requests
- Matching request routes
- Dispatching requests to handlers
- Returning HTTP responses
The routing layer maps HTTP requests to their corresponding request handlers.
Each route consists of:
- HTTP Method
- URL Path
- Request Handler
This separation keeps the server implementation clean and allows new endpoints to be added with minimal changes.
Handlers act as the controller layer of the application.
Their responsibilities include:
- Reading request parameters
- Validating user input
- Managing authentication
- Executing business logic
- Rendering HTML pages
- Redirecting users
The business layer contains the core application logic.
It is responsible for:
- User authentication
- Session validation
- Task management
- Event management
- Invitation processing
- Report generation
Separating business rules from HTTP handling improves maintainability and simplifies future development.
The project is organized around several core domain models.
Represents an application user and stores authentication and profile information.
Represents a scheduled task associated with a calendar date.
Represents calendar events and invitations.
Responsible for date calculations and calendar-related operations.
Loads holiday information from CSV files and integrates it into scheduling logic.
A typical request follows the process below:
Browser
↓
HTTP Request
↓
Server
↓
Route Matching
↓
Request Handler
↓
Business Logic
↓
Generate Response
↓
Browser
This workflow separates networking, routing, application logic, and presentation into independent modules.
calendar-task-manager
│
├── csv/
│ └── holidays.csv
│
| docs/
| ├── screenshots/
| │ ├── home.png
| │ ├── login.png
| │ ├── signup.png
| │ ├── dashboard.png
| │ ├── add-task.png
| │ ├── edit-task.png
| │ ├── delete-task.png
| │ ├── add-event.png
| │ ├── invitations.png
| │ ├── report.png
| │ └── error-page.png
│
├── server/
│ ├── route.cpp
│ ├── server.cpp
│ └── ...
│
├── src/
│ ├── User.cpp
│ ├── Task.cpp
│ ├── Event.cpp
│ ├── HolidayManager.cpp
│ ├── handlers.cpp
│ ├── main.cpp
│ └── ...
│
├── static/
│ ├── login.html
│ ├── dashboard.html
│ ├── report.html
│ └── ...
│
├── template/
│
├── test/
│
├── utils/
│
├── Makefile
├── README.md
└── LICENSE
| Folder | Description |
|---|---|
src/ |
Core application logic and domain models |
server/ |
HTTP server and routing system |
utils/ |
Utility classes used across the project |
static/ |
HTML pages served by the backend |
template/ |
HTML templates |
csv/ |
Holiday data source |
docs/ |
Documentation and screenshots |
test/ |
Sample input/output test cases |
Several architectural decisions were made during development to improve software quality.
The application follows object-oriented programming principles by encapsulating related data and behavior into dedicated classes.
Instead of implementing the entire project inside a few large source files, functionality has been divided into independent modules with clear responsibilities.
Networking, routing, business logic, utilities, and presentation are separated into different directories to reduce coupling and simplify maintenance.
Rather than relying on an external database, holiday information is stored in CSV files to keep deployment simple and minimize dependencies.
Although implemented in C++, the project provides a graphical user experience through standard web technologies (HTML, CSS, and JavaScript), making it more accessible than a console application.
Before running the project, ensure the following tools are installed:
- GCC/G++ with C++20 support
- GNU Make
- Linux operating system (recommended)
The project was primarily developed and tested on Linux.
Clone the repository:
git clone https://github.com/AliDehghani06/calendar-task-manager.git
cd calendar-task-managerCompile the project using Make:
makeAfter a successful build, the executable will be generated.
Run the application using the holiday dataset:
./UTrello csv/holidays.csvAfter launching the server, open your browser and navigate to:
http://localhost:<PORT>
Replace
<PORT>with the configured server port if different.
The repository contains sample test cases under the test/ directory.
test/
├── 1/
├── 2/
├── ...
└── 15/
Each test directory contains:
- Input data (
*.in) - Expected output (
*.out)
These files were used during development to validate different application behaviors.
A typical user workflow is shown below.
New users can register through the Sign Up page.
↓
Authenticate using your username and password.
↓
The dashboard provides quick access to:
- Tasks
- Events
- Invitations
- Reports
↓
Users can:
- Add tasks
- Edit tasks
- Delete tasks
- Schedule tasks
↓
Users may:
- Create events
- Invite participants
- Review invitations
↓
Reports summarize scheduled tasks and events for selected dates.
The application provides multiple browser-accessible pages.
| Page | Description |
|---|---|
| Login | User authentication |
| Sign Up | New account registration |
| Dashboard | Main application page |
| Add Task | Create new tasks |
| Edit Task | Modify existing tasks |
| Delete Task | Remove scheduled tasks |
| Add Event | Schedule calendar events |
| Invitations | View pending invitations |
| Report | Generate reports |
| 404 | Error page |
✔ User authentication
✔ Session management
✔ Calendar scheduling
✔ Task creation
✔ Task editing
✔ Task deletion
✔ Event creation
✔ User invitations
✔ Daily reports
✔ Holiday awareness
✔ Browser-based interaction
✔ Modular backend architecture
| Metric | Value |
|---|---|
| Programming Language | C++20 |
| Architecture | Object-Oriented |
| HTTP Server | APHTTP |
| Frontend Pages | 10+ |
| Source Files | 40+ |
| Test Cases | 15 |
| Build System | Make |
| Data Source | CSV |
The project was designed around independent classes with specific responsibilities.
Examples include:
- User
- UserManager
- Task
- Event
- HolidayManager
- Date
- Day
- Request Handlers
- Server
- Route
This design minimizes coupling while improving maintainability and code readability.
The application supports authenticated user sessions.
After a successful login:
- User identity is stored in the active session.
- Protected pages become accessible.
- Unauthorized requests are redirected appropriately.
This demonstrates practical implementation of stateful web interactions using C++.
National holidays are loaded from a CSV file.
This approach separates application logic from configuration data, allowing holiday information to be updated without recompiling the project.
Although developed as an educational project, the architecture was intentionally organized to simplify future extensions.
Potential enhancements include:
- Database integration
- RESTful APIs
- JSON serialization
- Docker support
- User roles
- Notifications
- Responsive UI
- Unit testing
- CI/CD pipelines
The modular organization makes these extensions significantly easier to implement.
The application exposes multiple HTTP endpoints for browser interaction.
| Method | Route | Description |
|---|---|---|
| GET | / |
Home page |
| GET | /login |
Login page |
| GET | /signup |
Registration page |
| GET | /dashboard |
User dashboard |
| GET | /add-task |
Create a task |
| GET | /edit-task |
Edit an existing task |
| GET | /delete-task |
Delete a task |
| GET | /add-event |
Create a calendar event |
| GET | /show-invitations |
Display invitations |
| GET | /report |
Daily reports |
| Method | Route | Description |
|---|---|---|
| POST | /login |
Authenticate a user |
| POST | /signup |
Register a new account |
| POST | /logout |
End current session |
| POST | /add-task |
Create a task |
| POST | /edit-task |
Update an existing task |
| POST | /delete-task |
Remove a task |
| POST | /add-event |
Create a calendar event |
| POST | /action/invitations |
Respond to invitations |
| GET | /api/invitations |
Retrieve invitations |
| GET | /api/report |
Generate reports |
git clone https://github.com/AliDehghani06/calendar-task-manager.git
cd calendar-task-manager
make
./UTrello 5000 csv/holidays.csvOpen your browser:
http://localhost:5000
The source code is intentionally divided into several independent modules.
| Module | Responsibility |
|---|---|
server |
HTTP server implementation |
route |
URL routing |
handlers |
Request processing |
User |
User model |
UserManager |
User management |
Task |
Task model |
Event |
Event model |
HolidayManager |
Holiday management |
Date |
Date utilities |
Day |
Calendar representation |
Utilities |
Shared helper functions |
This organization keeps the codebase maintainable and reduces coupling between components.
Possible future enhancements include:
- Database integration (SQLite/PostgreSQL)
- RESTful API support
- JSON serialization
- Docker deployment
- Responsive frontend
- Password hashing
- Email notifications
- Calendar export (ICS)
- Unit testing with GoogleTest
- Continuous Integration (GitHub Actions)
- API documentation
- User roles and permissions
Developing this project provided valuable practical experience in several software engineering concepts, including:
- Object-Oriented Design
- Modular Software Architecture
- HTTP Communication
- Client-Server Programming
- Session Management
- Separation of Concerns
- Build Automation using Make
- Backend and Frontend Integration
- Designing Maintainable C++ Applications
Beyond implementing features, the project emphasized writing organized, extensible, and maintainable code.
This project was originally developed as part of an Advanced Programming course and has since been refined into a portfolio-ready repository.
The public version focuses on software engineering practices, documentation quality, repository organization, and maintainable code structure while preserving the original educational objectives.
This project utilizes the educational APHTTP framework for HTTP communication.
Special thanks to the Advanced Programming course team for providing the infrastructure used throughout the development process.
The framework itself is not part of this project's original implementation and remains the intellectual property of its respective authors.
This project is distributed under the MIT License.
See the LICENSE file for more information.
Ali Dehghani
Computer Engineering Student
GitHub
https://github.com/AliDehghani06
If you found this repository useful or interesting, consider giving it a ⭐ on GitHub.
Feedback, suggestions, and contributions are always welcome.
Made with ❤️ using C++20