QueueLess – Smart Queue Management System

QueueLess is a comprehensive, multi‑tenant queue management platform designed for businesses of all types – hospitals, banks, shops, restaurants, and more. It allows administrators to create and manage multiple locations (places), providers to handle queues in real time, and users to join queues, track their position, receive notifications, and provide feedback. The system features live updates via WebSocket, email/push notifications, Razorpay payment integration, role‑based access control, and detailed analytics.

Features

For End Users

Search & Discover: Find places by name, type, location, or rating.
Join Queues: Choose regular, group, or emergency tokens (with provider approval).
Real‑time Updates: Live position, wait time, and status changes via WebSocket.
Notifications: Email and push notifications before your turn, and when a queue becomes short.
Feedback: Rate your experience with detailed dimensions (staff, service, wait time).
Favorites: Save favourite places for quick access.
Token History: View past tokens and ratings.

For Providers

Queue Management: Create, pause, resume, and reset queues.
Token Handling: Serve next, complete, cancel tokens; view user details for each token.
Emergency Approvals: Approve or reject emergency tokens with optional reason.
Dashboard: Real‑time statistics, drag‑and‑drop reorder, export reports (PDF/Excel).
Analytics: Token volume over time, busiest hours, average wait time trends.

For Administrators

Place Management: Create and update places with images, location, contact info, business hours.
Service Management: Define services under each place (e.g., cardiology, haircut) with average service time.
Provider Management: Add providers (via token purchase), update their details, assign places, enable/disable accounts, reset passwords.
Dashboard: Overview of all places, queues, providers, payment history, and analytics charts.
Export: Generate admin reports in PDF/Excel.
Alert Configuration: Set wait time thresholds to receive email alerts.

General

Authentication & Authorization: JWT‑based with roles: USER, PROVIDER, ADMIN. Email verification via OTP.
Payments: Razorpay integration for purchasing admin/provider tokens.
Audit Logging: All critical actions are logged for compliance and debugging.
Rate Limiting: Per‑user and IP‑based limits to prevent abuse.
Caching: Redis cache for places, services, queues.
Monitoring: Prometheus metrics, Grafana dashboards, Loki logs.

Tech Stack

Layer	Technology
Backend	Java 25, Spring Boot 3.5, Spring Security, Spring Data MongoDB, Spring WebSocket, JWT, Lombok
Frontend	React 18, Vite, Redux Toolkit, React Bootstrap, React Router, Formik & Yup, React Toastify, Recharts, STOMP.js, SockJS, Firebase Cloud Messaging
Database	MongoDB (primary), Redis (caching, OTP store)
Messaging	WebSocket (STOMP)
Payments	Razorpay
Notifications	Firebase Cloud Messaging (push), JavaMail (SMTP)
Monitoring	Prometheus, Grafana, Loki, Promtail
DevOps	Docker, Docker Compose, Maven

Architecture Overview

QueueLess follows a client‑server architecture with a Spring Boot backend and a React frontend.

Backend: Exposes RESTful API and STOMP WebSocket endpoints. Business logic is encapsulated in services. Data persistence uses MongoDB (with geospatial queries). Redis is used for caching and temporary OTP storage.
Frontend: Single‑page application built with React and Redux for state management. WebSocket client maintains live connections for queue updates.
Real‑time Updates: When a queue changes (token added, served, completed), the backend broadcasts the updated queue via WebSocket to all subscribed clients.
Security: All endpoints except public ones require a JWT token. Role‑based access is enforced with method‑level annotations (@AdminOnly, @ProviderOnly, etc.).
Payments: Admin/Provider tokens are purchased via Razorpay; the backend generates and validates the tokens.
Push Notifications: Firebase Cloud Messaging is used for sending notifications when a user’s turn is approaching or when a queue becomes short.

Data Model Highlights

