How avishka07/e-sport-management-system works
Project Type & Purpose
• The project is a full-stack application for an e-sports management system that provides personalized game recommendations.
• The README emphasizes data-driven matchmaking powered by relationship analysis with Neo4j, alongside a classic Flask/React full-stack implementation using PostgreSQL for core data management.
File Structure Analysis
• There are clearly separated directories for frontend, backend, and an additional recommendation module.
• The “backend” folder contains the Flask application code organized into app components (routes, models, recommendation logic, and utilities), along with migrations and Kubernetes deployment descriptors.
• The “frontend” folder holds the React application, using Tailwind CSS for styling, with a robust component structure.
• There are Dockerfiles for containerization and Kubernetes YAML files in the backend, indicating infrastructure/deployment considerations.
• The standalone “recommendation” folder mirrors parts of the backend’s recommendation logic and could represent a dedicated microservice or a module that is central to the project.
Key Architectural Components
a. Frontend:
• React application (React, Tailwind CSS).
• Components like AdminNavbar, EventCard, SignIn/SignUp, etc.
• State management (store) indicating a client-side architecture that interacts with backend APIs.
b. Backend:
• Flask-based API server managing business logic and API endpoints.
• Organized routes (admin_routes, event_routes, recommendation_routes, user_routes) indicating clear separation of concerns.
• Modular recommendation engine included in backend/app/recommendation – this handles player matching, filtering, and Neo4j connections.
• Utility modules for database interaction (both PostgreSQL and Neo4j).
• Dockerization indicated by the presence of Dockerfiles and Kubernetes configuration files for different services such as user management, recommendation, tournament management, and notification services.
c. Databases:
• PostgreSQL is used as the core relational database.
• Neo4j for handling graph-based relationships essential to the recommendation engine.
d. Additional Infrastructure:
• Container orchestration using Docker and Kubernetes.
• Continuous integration workflows via GitHub (see .github/workflows directory).
Relationships & Interactions
• The Frontend (React) communicates with the Backend (Flask) via API calls.
• The Backend serves as the mediator between the frontend and the databases:
– It reads/writes to the PostgreSQL database for core data management.
– It leverages Neo4j, accessed via specialized modules, to perform complex graph queries for recommendation services.
• The recommendation modules within the backend may also be separately accessed or even scaled independently (as suggested by the separate recommendation directory and dedicated Kubernetes deployments).
• Docker containers encapsulate each major service, and Kubernetes deployments manage scaling and orchestration.
Architectural Patterns & Technologies
• Separation of concerns: clear modularization of frontend, backend, and recommendation logic.
• Microservices/Containerization: Use of Docker and Kubernetes (separate deployment YAML files for different services).
• MVC-like structure in backend: Routes/controllers, Models (both SQL and Neo4j-based), and Business logic (recommendation algorithms).
• API-based communication: RESTful endpoints provided by Flask are accessed by the React frontend.
• Data-driven processing: Integration of data from PostgreSQL and Neo4j to guide recommendation decisions.