English | Italiano

BugBoard26

Software Engineering course project — Academic Year 2025/2026

University of Naples Federico II

BugBoard26 is a distributed enterprise platform for bug tracking and collaborative software project management. It provides a robust architecture for issue reporting, development team management and monitoring of the software lifecycle.

---

Team

Student ID	Student
N86005174	Giuseppe Paolo Esposito
N86004987	Virginia Antonia Esposito

---

Features

The project covers the following functionality:

1. Authentication and User Management

• Secure login: stateless authentication based on JWT (JSON Web Token).
• Role management: separate permissions for Administrator and Standard User.
• Registration: account creation with data validation and password hashing.

2. Issue Creation and Management

• Reporting: issue submission with structured fields (Title, Description, Priority).
• Media support: upload and display of attached images (Base64 encoding).
• Types: classification into Bug, Feature, Documentation, Question.
• States: lifecycle management (Todo -> Assigned -> In Progress -> Resolved).

3. Dashboard and Visualization

• Table view: interactive issue list with image previews.
• Advanced filtering: dynamic filters by Status, Priority and Type, with text search.
• Contextual views: separation between "My Issues" (created/assigned) and the global view (for Admins).

4. Archiving (Admin)

• History: admin-only feature to archive resolved issues.
• Audit: archived issues are removed from the operational dashboard but remain available in a dedicated "Archive" section.

---

System Architecture

The application follows a distributed client-server architecture.

Backend (Spring Boot)

The core of the system adopts a strict layered architecture to ensure separation of concerns:

• Controller Layer: exposes the REST APIs and handles request validation (DTOs).
• Service Layer: implements business logic (e.g. assignment rules, team checks).
• Repository Layer (JPA): handles data access on PostgreSQL using Spring Data JPA.

Frontend (Java Swing)

A modern and responsive desktop rich client:

• MVC pattern:
  • Model: DTOs and services for data handling and HTTP communication.
  • View: graphical interfaces built with Swing, FlatLaf (modern look) and MigLayout. Views are passive components.
  • Controller: handles presentation logic, coordinates flows and asynchronous service calls.
• Async UI: network operations run on separate threads to keep the interface responsive.

---

Tech Stack

Backend

• Java 21+
• Spring Boot 3 (Web, Security, Data JPA)
• PostgreSQL (relational database)
• Hibernate (ORM)
• Lombok (boilerplate reduction)

Frontend

• Java Swing (GUI toolkit)
• FlatLaf (look and feel)
• MigLayout (layout manager)
• SwingX (extended components)
• Jackson (JSON processing)

DevOps & Tools

• Maven (dependency management)
• Docker (containerization)
• GitHub Actions + SonarQube (CI and static analysis)

---

Getting Started

0. Clone the repository

git clone https://github.com/kiyx/bugboard26.git
cd bugboard26

1. Database setup

Make sure PostgreSQL is running, then import the SQL scripts from Documentazione/Sezione 3/Database/:

• 00_Create.sql
• 01_Popolamento.sql
• 02_Trigger_Functions.sql

Configure the connection in backend/src/main/resources/application.properties. The database password is read from the NEON_PASSWORD environment variable; the JWT secret from the JWT_SECRET environment variable (a development-only fallback is included).

2. Start the backend

cd backend
docker-compose up --build

Alternatively, run it locally with Maven:

cd backend
./mvnw spring-boot:run

3. Start the frontend

cd frontend
mvn clean compile exec:java

---

Project Structure

bugboard26/
├── backend/
│   ├── src/main/java/dev/parthenodevs/bugboard/backend/
│   │   ├── config/        # security configuration and JWT filter
│   │   ├── controller/    # REST endpoints
│   │   ├── service/       # business logic
│   │   ├── repository/    # Spring Data JPA repositories
│   │   ├── model/         # JPA entities
│   │   ├── dto/           # request/response DTOs and enums
│   │   ├── mapper/        # entity <-> DTO mapping
│   │   └── exception/     # error handling
│   ├── src/test/          # JUnit tests
│   ├── Dockerfile
│   └── docker-compose.yml
├── frontend/
│   └── src/main/java/
│       ├── view/          # Swing views and dialogs
│       ├── controller/    # presentation controllers
│       ├── service/       # HTTP clients
│       ├── model/dto/     # shared DTOs and enums
│       └── utils/         # helpers
├── Documentazione/        # SRS, design docs, UML diagrams, database scripts
└── .github/workflows/     # SonarQube CI workflow

---

Testing and CI

• JUnit tests for the service layer:

cd backend
./mvnw test

• The GitHub Actions workflow (.github/workflows/build.yml) builds the backend and runs the SonarQube analysis on every push or pull request to main.

---

Documentation

The Documentazione/ folder contains the project deliverables: requirements specification (SRS), design document, architecture and UML diagrams, database model and SQL scripts.

---

License

Released under the MIT License — see LICENSE.

Copyright (c) 2025 Giuseppe Paolo Esposito and Virginia Antonia Esposito.