User – can be USER, PROVIDER, or ADMIN.
Place – represents a physical location (hospital, shop) with geo‑coordinates.
Service – a specific service offered at a place (e.g., “Cardiology Consultation”).
Queue – linked to a service and provider, contains a list of tokens.
Token – represents a user’s spot in a queue; can be regular, group, or emergency.
Feedback – submitted for completed tokens, includes multi‑dimensional ratings.
AuditLog – records important actions for traceability.
NotificationPreference – per‑queue notification settings for users.

Screenshots & Demo

🏠 Public Pages

Home Page (Click to expand)

Hero Section

Landing page with call‑to‑action, statistics, and live queue status.

Features & Testimonials

Overview of key features and user testimonials.

Places List & Place Details

Places List

All active places displayed with images, ratings, and addresses.

Places List (Dark Mode)

Place Detail

Main view with services, business hours, and location map.

Place Detail – Feedback & Best Time

User reviews, average ratings, and best‑time recommendations.

Advanced Search

Search Filters

Filter by location, rating, wait time, and features.

Search Results – Places

Search Results – Services

Search Results – Queues

Paginated results with place details and queue status.

Authentication & Registration

Login Page

All roles login with email and password.

Register Page – User

User registration – no payment required.

Register – Mobile View

Email Verification
All roles receive a verification email after registration.
Example email (responsive):

Verification page:

Forgot Password

Enter email, receive OTP, then reset password.

Admin Token Purchase & Registration

Pricing Page (Admin)

Razorpay checkout for purchasing admin tokens.

Admin Token Generated

Copy the token and use it during registration.

Admin Registration

Choose “ADMIN” role and paste the purchased token. Token works once and expires.

👤 User Dashboard (Logged‑in)

Dashboard Overview

My Queues

Favourite Places

Token Usage Chart

Places Section

Dark Mode

Mobile View

Personal dashboard showing active queues, favourite places, and token history.

Joining a Queue & Token Flow

Regular Token – Join Form

Get Token with Details

Group Token – Form

Emergency Token – Form

Queue Information

Mobile View

Live Position

Feedback Prompt (after token completion)

Feedback Form

Filled Form

Completion Message

Users can choose regular, group, or emergency tokens, provide details, and give feedback after completion.

Queue Position & Notifications

Queue Position

Push Notifications
Your turn is coming up:

Queue is short:

Email Notification
Reminder when your turn is approaching:

Favourite Places

Favourites Page

Dark Mode

Mobile View

Notification Preferences

Empty State

Add Preference – Select Queue

Add Preference – Set Options

Preferences List

Mobile View

Per‑queue settings for reminder time, status changes, and best‑time alerts.

User Profile

Profile Page

Avatar Selection

Personal Information

Change Password

Preferences & Account

Dark Mode

Mobile View – Light

Mobile View – Dark

Update name, phone, password, upload profile image, and manage preferences.

Token History

Past tokens with ratings and service details.

🛠️ Provider Dashboard

Provider Queue List

Queues List

Dark Mode

Mobile View

List of all queues with status and quick actions.

Queue Management

Dashboard

Complete Token

Completed Tokens List

QR Code

Reset Queue with Export

Export History

Dark Mode

Mobile View

Drag‑and‑drop reorder, serve next, complete/cancel tokens, view user details, and reset.

Emergency Approval

Approve or reject emergency token requests with optional reason.

Analytics & Exports

Token Volume (30 days)

Busiest Hours

Average Wait Time Trend

Export Reports

Dark Mode Charts

Mobile View

Charts for token volume, busiest hours, average wait time, and PDF/Excel exports.

👑 Admin Dashboard

Admin Overview

Dashboard

Dark Mode

Mobile View

Statistics cards, quick actions, and tabs for places, queues, payments, providers, analytics.

Place Management

Places List

Create/Edit Place (Dark Mode)

Mobile View

Create and edit places with images, location, business hours, and contact info.

Service Management

Services List

Create Service

Services Table

Dark Mode – Create Service

Mobile View

Add services under a place, set average service time, and enable group/emergency support.

Provider Management

Providers Table

Dark Mode

Provider Details

Edit Provider

Dark Mode – Details

Mobile View

Password Reset Email

List all providers, view performance, edit details, assign places, and reset passwords.

