Uevent

Uevent is a full-stack event platform for discovering events, following organizers, buying tickets, receiving notifications, and managing organizer workflows.

It was built as a university project, but the product flow is designed closer to a real event platform than a simple CRUD demo:

event discovery with filters and search
organizer profiles and event management
Stripe checkout and refunds
QR ticket generation
email notifications and Mailhog testing
attendee visibility settings
seat-based events with seat selection and seat locking
moderation flows for organizer access and event approval

Tech Stack

Frontend

React
Vite
TypeScript
Tailwind CSS

Backend

NestJS
TypeORM
PostgreSQL
Swagger

Infrastructure / Integrations

Docker / Docker Compose
Stripe
Mailhog
pgAdmin

Main Features

User Features

Register, log in, and verify email
Browse upcoming events
Search, filter, and sort event lists
View event details, organizer info, comments, map, and related events
Follow events and organizers
Buy tickets with Stripe
Receive email confirmation and issued tickets with QR codes
Manage orders, tickets, and notifications
Control whether the user's name is visible in attendee lists

Organizer Features

Request organizer access
Manage company profile
Create and edit events
Upload event posters
Configure attendee list visibility
Configure redirect URL after purchase
Create promo codes
Receive order-related notifications
Use reserved seating layouts with zones and seat maps

Admin / Moderation Features

Review organizer applications
Review event changes
Suspend / restore flows
Audit actions through admin logs

Ticketing Features

General admission events
Reserved seating events
Seat map editor with:
- aisles
- place objects such as stage / field areas
- zones
- custom row / column naming
- sequential seat numbering
Seat locking during checkout
Re-seat flow when an organizer changes seating after tickets were sold

Screenshots

Home Page

Event Details

Checkout

User Account

Organizer Dashboard

Admin Dashboard

Organizer Event Editor

Seat Map Editor

Re-seat Flow

Email Preview

Project Structure

apps/
  backend/
    src/
      common/
      database/
      modules/
        admin/
        auth/
        companies/
        events/
        mail/
        orders/
        organizer-applications/
        tickets/
        user-notifications/
        users/
  frontend/

Architecture Overview

Core Domain

users
companies
events
orders
tickets

Engagement Domain

comments
event_follows
company_follows
user_notifications

Organizer / Admin Domain

organizer_applications
organizer_application_documents
admin_audit_logs
user_tokens

Getting Started

1. Copy environment files

Create the root environment file:

cp .env.example .env

Optional backend example values are available in:

apps/backend/.env.example

2. Start the project with Docker

docker compose up --build

This starts:

PostgreSQL
pgAdmin
Mailhog
NestJS backend
React frontend

3. Open the project

Frontend: http://localhost:5173
Backend API: http://localhost:3000
Swagger: http://localhost:3000/api/docs
Health check: http://localhost:3000/health
Mailhog UI: http://localhost:8025
pgAdmin: http://localhost:5050

Docker Services

docker-compose.yml runs the following containers:

uevent-postgres
uevent-pgadmin
uevent-mailhog
uevent-backend
uevent-frontend

Why PostgreSQL in Docker:

easy local setup
stable shared environment
no manual local DB installation
persistent volume through pgdata

Local Development Without Docker

Backend

cd apps/backend
npm install
npm run build
npm run seed
npm run start:dev

Frontend

cd apps/frontend
npm install
npm run dev

You still need PostgreSQL and Mailhog running locally, or you can keep using them through Docker.

Environment Variables

Example backend values:

PORT=3000
CORS_ORIGIN=http://localhost:5173

DATABASE_HOST=postgres
DATABASE_PORT=5432
DATABASE_NAME=uevent
DATABASE_USER=uevent
DATABASE_PASSWORD=uevent

SMTP_HOST=mailhog
SMTP_PORT=1025
SMTP_FROM=uevent@local.test

JWT_SECRET=super_secret_key_change_me
JWT_EXPIRES_IN=7d
CLIENT_URL=http://localhost:5173

STRIPE_SECRET_KEY=sk_test_...
STRIPE_WEBHOOK_SECRET=whsec_...
STRIPE_SUCCESS_URL=http://localhost:5173/payment/success?session_id={CHECKOUT_SESSION_ID}
STRIPE_CANCEL_URL=http://localhost:5173/payment/cancel
FRONTEND_URL=http://localhost:5173

Demo Accounts

Seeded demo accounts from seed.ts:

Admin

admin@test.com / password123

Organizers

organizer.valencia@test.com / password123
organizer.madrid@test.com / password123
organizer.barcelona@test.com / password123

