Go to file
Gustavo Henrique Santos Souza de Miranda e51d5aa678 Add bidirectional Genre relationship to Album entity
This commit extends the Album entity with bidirectional relationship
  management for the AlbumHasGenre join table, enabling many-to-many
  associations between albums and genres with convenient helper methods.

  Key enhancements:

  Relationship Mapping:
  - Added OneToMany relationship from Album to AlbumHasGenre
    * Bidirectional mapping with cascade ALL and orphan removal
    * Maintains collection of album-genre associations
    * Initialized as ArrayList to prevent null pointer exceptions
    * Follows the same pattern as albumArtists relationship

  Helper Methods for Genre Management:
  - addGenre(Genre genre):
    * Creates AlbumHasGenre join table entry
    * Sets bidirectional references to Album and Genre
    * Adds association to albumGenres collection
    * Simplifies adding genres to albums programmatically

  - removeGenre(Genre genre):
    * Removes association by comparing genre IDs
    * Safely handles null checks
    * Uses removeIf for clean collection manipulation
    * Maintains referential integrity

  - getGenres():
    * Convenience method to extract Genre list from join table
    * Uses Java streams for clean transformation
    * Maps AlbumHasGenre → Genre
    * Returns List<Genre> for easy consumption

  Collection Management:
  - Added getAlbumGenres() getter
    * Returns full List<AlbumHasGenre> for direct access
    * Useful for repository-level operations

  - Added setAlbumGenres() setter
    * Allows bulk replacement of genre associations
    * Required by JPA for entity hydration

  Benefits:
  - Enables navigating from Album to associated Genres
  - Simplifies genre association management in service layer
  - Cascade operations ensure join table entries are managed automatically
  - Orphan removal prevents orphaned join table entries
  - Consistent API with existing Artist relationship methods
  - Type-safe genre management through helper methods

  Pattern Consistency:
  This implementation mirrors the albumArtists relationship structure,
  providing a consistent API for managing both artist and genre associations
  on the Album entity. Both relationships use the same cascade and orphan
  removal strategies for reliable data integrity.

  🤖 Generated with [Claude Code](https://claude.com/claude-code)

  Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

  This commit message is ready to use in IntelliJ for the Album.java changes!
2025-12-07 23:31:07 -03:00
src/main Add bidirectional Genre relationship to Album entity 2025-12-07 23:31:07 -03:00
.gitignore Register AlbumArtService with service locator and update gitignore 2025-12-07 02:17:29 -03:00
COPYING Add GPLv3 license to project: included `COPYING` file with full license text. 2025-11-13 02:28:26 -03:00
README.md Replace `application.properties` with `config.properties`: 2025-11-13 03:25:33 -03:00
pom.xml Remove `Media` entity and integrate Hibernate ORM into `DatabaseManager`: 2025-11-27 18:40:08 -03:00

README.md

MediaManager Core

A Java-based media management system that uses IPC (Inter-Process Communication) with named pipes and PostgreSQL for data persistence.

Features

  • IPC communication using named pipes
  • PostgreSQL database integration
  • JPA/Hibernate for ORM
  • Log4j 2 for logging
  • HikariCP connection pooling
  • Sample Media entity model

Prerequisites

  • Java 17 or higher
  • Maven 3.6+
  • PostgreSQL 12 or higher

Project Structure

MediaManager-Core/
├── src/
│   └── main/
│       ├── java/
│       │   └── com/
│       │       └── mediamanager/
│       │           ├── config/          # Configuration classes
│       │           ├── model/           # JPA entities
│       │           ├── repository/      # Data access layer
│       │           ├── service/         # Business logic
│       │           ├── ipc/            # IPC implementation
│       │           ├── util/           # Utility classes
│       │           └── MediaManagerApplication.java
│       └── resources/
│           ├── config.properties       # App configuration
│           ├── log4j2.xml              # Logging configuration
│           └── META-INF/
│               └── persistence.xml     # JPA configuration
└── pom.xml

Setup

1. Database Setup

Create a PostgreSQL database and user:

CREATE DATABASE mediamanager;
CREATE USER mediamanager WITH PASSWORD 'changeme';
GRANT ALL PRIVILEGES ON DATABASE mediamanager TO mediamanager;

2. Configuration

Edit src/main/resources/config.properties and update the database credentials:

db.url=jdbc:postgresql://localhost:5432/mediamanager
db.username=mediamanager
db.password=your_password_here

3. Build the Project

mvn clean install

4. Run the Application

mvn exec:java -Dexec.mainClass="com.mediamanager.MediaManagerApplication"

Or build and run the JAR:

mvn clean package
java -jar target/MediaManager-Core-0.0.1-SNAPSHOT.jar

IPC Configuration

The application creates named pipes for inter-process communication. Default configuration:

  • Pipe path: /tmp/mediamanager
  • Pipe name: mediamanager-pipe
  • Buffer size: 8192 bytes

You can modify these settings in config.properties.

Logging

Logs are written to:

  • Console (STDOUT)
  • logs/mediamanager.log (rotating daily, max 10MB per file)

Log configuration can be modified in src/main/resources/log4j2.xml.

Development

Adding New Entities

  1. Create entity class in com.mediamanager.model
  2. Add the entity class to persistence.xml
  3. Create corresponding repository and service classes

Running Tests

mvn test

Dependencies

  • PostgreSQL Driver: 42.7.5
  • Hibernate ORM: 7.1.7.Final
  • HikariCP: 5.1.0
  • Log4j 2: 2.23.1
  • Jackson: 2.16.1
  • JUnit 5: 5.10.2

License

TBD

TODO

  • Implement IPC server with named pipes
  • Implement database connection manager
  • Create repository layer
  • Create service layer
  • Add comprehensive tests
  • Add API documentation