Payment History

Payment History

Dark Mode

Mobile View

Record of all token purchases (admin and provider) with transaction details.

Admin Queues

Queues Table

Dark Mode

Mobile View

Admins can see all queues managed by their providers and toggle active status.

Analytics Charts

Token Volume

Busiest Hours

Dark Mode

Mobile View

Token volume over time and busiest hours across all places.

Heat Map (Queue Load)

Heat Map

Dark Mode

Mobile View

Geographic visualisation of queue load per place.

Alert Configuration

Alert Config Form

Dark Mode

Mobile View

Alert Email

Set wait time thresholds; receive email alerts when exceeded.

📄 Additional Public Pages

About Us

Mobile View

Our mission, problem statement, solution, differentiators, and technologies used.

How to Use

User Guide

Provider Guide

Admin Guide

Pro Tips

Mobile View

Step‑by‑step instructions for each role, plus tips for best experience.

Documentation

Mobile View

Major API documentation – User Friendly Ui for apis and getting started.

Privacy Policy & Terms of Service

Privacy Policy

Mobile View

Legal information page containing both privacy policy and terms of service.

📚 Swagger – API Documentation

Schemas

Interactive OpenAPI documentation for all controllers and models.

📊 Grafana – Monitoring Dashboards

Queue Metrics

Spring Boot Metrics

Cache & Performance

Logs Drilldown

All Metrics

Visualise metrics and logs from Prometheus and Loki.

🎬 Real‑time Updates (Demo)

Live Queue Updates

Watch as tokens are added, served, and completed – the queue updates instantly on all connected clients.

All screenshots are from the running application.

Getting Started

Prerequisites

Java 25 (or newer)
Node.js 20+ and npm
MongoDB (local or Atlas)
Redis (local or cloud)
Razorpay account (for payments)
Firebase project (for push notifications)
SMTP server (e.g., Gmail) for emails

Installation

Clone the repository

git clone https://github.com/harman-04/QueueLess.git
cd QueueLess

Backend setup
```
cd backend/backend
./mvnw clean install
```

Frontend setup

cd ..
cd ../frontend/queue-less-frontend
npm install

Environment Variables

Create a .env file in both backend and frontend directories.

Backend `.env` (inside `backend/`)

MONGODB_URI=mongodb://localhost:27017/queueless
REDIS_HOST=localhost
JWT_SECRET=your_jwt_secret_key_here
JWT_EXPIRATION=86400000
RAZORPAY_KEY=rzp_test_xxxxxxxxxx
RAZORPAY_SECRET=your_razorpay_secret
MAIL_USERNAME[email protected]
MAIL_PASSWORD=your_app_password
SSL_KEY_STORE_PASSWORD=changeit
APP_FRONTEND_URL=https://localhost:5173

Note: For Gmail, use an App Password if 2FA is enabled.

Frontend `.env` (inside `frontend/`)

VITE_API_BASE_URL=https://localhost:8443/api
VITE_FIREBASE_API_KEY=your_firebase_api_key
VITE_FIREBASE_AUTH_DOMAIN=your_firebase_auth_domain
VITE_FIREBASE_PROJECT_ID=your_firebase_project_id
VITE_FIREBASE_STORAGE_BUCKET=your_firebase_storage_bucket
VITE_FIREBASE_MESSAGING_SENDER_ID=your_firebase_messaging_sender_id
VITE_FIREBASE_APP_ID=your_firebase_app_id
VITE_FIREBASE_VAPID_KEY=your_firebase_vapid_key
VITE_RAZORPAY_KEY_ID=rzp_test_xxxxxxxxxx

Environment Variables – Detailed Reference

QueueLess uses separate .env files for different environments:

Backend – placed in the backend/ folder, read by Spring Boot.
Frontend – placed in the frontend/ folder, read by Vite.
Docker Compose – placed in the project root (where docker-compose.yml lives), used to supply variables to containers.

Backend `.env` (inside `backend/`)