User

user@test.com / password123

Unverified user

unverified@test.com / password123

Seeded Demo Data

The seed includes:

multiple organizer companies
events in Spain, Germany, UK, Belgium, Switzerland, Japan, and USA
categories such as technology, business, art, politics, psychology, and science
formats such as conference, workshop, lecture, and fest
promo codes for selected events

API Documentation

Swagger is available at:

http://localhost:3000/api/docs

Useful areas to explore:

auth
events
orders
tickets
companies
organizer applications
notifications

Payment Flow

User opens an event page.
User selects quantity or seats.
Backend creates a pending order.
Stripe Checkout session is created.
Selected seats are temporarily locked.
Stripe confirms payment through webhook flow.
Order becomes paid.
Tickets are issued.
User receives confirmation email and ticket email.

Stripe Test Card

4242 4242 4242 4242

Use:

any future expiry date
any CVC
any postal code

Email Testing

Mailhog is used in development for:

email verification
password reset
payment confirmation
issued tickets
refund emails
event change notifications

Open Mailhog at:

http://localhost:8025

Ticket and QR Flow

Each issued ticket contains:

ticket holder name
QR hash
seat information if the event is seated
zone information when applicable

QR links are generated on the backend and embedded into the issued ticket email.

Seat Map Logic

Reserved seating uses a JSON-based seat map because layouts are flexible and may include:

non-rectangular rows
aisles / gaps
zones
place objects
custom numbering

This keeps seat layout editing practical while still allowing orders and tickets to store immutable seat snapshots.

Demo Walkthrough

Recommended demo path:

Start the app with Docker.
Show the event list on the home page.
Demonstrate search / filter / sorting.
Open an event details page.
Show comments, attendees, organizer info, map, and related events.
Log in as a seeded user.
Follow an organizer and an event.
Buy a ticket through Stripe test mode.
Show the generated email in Mailhog.
Open the account page and show orders, tickets, and notifications.
Log in as organizer and show event creation / management.
Show the seat editor for reserved seating events.

Important Design Decisions

Why `seat_map` is JSON

Because the editor supports flexible geometries, aisles, place objects, zones, and custom numbering. This is configuration data rather than classic relational transactional data.

Why `orders` is relatively rich

Orders are the center of the ticketing lifecycle, not just payment records. They also track refund protection, disruption handling, attendee decision states, ticket holders, and selected seats.

Why `tickets` duplicate some order / seat data

Tickets act as immutable snapshots after purchase. This makes QR validation, email delivery, and ticket display stable even if the event data changes later.

Database Notes

Development currently uses TypeORM entity sync / entity-driven schema flow.
PostgreSQL is the main relational database.
DBML files are included for visualization in dbdiagram.

Future Improvements

Redis for reservation / lock optimization
push notifications
analytics dashboard
richer organizer moderation UI
seat sector presets for stadium layouts
production storage for media uploads
stronger audit history for ticket usage and order status changes

Stack:

NestJS
React
PostgreSQL
Stripe
Docker

Name		Name	Last commit message	Last commit date
apps		apps
docs/screenshots		docs/screenshots
.env.example		.env.example
.gitignore		.gitignore
README.md		README.md
docker-compose.yml		docker-compose.yml

Latest commit

History

Folders and files

Repository files navigation

Uevent

Tech Stack

Frontend

Backend

Infrastructure / Integrations

Main Features

User Features

Organizer Features

Admin / Moderation Features

Ticketing Features

Screenshots

Home Page

Event Details

Checkout

User Account

Organizer Dashboard

Admin Dashboard

Organizer Event Editor

Seat Map Editor

Re-seat Flow

Email Preview

Project Structure

Architecture Overview

Core Domain

Engagement Domain

Organizer / Admin Domain

Getting Started

1. Copy environment files

2. Start the project with Docker

3. Open the project

Docker Services

Local Development Without Docker

Backend

Frontend

Environment Variables

Demo Accounts

Admin

Organizers

User

Unverified user

Seeded Demo Data

API Documentation

Payment Flow

Stripe Test Card

Email Testing

Ticket and QR Flow

Seat Map Logic

Demo Walkthrough

Important Design Decisions

Why seat_map is JSON

Why orders is relatively rich

Why tickets duplicate some order / seat data

Database Notes

Future Improvements

About

Resources

Stars

Watchers

Forks

Releases

Packages

Contributors

Languages

Why `seat_map` is JSON

Why `orders` is relatively rich

Why `tickets` duplicate some order / seat data