🎫 Tickify — Event Ticket System

Fast, secure, and scalable platform to create events, sell tickets, and validate entry.

🧭 Table of Contents

Overview
Goals
Architecture
Tech Stack
Main Features
System Flows
Database Schema
API Endpoints
Project Structure
Setup & Installation
Configuration
Testing
Security
Monitoring & Performance
Frontend Options
Roadmap
Contributing
License
Example Flow

🎯 Overview

Tickify is a modern event management and ticketing system built with ASP.NET Core (C#) and SQL Server. It empowers event organizers to publish and manage events while giving users a fast and intuitive booking experience.

🎟️ From event creation → ticket sales → QR check-in — all in one system.

🧩 System Goals

⚡ Frictionless Checkout: Simple, fast, and responsive ticket buying experience.
🧠 Smart Management: Organizers can manage events, tickets, and promotions easily.
🔒 Secure & Reliable: Prevent double-booking and overselling with transactional safety.
📊 Scalable: Clean modular architecture to support future features and integrations.
🔍 Transparent: Clear order history, fees, and refund policies.

🏗️ Architecture Overview

Frontend (Next.js / React SPA)
│
│  HTTPS REST API Calls
▼
Backend (ASP.NET Core 8 Web API)
├── Controllers → Routes
├── Services → Business Logic
├── EF Core → SQL Server
└── Auth → JWT + ASP.NET Identity

Database: SQL Server 2019+
(Phase 2) Redis → seat lock, rate limiting

Layered Design:

Controllers: REST endpoints.
Services: Business rules (pricing, inventory, payments).
Data: EF Core ORM & migrations.
Infrastructure: Payment, email, and storage adapters.

⚙️ Tech Stack

Layer	Technology
Backend	ASP.NET Core 8, C#, EF Core
Database	Microsoft SQL Server
Frontend	Next.js / React + TailwindCSS + shadcn/ui
Auth	JWT + ASP.NET Identity
Payments	Stripe API (modular)
Docs	Swagger / OpenAPI 3.1
DevOps	Docker + GitHub Actions

🔑 Main Features

👥 Roles

Buyer: Browse, purchase, and view tickets.
Organizer: Create and manage events, pricing, and promotions.
Door Staff: Validate QR codes and manage entry (Phase 2).
Admin: Manage users, roles, and audit logs.

🛒 Buyer Experience

Explore events with smart filters (date, city, category).
Transparent pricing and fee breakdown.
Instant confirmation & downloadable ticket (QR/PDF).
Order history and e-wallet integration (Phase 2).

🏢 Organizer Tools

Event creation wizard (title → tickets → policies → publish).
Ticket type management (GA, VIP, Sectioned).
Dashboard with analytics (sales, attendees, revenue).
Promotion codes & early-bird pricing.

⚙️ Admin Features

User & event moderation.
System-level reports and metrics.
Role-based access control.

🔄 System Flows

🛍️ Checkout Flow

User selects tickets.
System locks inventory (TTL ~10min).
Create pending order + Stripe payment intent.
Payment success → confirm webhook → mint QR tickets.
Order marked paid → email confirmation.

🎫 Ticket Validation Flow

QR scanned → API verifies validity.
active → mark as used.
Response: valid | used | invalid.

📅 Event Creation Flow

Organizer inputs details.
Adds schedule, ticket tiers, and refund rules.
Preview → Publish → Goes live.

🧠 Database Schema (Core)

Users(id, email, password_hash, role, status, created_at)
Organizers(id, user_id, legal_name, kyc_status)
Venues(id, name, address, city, country, capacity)
Events(id, organizer_id, venue_id, slug, title, starts_at, ends_at, status)
TicketTypes(id, event_id, name, price_cents, capacity, sales_start, sales_end)
Inventory(id, event_id, ticket_type_id, status, lock_expires_at)
Orders(id, user_id, event_id, status, total_cents, currency)
OrderItems(id, order_id, ticket_type_id, quantity, price_cents)
Tickets(id, order_item_id, qr_payload, status, used_at)
Promotions(id, event_id, code, type, value, max_uses, used)
AuditLogs(id, actor_id, action, target_type, metadata_json, created_at)

📡 API Endpoints

Category	Endpoint	Description
Public	`GET /events`	Browse events
	`GET /events/{id}`	Event details
	`GET /events/{id}/ticket-types`	Ticket list
	`POST /cart`	Create/update cart
	`POST /inventory/lock`	Reserve tickets
	`POST /checkout/start`	Begin checkout
	`POST /checkout/webhook/stripe`	Stripe webhook
	`GET /me/orders`	View user orders
Organizer	`POST /organizers/events`	Create draft event
	`PUT /organizers/events/{id}`	Update event
	`POST /organizers/events/{id}/publish`	Publish event
	`GET /organizers/events/{id}/orders`	Sales data
Admin	`GET /admin/users`	Manage users
	`GET /admin/audit-logs`	View logs

🧱 Project Structure

Tickify/
├── src/
│   ├── Tickify.Api/              # ASP.NET Core Backend
│   │   ├── Controllers/
│   │   ├── Data/ (DbContext, Entities)
│   │   ├── Dtos/
│   │   ├── Services/
│   │   ├── Infrastructure/ (Payments, QR, Email)
│   │   └── Program.cs
│   ├── Tickify.Frontend/         # Next.js / React frontend
│   └── Tickify.Tests/            # Unit & integration tests
├── docs/
├── docker-compose.yml
└── .github/workflows/ci.yml

⚙️ Setup & Installation

🧰 Requirements

.NET 8 SDK
SQL Server 2019+
Node.js 20+ (if using frontend)

🚀 Backend Setup

cd src/Tickify.Api
dotnet restore
dotnet ef database update
dotnet run

API: https://localhost:5001/swagger

💻 Frontend Setup

cd src/Tickify.Frontend
npm install
npm run dev

Frontend: http://localhost:3000

⚙️ Configuration (appsettings.json)

{
  "ConnectionStrings": {
    "Default": "Server=localhost;Database=Tickify;Trusted_Connection=True;TrustServerCertificate=True"
  },
  "Jwt": {
    "SigningKey": "CHANGE_THIS_SECRET_KEY"
  },
  "Stripe": {
    "PublishableKey": "pk_test_...",
    "SecretKey": "sk_test_...",
    "WebhookSecret": "whsec_..."
  }
}

🧪 Testing

cd src/Tickify.Tests
dotnet test

✅ Unit: pricing, inventory, promotions. ✅ Integration: checkout & webhooks. ✅ E2E (optional): Playwright for full buyer flow.

🔐 Security

HTTPS enforced (HSTS).
JWT tokens (access + refresh).
Role-based access (Buyer, Organizer, Admin).
Inventory locking to prevent overselling.
Input validation via FluentValidation.
Encrypted secrets and audit logging.

📈 Monitoring & Performance

Logging via Serilog.
Metrics via OpenTelemetry (Prometheus).
Query profiling with EF Core logs.
CDN + caching for static assets (frontend).

💡 Frontend Options

Next.js

Server-side rendering for SEO.
Tailwind + shadcn/ui design system.
React Query for caching.

🧭 Roadmap

Phase 1 (MVP)

Event management, checkout, payments, QR generation.
Organizer dashboard.

Phase 2

Reserved seating map.
Ticket transfer & resale.
Box office & offline validation.
Advanced analytics + payouts.

🤝 Contributing

Fork repo & clone locally.
Create feature branch:
```
git checkout -b feature/new-feature
```

Commit and push:

git commit -m "Add new feature"
git push origin feature/new-feature

Create Pull Request.

📜 License

Licensed under the MIT License — use freely for personal or commercial purposes.

🧠 Appendix — Example Checkout Flow

User → Web: select 2 tickets
Web → API(/inventory/lock): lock tickets
Web → API(/cart): price breakdown
Web → API(/checkout/start): create order + payment intent
Stripe → API(webhook): payment_succeeded
API → allocate tickets + send confirmation
User → Web: shows confirmation + QR code

🚀 Built with ❤️ by the Tickify Team

Name		Name	Last commit message	Last commit date
Latest commit History 4 Commits
src		src
.gitignore		.gitignore
README.md		README.md

gwould/Tickify

Folders and files

Latest commit

History

Repository files navigation