Variable	Description	Example
`MONGODB_URI`	MongoDB connection string	`mongodb://localhost:27017/queueless`
`REDIS_HOST`	Redis host (used for caching and OTP store)	`localhost`
`JWT_SECRET`	Secret key for signing JWT tokens	`your-256-bit-secret`
`JWT_EXPIRATION`	Token validity in milliseconds	`86400000` (24 hours)
`RAZORPAY_KEY`	Razorpay API key	`rzp_test_xxxxxx`
`RAZORPAY_SECRET`	Razorpay API secret	`your_secret`
`MAIL_USERNAME`	SMTP username (e.g., Gmail address)	`[email protected]`
`MAIL_PASSWORD`	SMTP password or app password	`your_app_password`
`SSL_KEY_STORE_PASSWORD`	Password for the SSL keystore (default `changeit`)	`changeit`
`APP_FRONTEND_URL`	URL of the frontend (used for reset password links)	`https://localhost:5173`
`FILE_UPLOAD_DIR`	Directory where uploaded profile images are stored	`uploads/`
`RATE_LIMIT_CAPACITY`	Default rate limit bucket capacity	`100`
`RATE_LIMIT_REFILL`	Tokens refilled per duration	`100`
`RATE_LIMIT_DURATION`	Duration for rate limit refill (ISO‑8601)	`PT1M` (1 minute)

Note: This file is used when running the backend directly with ./mvnw spring-boot:run or as a standalone JAR.

Frontend `.env` (inside `frontend/`)

Variable	Description	Example
`VITE_API_BASE_URL`	Base URL of the backend API	`https://localhost:8443/api`
`VITE_FIREBASE_API_KEY`	Firebase API key	`AIza...`
`VITE_FIREBASE_AUTH_DOMAIN`	Firebase auth domain	`your-project.firebaseapp.com`
`VITE_FIREBASE_PROJECT_ID`	Firebase project ID	`your-project`
`VITE_FIREBASE_STORAGE_BUCKET`	Firebase storage bucket	`your-project.appspot.com`
`VITE_FIREBASE_MESSAGING_SENDER_ID`	Firebase sender ID	`1234567890`
`VITE_FIREBASE_APP_ID`	Firebase app ID	`1:123:web:abc`
`VITE_FIREBASE_VAPID_KEY`	VAPID key for push notifications	`BEl...`
`VITE_RAZORPAY_KEY_ID`	Razorpay API key (same as backend key)	`rzp_test_xxxxxx`

Note: This file is used when running the frontend with npm run dev or building with npm run build. All variables must be prefixed with VITE_.

Docker Compose Root `.env`

When running the full stack with Docker Compose, a third .env file should be placed in the project root (the same directory as docker-compose.yml). This file supplies environment variables to the containers. It typically contains a superset of the variables needed by both backend and frontend, plus any additional configuration for the containers themselves.

Example docker-compose.env (or simply .env at the root):

# Backend
MONGODB_URI=mongodb://mongodb:27017/queueless
JWT_SECRET=your_jwt_secret_key_here
JWT_EXPIRATION=86400000
RAZORPAY_KEY=rzp_test_xxxxxxxxxx
RAZORPAY_SECRET=your_razorpay_secret
MAIL_USERNAME=[email protected]
MAIL_PASSWORD=your_app_password
SSL_KEY_STORE_PASSWORD=changeit

Running Locally

Backend

cd backend/backend
./mvnw spring-boot:run

The backend will start on `https://localhost:8443` (SSL enabled). You can access the API at `https://localhost:8443/api`.

#### Frontend

