A full-stack client-server course timetable inquiry system developed for the Data Communications and Networking (DCN) Assignment 2.
This Project was evaluated by the teacher as the project with the highest degree of completion in 2026's classes.
 |
 |
 |
 |
 |
 |
 |
 |
- Step 0: Download the bin files from Github Release
- Step 0.5: Click the exe file and unzip it to the project (More clearly, dir "Apps" should in the project root dir)
- Step 0.9: Config DB:server.cfg (* Must be done before start *)
- Step 1: Open the dir Apps
- Step 2: Right-click on "OneKeyStart.exe" / "一键启动.exe"
- Step 3: Select "Run as Administrator"
- Step 4: Enjoy!
- Note: If you want do dev based on this project, pls make sure that ALL "ai_config.yaml"s and "ai_config.dart"s are configured.
- Note: The routing safety and conflict handling under high concurrency is not that strong. You can implement fine-grained optimistic concurrency control or row-level locking to improve that. Welcome to contribute about that.
- Architecture Overview
- Tech Stack
- Project Structure
- Features
- Communication Protocol
- Prerequisites
- Build & Run
- Usage Guide
- Data Import
- Security
- Bonus Features
- How to Meet Requirements
┌──────────────────────┐ ┌──────────────────────┐ ┌──────────────────────┐
│ Windows Client │ │ Android Client │ │ Web Dashboard │
│ C# / WinUI 3 │ │ Flutter / Dart │ │ Next.js / React │
│ Desktop GUI │ │ Mobile App │ │ Browser UI │
└──────────┬───────────┘ └──────────┬───────────┘ └──────────┬───────────┘
│ TCP (AES-256-GCM Encrypted)│ TCP (AES-256-GCM Encrypted) / HTTP (Web)
└──────────┬─────────────────┘ │
▼ │
┌──────────────────────┐ ┌──────────────────────┐ │
│ C++ Server (IOCP) │ │ Python TCP Server │ │
│ Qt6 GUI Dashboard │ │ asyncio + Redis │◄───┘
└──────────┬───────────┘ └──────────┬───────────┘
│ libpq │ psycopg2
▼ ▼
┌──────────────────────────────────────────────┐
│ PostgreSQL + Redis (Docker Stack) │
│ courses + users + logs + connections │
└──────────────────────────────────────────────┘
The system follows a client-server model with multiple entry points:
- C++ Server: Multi-threaded IOCP-based server for Windows/Android clients, with AES-256-GCM encrypted TCP communication and real-time monitoring dashboard.
- Python TCP Server (Docker): Asyncio-based TCP server sharing the same protocol, with Redis-powered connection tracking and statistics.
- Web Dashboard (Docker): Next.js 14 web application providing course queries, timetable visualization, admin CRUD, and system monitoring — all through a browser.
- Clients: Windows desktop (WinUI 3), Android mobile (Flutter), and web browser — all connect independently to the server.
- Database: PostgreSQL storing course timetable data, user credentials, server logs, and connection statistics — accessed by all server instances.
| Component | Technology |
|---|---|
| Server | C++17, Winsock2 IOCP, Qt6 Widgets, PostgreSQL (libpq), Argon2id |
| Windows Client | C#, .NET 10, WinUI 3 (Windows App SDK) |
| Android Client | Flutter, Dart, Riverpod, Material Design 3, PointyCastle |
| Web Dashboard | Next.js 14, React 18, TypeScript, Tailwind CSS, Radix UI |
| Docker TCP | Python 3.11, asyncio, Redis, Celery (background tasks) |
| Launcher | C#, .NET 10, Avalonia UI 11.2 (cross-platform desktop) |
| Database | PostgreSQL 16 (Docker) / PostgreSQL 17 (standalone) |
| Cache/Queue | Redis 7 (Docker) |
| Build System | CMake (Server), Flutter/Gradle (Android), MSBuild / dotnet (Client) |
| Encryption | AES-256-GCM with PBKDF2 key derivation (310K iterations) |
| Password Hash | Argon2id (m=65536, t=3, p=4) |
dcn-project/
├── Code/
│ ├── Modified/ # Main source code
│ │ ├── Docker/ # Docker Compose orchestration
│ │ │ ├── docker-compose.yml # Multi-service orchestrator
│ │ │ ├── .env # Environment variables
│ │ │ ├── web/ # Next.js Web Dashboard
│ │ │ │ ├── src/app/ # App router (dashboard, login, API routes)
│ │ │ │ ├── src/lib/ # Shared libs (auth, db, redis, utils)
│ │ │ │ ├── package.json
│ │ │ │ └── Dockerfile
│ │ │ ├── tcp-server/ # Python async TCP server
│ │ │ │ ├── server.py # asyncio TCP server
│ │ │ │ ├── database.py # PostgreSQL access + conflict detection
│ │ │ │ ├── user_manager.py # Authentication (Argon2id)
│ │ │ │ ├── protocol.py # Protocol parser/serializer
│ │ │ │ ├── crypto.py # AES-256-GCM encryption (PBKDF2)
│ │ │ │ ├── requirements.txt
│ │ │ │ └── Dockerfile
│ │ │ ├── celery-worker/ # Background task worker
│ │ │ │ ├── celery_app.py # Celery configuration
│ │ │ │ ├── tasks.py # Stats collection & cleanup
│ │ │ │ ├── requirements.txt
│ │ │ │ └── Dockerfile
│ │ │ └── init_db/ # Database initialization
│ │ │ └── init.sql # Schema + seed data
│ │ │
│ │ ├── Server/ # C++ Server (IOCP + Qt6 GUI)
│ │ │ ├── CMakeLists.txt # CMake build config (Argon2 from source)
│ │ │ ├── main.cpp # Qt GUI entry point
│ │ │ ├── main_cli.cpp # CLI-only server entry point
│ │ │ ├── Server.cpp/h # IOCP networking core
│ │ │ ├── ClientHandler.cpp/h # Per-client request processing
│ │ │ ├── Database.cpp/h # PostgreSQL access + conflict detection
│ │ │ ├── UserManager.cpp/h # Argon2id authentication
│ │ │ ├── Protocol.h # Protocol parser/serializer (10-field Course)
│ │ │ ├── Crypto.h # AES-256-GCM + PBKDF2 key derivation
│ │ │ ├── Logger.h # File-based logging
│ │ │ ├── SystemMonitor.cpp/h # CPU/Memory/Network monitoring
│ │ │ ├── MainWindow.cpp/h # Qt6 server dashboard
│ │ │ ├── HashGen.cpp # Argon2id password hash generator
│ │ │ ├── BuildCLI.bat # Build script (CLI mode)
│ │ │ ├── BuildQT.bat # Build script (Qt GUI mode)
│ │ │ ├── API-Doc.md # Server module API documentation
│ │ │ └── server.cfg # Database connection config
│ │ │
│ │ ├── ClientGUI/ # Windows desktop client (WinUI 3)
│ │ │ ├── Models/
│ │ │ │ ├── Course.cs # Course data model (10 fields)
│ │ │ │ ├── Protocol.cs # Protobuf response parser + types
│ │ │ │ └── Dcn.cs # Generated Protobuf C# classes
│ │ │ ├── Services/
│ │ │ │ ├── NetworkService.cs # TCP socket + AES-256-GCM encryption (PBKDF2)
│ │ │ │ ├── CacheService.cs # Local course data cache
│ │ │ │ └── AIService.cs # AI-powered teacher/course query (SearXNG + LLM)
│ │ │ ├── Views/
│ │ │ │ ├── LoginPage.xaml # Login / connect page
│ │ │ │ ├── QueryPage.xaml # Course query + timetable grid + AI ask
│ │ │ │ ├── AdminPage.xaml # Admin CRUD page
│ │ │ │ └── SudoPage.xaml # Sudo user management page
│ │ │ ├── MainWindow.xaml # Main navigation host
│ │ │ ├── ai_config.yaml # AI service configuration
│ │ │ └── ClientGUI.csproj # .NET 10 project file
│ │ │
│ │ ├── AndroidApp/ # Android mobile client (Flutter/Dart)
│ │ │ ├── lib/
│ │ │ │ ├── main.dart # App entry point (Riverpod ProviderScope)
│ │ │ │ ├── app.dart # MaterialApp + GoRouter setup
│ │ │ │ ├── screens/ # login_screen, query_screen, admin_screen, sudo_screen
│ │ │ │ ├── models/ # Course, Protocol models (10 fields)
│ │ │ │ ├── services/ # network_service, crypto_service (PBKDF2/PointyCastle), cache_service, ai_service
│ │ │ │ ├── providers/ # Riverpod: network, course, timetable, ai
│ │ │ │ ├── widgets/ # course_card, search_bar, timetable_grid, ai_dialog, status_toast
│ │ │ │ ├── config/ # app_config, ai_config
│ │ │ │ └── theme/ # app_theme, colors (Material Design 3)
│ │ │ └── pubspec.yaml # Flutter project config
│ │ │
│ │ ├── Launcher/ # OneKeyStart launcher (Avalonia UI)
│ │ │ ├── Program.cs # Avalonia app entry point
│ │ │ ├── App.axaml(.cs) # Application definition
│ │ │ ├── MainWindow.axaml(.cs)# Main window with toggle buttons
│ │ │ ├── OneKeyStart.csproj # .NET 10 project file
│ │ │ └── app.manifest
│ │ │
│ │
│ ├── Protocol/ # Shared Protobuf definition
│ │ ├── dcn.proto # Protobuf message/service definitions (18 request types)
│ │ ├── cpp/ # Generated C++ protobuf code (dcn.pb.cc/h)
│ │ ├── csharp/ # Generated C# protobuf code (Dcn.cs)
│ │ ├── dart/ # Generated Dart protobuf code (dcn.pb.dart)
│ │ ├── python/ # Generated Python protobuf code (dcn_pb2.py)
│ │ └── generate.bat # Protoc code generation script
│ │
│ └── Origin/ # Original assignment source
│ ├── Client.cpp # Original C++ client (Winsock)
│ └── Server.cpp # Original C++ server (Winsock)
│
├── Data/
│ ├── CourseList.xlsx # Course data (Excel)
│ ├── 导入脚本.py # Excel-to-PostgreSQL import script
│ └── 数据库结构备份 26.5.13.sql # Database schema & structure backup
│
├── Guide/
│ ├── Assignment2_2026.pdf # Assignment specification
│ ├── Assignment_2_Compilation.pdf # Assignment compilation guide
│ ├── pdf2img.py # PDF to PNG conversion utility
│ └── ForLLM/ # Reference materials (screenshots + requirements)
│ ├── Requirements.md
│ └── page_1.png ~ page_8.png
│
├── Pressure Test/ # Concurrent stress test
│ ├── stress_test.py # Multi-user async pressure test
│ ├── Conclusion.md # Test result analysis
│ └── requirements.txt
│
├── How-to-Meet-Requirements.md # Requirements mapping document
├── README.md # This file
└── .gitignore
- Course Querying — Search courses by:
- Course code (e.g.,
COMP3003) - Instructor name
- Time slot (day + time range)
- View all courses in the semester
- Course code (e.g.,
- User Authentication — Three-role system:
- Student — Query-only access
- Administrator — Full CRUD access (add, update, delete courses)
- Sudo — Super-admin: all admin privileges + user account management (create, update, enable/disable, delete users)
- Conflict Detection — When adding or updating courses, the server automatically checks for:
- Instructor time conflicts (same teacher, overlapping time)
- Classroom time conflicts (same room, overlapping time)
- Real-time Updates — When an administrator modifies course data, all connected clients receive instant notifications.
- Course Requirements — Courses can have prerequisite (
must) and conflict (mustnot) fields for timetable validation. - User Management (Sudo) — Sudo users can create, update, enable/disable, and delete user accounts. Disabled users cannot log in (soft-delete).
- Profile Update — All users can update their own username and password.
- Course Blocking — Users can block/unblock courses to filter them from search results.
- I/O Completion Port (IOCP) based architecture for high-concurrency
- Supports 5+ concurrent client connections (tested up to 100)
- Qt6-based monitoring dashboard with:
- Real-time CPU & memory usage bars
- Network TX/RX statistics
- Connected client table (IP, user, role, traffic)
- Scrollable log viewer
- Uptime counter
- CLI-only mode available (no Qt dependency)
- Graceful shutdown handling
- asyncio-based TCP server sharing the same protocol
- Redis-powered connection tracking and statistics
- Celery background worker for system stats collection and stale connection cleanup
- PostgreSQL server logs and TCP connection records
- Next.js 14 single-page application with 6 tabs:
- Dashboard: System stats (CPU, memory, TCP clients, courses), network I/O, uptime
- Courses: Search, filter, add to personal timetable with conflict/prerequisite indicators
- Timetable: Weekly grid view with color-coded blocks, export to PNG
- Admin: CRUD operations (admin role only)
- Connections: Active TCP connection table
- Logs: Server logs with severity levels
- Modern WinUI 3 interface with tabbed navigation
- Frame-based page navigation (Login → Query / Admin)
- Timetable grid with weekly view, color-coded blocks, and PNG export
- AI-powered queries via SearXNG web search + OpenAI-compatible LLM:
- Ask about a teacher (background, courses taught)
- Ask about a course (syllabus, key topics)
- Course prerequisite/conflict validation with color-coded buttons:
- Green: available to add
- Yellow: prerequisites not met
- Red: conflict with selected courses
- Grey: already selected
- Client-side data caching for offline query support
- Persistent connection with auto-reconnect
- Flutter app with Material Design 3, Riverpod state management, and GoRouter navigation
- Chip-based search modes with auto-complete suggestions for course codes and instructors
- Course card list with optimized display
- Timetable grid with weekly view, color-coded blocks, and image export
- Course prerequisite/conflict validation (same color-coded system as Windows)
- AI-powered queries via SearXNG web search + OpenAI-compatible LLM for teacher and course info
- Client-side data caching via CacheService
- Pull-to-refresh support
CheatManagerCLI.py— Interactive Python CLI tool for managing users:- List, add, delete users
- Change username, password, role
- Argon2id password hashing
- Protected by sudo login
The system uses a binary Protobuf protocol with 8-byte length-prefix framing over TCP (default port 50000 for C++ server, 50001 for Python server). All messages are encrypted with AES-256-GCM.
[0xDC 0xA1][ver 0x01][flags][uint32_BE payload_length][encrypted protobuf payload]
\_ magic _/ \_ ver _/ \_ 1B _/ \_____ 4B length _____/ \_____ variable ______/
| Field | Size | Description |
|---|---|---|
| Magic | 2 bytes | 0xDC 0xA1 — identifies protocol packets |
| Version | 1 byte | 0x01 — protocol version |
| Flags | 1 byte | 0x00 = request, 0x01 = response, 0x02 = notification |
| Payload length | 4 bytes | Big-endian uint32, max 16 MiB |
| Payload | variable | AES-256-GCM encrypted Protobuf-serialized dcn.Request / dcn.Response |
The protocol is defined in Protocol/dcn.proto and generates code for all platforms.
| Category | Type | Required Role | Description |
|---|---|---|---|
| Auth | LOGIN |
— | Authenticate with username/password |
LOGOUT |
— | Disconnect session | |
| Query | QUERY_COURSE |
— | Fuzzy search by course code |
QUERY_INSTRUCTOR |
— | Fuzzy search by instructor name | |
QUERY_ALL |
— | Retrieve all courses | |
QUERY_TIMESLOT |
— | Search by day + time | |
| Course Admin | ADD_COURSE |
admin | Add new course (with conflict check) |
UPDATE_COURSE |
admin | Update course fields (with conflict check) | |
DELETE_COURSE |
admin | Remove a course | |
BLOCK_COURSE |
— | Hide course from personal search results | |
UNBLOCK_COURSE |
— | Unhide a blocked course | |
| Profile | UPDATE_PROFILE |
— | Change own username/password |
| User Mgmt | LIST_USERS |
sudo | List all users |
CREATE_USER |
sudo | Create a new user | |
UPDATE_USER |
sudo | Update username/password/role | |
DISABLE_USER |
sudo | Soft-disable a user account | |
ENABLE_USER |
sudo | Re-enable a disabled account | |
DELETE_USER |
sudo | Permanently delete a user |
| Code | Meaning |
|---|---|
SUCCESS |
Operation succeeded |
FAILURE |
Operation failed (includes conflict messages) |
ERROR_MALFORMED |
Invalid / malformed request |
ERROR_UNAUTHORIZED |
Access denied (insufficient role) |
ERROR_NOT_FOUND |
No matching records |
Course — 10 fields: code, title, section, instructor, day, start_time, end_time, classroom, must, mustnot
UserInfo — username, role, enabled
Response — contains status, message, repeated courses[], repeated users[]
- Windows 10/11 (Winsock2 required)
- CMake 3.16+
- OpenSSL 3.x (development libraries, required for AES-256-GCM and PBKDF2)
- Argon2 (compiled from source, included in
Apps/Server/argon2_local/) - Qt 6.x (Widgets module) — for GUI mode; optional for CLI mode
- PostgreSQL 16+ (with libpq development headers)
- MSVC 2022 or compatible C++17 compiler
- .NET 10 SDK
- Windows App SDK 1.5+
- Windows 10 (build 19041+) / Windows 11
- Flutter SDK (3.12+)
- Dart SDK (3.12+)
- Android Studio (for Android SDK and emulator)
- Docker Desktop with Docker Compose
- No additional host-side dependencies required
- PostgreSQL 16+ running and accessible (Docker or standalone)
- Database user with
CREATE TABLEand full CRUD privileges
Option A: Docker (recommended)
cd Code/Modified/Docker
docker compose up -d postgresOption B: Standalone PostgreSQL
- Create a PostgreSQL database and run the schema backup:
psql -h <host> -p <port> -U <user> -d <dbname> -f "Data/数据库结构备份 26.5.13.sql"- Import real course data (optional, for production data):
cd Data
python 导入脚本.pyThe script reads the Excel course list and inserts all records into PostgreSQL. Configure the database connection parameters at the top of the script before running.
GUI Mode (with Qt6 monitoring dashboard):
cd Code/Modified/Server
# Configure and build with CMake
cmake -B build -S . -DCMAKE_PREFIX_PATH="<Qt6_install_path>"
cmake --build build --config Release
# Run
build\Release\Server.exeOr use the batch scripts:
BuildQT.bat— Build with Qt6 GUI supportBuildCLI.bat— Build CLI-only mode
CLI Mode (no Qt dependency):
# The CLI server is compiled from main_cli.cpp
cmake -B build -S .
cmake --build build --config Release
build\Release\ServerCLI.exe [port] [thread_count]cd Code/Modified/ClientGUI
# Restore and build
dotnet restore
dotnet build -c Release
# Run
dotnet runOr open ClientGUI.csproj in Visual Studio 2022 and press F5.
- Install Flutter SDK and set up Android toolchain.
- Update the server IP address in
lib/config/app_config.dart(default:192.168.1.100). - Run
flutter pub getto install dependencies. - Build and run on an emulator or physical device:
- Debug:
flutter run - Release APK:
flutter build apk --release
- Debug:
OneKeyStart is an Avalonia UI desktop application that provides a single window to launch and manage all project components.
Build:
cd Code/Modified/Launcher
# Restore and publish as single-file executable
dotnet restore
dotnet publish -c Release -r win-x64
# Output: bin/Release/net10.0/win-x64/publish/OneKeyStart.exeFeatures:
- Toggle buttons — Click to start CLI Server, GUI Server, or ClientGUI; click again to stop. Button turns green when running, reverts when the process exits.
- Binary detection — Buttons turn red if the corresponding executable is not found, with a popup explaining how to build.
- Process monitoring — Background timer tracks managed processes and automatically updates button state when a process exits.
- Docker WebUI — Launches
docker compose up -din a terminal window (requires Docker Desktop). - Android install — Runs
adb install -ron the release APK (requires ADB and a connected device).
cd Code/Modified/Docker
docker compose up -dThis starts:
- PostgreSQL on port 5432 (internal)
- Redis on port 6379 (internal)
- Web Dashboard on port 50000
- Python TCP Server on port 50001
- Celery Worker (background stats + cleanup)
Configure via .env file before starting.
- Launch the client application.
- Click Connect (or enter server IP:port for Android, then tap Connect).
- Enter username and password (e.g.,
student1/student123). - Click Login.
- By Course Code: Select "By Course Code" chip → enter a code like
COMP3003→ Search. - By Instructor: Select "By Instructor" chip → start typing an instructor name → select from suggestions.
- By Time Slot: Select "By Time Slot" chip → choose a day and enter a time → Search.
- View All: Select "View All" chip → all courses are loaded automatically.
- Timetable: Select "Timetable" chip → view your selected courses in a weekly grid.
- Click ASK AI button → choose "Ask Teacher" or "Ask Course".
- The AI service searches the web via SearXNG and uses an LLM to provide information about teachers or course content.
After logging in with an admin account (e.g., admin):
- Add Course: Fill in all course fields → tap/click Add. Server checks for instructor/classroom conflicts.
- Update Course: Enter course code and section → modified fields are applied.
- Delete Course: Enter course code and section → confirm deletion.
- View All Courses: Browse the full course list.
After logging in with a sudo account (e.g., sudo):
- View Users: See all user accounts with role and status.
- Create User: Add new user with username, password, and role.
- Update User: Change a user's username, password, or role.
- Disable/Enable User: Soft-disable or re-enable a user account.
- Delete User: Permanently remove a user account.
| Username | Password | Role |
|---|---|---|
admin |
admin123 |
admin |
student1 |
student123 |
student |
student2 |
student123 |
student |
student3 |
student123 |
student |
guest |
guest123 |
student |
sudo |
sudo123 |
sudo |
Passwords are stored as Argon2id hashes. Use the
HashGen.cpputility orCheatManagerCLI.pyto generate/manage passwords.
The Data/ directory contains:
- Course Excel File:
CourseList.xlsx— the full semester 2 course list for AY 2025-26. - Import Script:
导入脚本.py— a Python script that parses the Excel file and inserts all records into PostgreSQL.
The script handles:
- Course code, title, and section extraction
- Schedule parsing (day, start/end times)
- Instructor and classroom mapping
- Prerequisite/restriction parsing
python Data/导入脚本.py [optional_path_to_xlsx]- AES-256-GCM Encryption: All client-server communication is encrypted using AES-256-GCM (Galois/Counter Mode) — an authenticated encryption mode that provides both confidentiality and integrity. Key is derived via PBKDF2-HMAC-SHA256 with 310,000 iterations and salt
DCN2026SALT. Each message uses a random 12-byte nonce. Implementations use platform-standard libraries: OpenSSL (C++),cryptography(Python),pointycastle(Flutter/Dart), andSystem.Security.Cryptography.AesGcm(C#). - Protobuf Binary Protocol: All messages use Protocol Buffers (Protobuf) for efficient binary serialization with an 8-byte fixed header framing (magic + version + flags + length prefix).
- Argon2id Password Hashing: User passwords are stored as Argon2id hashes (PHC winner, m=65536, t=3, p=4) — never in plaintext. This provides resistance against GPU/ASIC brute-force attacks.
- Role-Based Access Control: Three-tier role system — student (read-only), admin (course CRUD), sudo (user management). The server enforces role checks before processing privileged operations.
- Soft-Delete: User accounts can be disabled (soft-deleted) instead of permanently removed, preventing accidental data loss.
- Conflict Detection: Server-side validation prevents scheduling conflicts for instructors and classrooms.
- Input Validation: Malformed requests return
ERROR_MALFORMEDwithout crashing the server. Parameterized SQL queries prevent SQL injection.
Beyond the core assignment requirements, the following bonus features are implemented:
- Graphical User Interface (GUI) — Windows desktop (WinUI 3), Android (Flutter / Material Design 3), and Web (Next.js) clients with polished interfaces.
- Advanced Search — Search by time slot (day + time range) in addition to course code, instructor, and view-all queries.
- Data Caching — Both Windows and Android clients cache query results locally, reducing network round-trips for repeated queries.
- AES-256-GCM Encrypted Communication — All network traffic is encrypted using AES-256-GCM with PBKDF2 key derivation, providing authenticated encryption with both confidentiality and integrity protection.
- Binary Protobuf Protocol — Efficient binary serialization with Protocol Buffers and fixed-size 8-byte length-prefix framing, replacing the original text-based protocol.
- Server Monitoring Dashboard — Qt6-based GUI showing real-time CPU/memory usage, network throughput, connected clients, and full log output. Docker version adds web-based monitoring.
- Real-time Notifications — When an admin modifies course data, all connected clients receive instant update notifications.
- Multi-platform Client — Supports Docker web dashboard, Windows desktop, and Android mobile clients.
- OneKeyStart Launcher — A desktop application to start all project components with a single click.
- Timetable Visualization — Interactive weekly grid on all platforms (WinUI 3, Android, Web) with color-coded course blocks and PNG/image export.
- Course Prerequisites & Conflicts —
mustandmustnotfields on courses with client-side validation and server-side conflict detection. - AI-Powered Queries — Windows and Android clients integrate SearXNG web search with an LLM to answer questions about teachers and courses.
- Docker Stack — Full containerized deployment with PostgreSQL, Redis, Celery worker, web dashboard, and Python TCP server.
- User Management System — Sudo role with full user account management (create, update, enable/disable, delete) via GUI clients (WinUI 3 SudoPage, Flutter SudoScreen).
- Course Blocking — Users can block/unblock courses to personalize their search results.
For a detailed mapping of how each assignment requirement is fulfilled, see How to Meet Requirements. Each requirement includes the exact source file and line reference.