```bash
cd frontend/queue-less-frontend
npm run dev

The frontend will be available at https://localhost:5173.

SSL Certificate (Development)

The application uses HTTPS (port 8443 for backend, 443 for frontend in Docker) with self‑signed certificates. To avoid browser warnings, you can generate trusted certificates using mkcert.

Install mkcert

macOS: brew install mkcert
Windows: choco install mkcert or download from github.com/FiloSottile/mkcert
Linux: sudo apt install libnss3-tools then curl -JLO "https://dl.filippo.io/mkcert/latest?for=linux/amd64" && chmod +x mkcert-v*-linux-amd64 && sudo mv mkcert-v*-linux-amd64 /usr/local/bin/mkcert

Generate and Install Certificates

Create a local CA (one‑time):
```
mkcert -install
```

Generate certificates for localhost:

cd backend/src/main/resources
mkcert localhost 127.0.0.1 ::1

This creates localhost+2.pem and localhost+2-key.pem. Rename them:

mv localhost+2.pem localhost.pem
mv localhost+2-key.pem localhost-key.pem

Convert to PKCS12 format (required by Spring Boot):

openssl pkcs12 -export -in localhost.pem -inkey localhost-key.pem -out localhost.p12 -name localhost -password pass:changeit

The password changeit matches the default in application.properties.

Place the .p12 file inside src/main/resources/.

Backend Configuration

The application.properties already contains:

server.ssl.key-store=classpath:localhost.p12
server.ssl.key-store-password=${SSL_KEY_STORE_PASSWORD:changeit}
server.ssl.key-store-type=PKCS12

Make sure the password matches the one used when generating the .p12 file.

Frontend Configuration (Vite)

For the Vite dev server to trust the certificate, add this to vite.config.js:

import { defineConfig } from 'vite';
import react from '@vitejs/plugin-react';

export default defineConfig({
  plugins: [react()],
  server: {
    https: {
      key: 'path/to/localhost-key.pem',
      cert: 'path/to/localhost.pem',
    },
    port: 5173,
    proxy: {
      '/api': {
        target: 'https://localhost:8443',
        changeOrigin: true,
        secure: false,
      },
    },
  },
});

Replace the paths with the actual location of your .pem files. The proxy ensures API requests are forwarded to the backend without CORS issues.

Docker

In the provided docker-compose.yml, the backend uses the localhost.p12 file mounted from the host. Ensure you have generated the .p12 file and placed it in the expected location (backend/src/main/resources/localhost.p12).

Note: For production, use certificates from a trusted CA like Let’s Encrypt.

Docker Setup

The project includes a docker-compose.yml that runs the entire stack (backend, frontend, MongoDB, Redis, Prometheus, Grafana, Loki, Promtail). Make sure you have Docker and Docker Compose installed.

Build and start all services
```
docker-compose up --build
```
Access the application
- Frontend: https://localhost:5173
- Backend API: https://localhost:8443
- Grafana: http://localhost:3000 (admin/admin)
- Prometheus: http://localhost:9090
- Loki: http://localhost:3100

Note: SSL certificates are self‑signed for development; browsers will show a warning – proceed anyway.

API Documentation

Interactive API documentation is available via Swagger UI when the backend is running:

https://localhost:8443/swagger-ui.html

Main API Endpoints

Category	Endpoint	Description	Roles
Auth	`/api/auth/register`	Register a new user	Public
	`/api/auth/login`	Login, receive JWT	Public
	`/api/auth/verify-email`	Verify email with OTP	Public
Password	`/api/password/forgot`	Request password reset OTP	Public
	`/api/password/verify-otp`	Verify OTP	Public
	`/api/password/reset`	Reset password (with OTP)	Public
Payments	`/api/payment/create-order`	Create Razorpay order	Public
	`/api/payment/confirm`	Confirm payment (admin token)	Public
	`/api/payment/confirm-provider`	Confirm provider token	Public
Places	`/api/places`	CRUD operations for places	Admin / Public
Services	`/api/services`	CRUD for services	Admin / Public
Queues	`/api/queues`	Manage queues and tokens	Mixed
Feedback	`/api/feedback`	Submit and retrieve feedback	User / Public
Search	`/api/search`	Comprehensive search with filters	Public
Admin	`/api/admin`	Admin dashboard, provider management, reports	Admin
Provider	`/api/providers`	Provider‑specific data and analytics	Provider
User	`/api/user`	Profile, favorites, token history	User
Export	`/api/export`	Export queue reports (PDF/Excel)	Admin/Provider
Notifications	`/api/notifications/preferences`	Manage per‑queue notification settings	User
PasswordResetToken	`/api/password-reset-token`	Admin‑initiated password reset (token)	Admin

For a complete list, refer to the Swagger UI.

WebSocket Real‑Time Updates

QueueLess uses WebSocket (STOMP over SockJS) to provide live queue updates. The WebSocket endpoint is /ws.

Connecting

import { Client } from '@stomp/stompjs';
import SockJS from 'sockjs-client';

const client = new Client({
  webSocketFactory: () => new SockJS('https://localhost:8443/ws'),
  connectHeaders: { Authorization: `Bearer ${token}` },
  onConnect: () => console.log('Connected'),
});

client.activate();

Subscribing to a Queue

Subscribe to /topic/queues/{queueId} to receive updates whenever the queue changes (token added, served, completed, cancelled).

client.subscribe('/topic/queues/' + queueId, (message) => {
  const queue = JSON.parse(message.body);
  // update UI
});

User‑Specific Notifications

/user/queue/emergency-approved – emergency token approval/rejection.
/user/queue/token-cancelled – token cancellation notifications.
/user/queue/provider-updates – (for providers) updates when they serve a token.

Sending Commands

/app/queue/serve-next – serve next token (provider only).
/app/queue/add-token – add a regular token (user).
/app/queue/status – toggle queue active status (provider).

All commands require authentication and appropriate role.

Testing

Backend Tests

Run unit and integration tests with Maven:

cd backend
./mvnw test

The tests cover services, controllers, and some integration flows. A local MongoDB instance is automatically started/stopped via embedded MongoDB for tests.

Frontend Tests

Frontend tests are not yet implemented but can be added using Jest and React Testing Library.

Deployment

Backend

Build an executable JAR:

cd backend
./mvnw clean package -DskipTests

Copy the JAR (target/backend-0.0.1-SNAPSHOT.jar) to your server.
Run with Java:
```
java -jar backend-0.0.1-SNAPSHOT.jar
```
Use a process manager like systemd or supervisor to keep it running.

Frontend

Build the production bundle:
```
cd frontend
npm run build
```
Serve the dist folder with a web server (e.g., Nginx).

Docker / Docker Compose

For a full stack deployment, use the provided docker-compose.yml on a server with Docker installed. Adjust environment variables in the compose file or in a .env file.

Troubleshooting

Backend won't start – MongoDB connection refused

Ensure MongoDB is running locally or the MONGODB_URI is correct.
If using embedded MongoDB for tests, it starts automatically.

Redis connection errors

Verify Redis is installed and running (redis-server).
If Redis is not needed, you can disable caching by setting spring.cache.type=none in application.properties.

Emails not sending

For Gmail, enable 2FA and generate an App Password.
Check that MAIL_USERNAME and MAIL_PASSWORD are correct.
If using a different SMTP provider, adjust spring.mail.host and port.

Push notifications not working

Ensure Firebase project is configured correctly and VAPID_KEY is set.
In the browser, check that notifications are allowed for the site.
Verify that FCM tokens are being stored in the database (user's fcmTokens array).

File uploads fail with 403

Make sure the uploads/ directory exists and is writable.
The backend serves static files under /uploads/**. If you get 404, check that WebConfig is properly configured.

WebSocket connection fails

Check that the backend is running and the WebSocket endpoint /ws is accessible.
Ensure the JWT token is valid and passed in the Authorization header.
If using self‑signed certificates, the browser may block the connection. In development, you can temporarily disable SSL verification or use a valid certificate.

Rate limiting too strict

Adjust rate.limit.* properties in application.properties. For example, increase capacity and refill for development.

Common error: "Token expired" after login

The JWT expiration is set to 24 hours by default. If your system clock is skewed, tokens may appear expired. Synchronize time via NTP.

Contributing

We welcome contributions! To ensure a smooth process, please follow these guidelines:

Fork the repository and create your branch from main.
Write tests for any new functionality. We aim for high test coverage.
Ensure all tests pass by running mvn test in the backend and (if applicable) npm test in the frontend.
Follow coding conventions:
- Backend: Use standard Java naming conventions, include Javadoc for public methods, and format code with your IDE's default settings.
- Frontend: Use ESLint and Prettier (configuration included).
Commit messages should be clear and follow Conventional Commits (e.g., feat: add user profile image upload).
Open a pull request against the main branch. Describe your changes in detail and link any related issues.

Development Workflow

Backend: Run ./mvnw spring-boot:run for hot reload.
Frontend: Run npm run dev for Vite dev server with HMR.

Reporting Issues

Use the GitHub issue tracker to report bugs or suggest features. Include as much detail as possible: steps to reproduce, expected behavior, screenshots, and environment details.

License

This project is licensed under the Apache License, Version 2.0.
You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Code of Conduct

We as members, contributors, and leaders pledge to make participation in our community a harassment‑free experience for everyone, regardless of age, body size, visible or invisible disability, ethnicity, sex characteristics, gender identity and expression, level of experience, education, socio‑economic status, nationality, personal appearance, race, caste, color, religion, or sexual identity and orientation.

We pledge to act and interact in ways that contribute to an open, welcoming, diverse, inclusive, and healthy community.

Our full Code of Conduct is available in the CODE_OF_CONDUCT.md file. By participating, you are expected to uphold this code.

Acknowledgments

Thanks to all contributors and open‑source libraries that made this project possible.
Special thanks to the Spring Boot and React communities for excellent documentation and tools.

Name		Name	Last commit message	Last commit date
Latest commit History 40 Commits
.github/workflows		.github/workflows
backend/backend		backend/backend
frontend/queue-less-frontend		frontend/queue-less-frontend
loki		loki
prometheus		prometheus
promtail		promtail
screenshots		screenshots
.gitignore		.gitignore
CODE_OF_CONDUCT.md		CODE_OF_CONDUCT.md
DOCUMENTATION.md		DOCUMENTATION.md
LICENSE		LICENSE
README.md		README.md
docker-compose.yml		docker-compose.yml

Folders and files

Latest commit

History

Repository files navigation

QueueLess – Smart Queue Management System

Table of Contents

Features

For End Users

For Providers

For Administrators

General

Tech Stack

Architecture Overview

Data Model Highlights

Screenshots & Demo

🏠 Public Pages

👤 User Dashboard (Logged‑in)

🛠️ Provider Dashboard

👑 Admin Dashboard

📄 Additional Public Pages

📚 Swagger – API Documentation

📊 Grafana – Monitoring Dashboards

🎬 Real‑time Updates (Demo)

Watch as tokens are added, served, and completed – the queue updates instantly on all connected clients.

Getting Started

Prerequisites

Installation

Environment Variables

Backend .env (inside backend/)

Frontend .env (inside frontend/)

Environment Variables – Detailed Reference

Backend .env (inside backend/)

Frontend .env (inside frontend/)

Docker Compose Root .env

Running Locally

Backend

SSL Certificate (Development)

Install mkcert

Generate and Install Certificates

Backend Configuration

Frontend Configuration (Vite)

Docker

Docker Setup

API Documentation

Main API Endpoints

WebSocket Real‑Time Updates

Connecting

Subscribing to a Queue

User‑Specific Notifications

Sending Commands

Testing

Backend Tests

Frontend Tests

Deployment

Backend

Frontend

Docker / Docker Compose

Troubleshooting

Backend won't start – MongoDB connection refused

Redis connection errors

Emails not sending

Push notifications not working

File uploads fail with 403

WebSocket connection fails

Rate limiting too strict

Common error: "Token expired" after login

Contributing

Development Workflow

Reporting Issues

License

Code of Conduct

Acknowledgments

About

Topics

Resources

License

Code of conduct

Uh oh!

Stars

Watchers

Backend `.env` (inside `backend/`)

Frontend `.env` (inside `frontend/`)

Backend `.env` (inside `backend/`)

Frontend `.env` (inside `frontend/`)

Docker Compose Root `.env`

Packages