Merge ba3e1eb19a into 86da601ad6

.gitignore

@@ -39,8 +39,18 @@ build/
 .DS_Store
 
 ### Application Specific ###
-application-local.properties
+config-local.properties
 *.db
 pipes/
 *.log
 /.idea/
+
+ Configuration files with sensitive credentials
+# These files contain database passwords and API keys and should never be committed
+src/main/resources/config.properties
+src/main/resources/application.properties
+
+# Allow example configuration files to be committed
+!src/main/resources/*.properties.example
+src/scripts/*
+local-repo/

README.md

@@ -34,7 +34,7 @@ MediaManager-Core/
 │       │           ├── util/           # Utility classes
 │       │           └── MediaManagerApplication.java
 │       └── resources/
-│           ├── application.properties   # App configuration
+│           ├── config.properties       # App configuration
 │           ├── log4j2.xml              # Logging configuration
 │           └── META-INF/
 │               └── persistence.xml     # JPA configuration
@@ -55,7 +55,7 @@ GRANT ALL PRIVILEGES ON DATABASE mediamanager TO mediamanager;
 
 ### 2. Configuration
 
-Edit `src/main/resources/application.properties` and update the database credentials:
+Edit `src/main/resources/config.properties` and update the database credentials:
 
 ```properties
 db.url=jdbc:postgresql://localhost:5432/mediamanager
@@ -90,7 +90,7 @@ The application creates named pipes for inter-process communication. Default con
 - Pipe name: `mediamanager-pipe`
 - Buffer size: 8192 bytes
 
-You can modify these settings in `application.properties`.
+You can modify these settings in `config.properties`.
 
 ## Logging
 
@@ -116,8 +116,8 @@ mvn test
 
 ## Dependencies
 
-- PostgreSQL Driver: 42.7.3
+- PostgreSQL Driver: 42.7.5
-- Hibernate ORM: 6.4.4.Final
+- Hibernate ORM: 7.1.7.Final
 - HikariCP: 5.1.0
 - Log4j 2: 2.23.1
 - Jackson: 2.16.1

pom.xml

@@ -13,7 +13,7 @@
         <maven.compiler.target>17</maven.compiler.target>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
         <hibernate.version>7.1.7.Final</hibernate.version>
-        <postgresql.version>42.7.5</postgresql.version>
+        <postgresql.version>42.7.7</postgresql.version>
         <hikaricp.version>5.1.0</hikaricp.version>
         <log4j.version>2.23.1</log4j.version>
         <junit.version>5.10.2</junit.version>
@@ -35,6 +35,12 @@
             <version>${hibernate.version}</version>
         </dependency>
 
+        <dependency>
+            <groupId>org.hibernate.orm</groupId>
+            <artifactId>hibernate-community-dialects</artifactId>
+            <version>${hibernate.version}</version>
+        </dependency>
+
         <!-- HikariCP for connection pooling -->
         <dependency>
             <groupId>com.zaxxer</groupId>
@@ -55,7 +61,7 @@
         </dependency>
         <dependency>
             <groupId>org.apache.logging.log4j</groupId>
-            <artifactId>log4j-slf4j2-impl</artifactId>
+            <artifactId>log4j-slf4j-impl</artifactId>
             <version>${log4j.version}</version>
         </dependency>
 
@@ -78,9 +84,32 @@
             <version>${junit.version}</version>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>com.google.protobuf</groupId>
+            <artifactId>protobuf-java</artifactId>
+            <version>4.32.0</version>
+        </dependency>
+        <dependency>
+            <groupId>org.xerial</groupId>
+            <artifactId>sqlite-jdbc</artifactId>
+            <version>3.44.1.0</version>
+        </dependency>
+        <dependency>
+            <groupId>org.reflections</groupId>
+            <artifactId>reflections</artifactId>
+            <version>0.10.2</version>
+        </dependency>
     </dependencies>
 
     <build>
+        <extensions>
+            <extension>
+                <groupId>kr.motd.maven</groupId>
+                <artifactId>os-maven-plugin</artifactId>
+                <version>1.7.1</version>
+            </extension>
+        </extensions>
+
         <plugins>
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
@@ -91,11 +120,75 @@
                     <target>17</target>
                 </configuration>
             </plugin>
+
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-surefire-plugin</artifactId>
                 <version>3.2.5</version>
             </plugin>
+
+            <!-- Protocol Buffers Plugin -->
+            <plugin>
+                <groupId>org.xolstice.maven.plugins</groupId>
+                <artifactId>protobuf-maven-plugin</artifactId>
+                <version>0.6.1</version>
+                <configuration>
+                    <protocExecutable>/usr/bin/protoc</protocExecutable>
+                    <protoSourceRoot>${project.basedir}/src/main/proto</protoSourceRoot>
+                    <outputDirectory>${project.build.directory}/generated-sources/protobuf/java</outputDirectory>
+                    <clearOutputDirectory>false</clearOutputDirectory>
+                </configuration>
+                <executions>
+                    <execution>
+                        <goals>
+                            <goal>compile</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+
+            <!-- Build Helper Plugin - Adiciona generated sources ao classpath -->
+            <plugin>
+                <groupId>org.codehaus.mojo</groupId>
+                <artifactId>build-helper-maven-plugin</artifactId>
+                <version>3.5.0</version>
+                <executions>
+                    <execution>
+                        <id>add-source</id>
+                        <phase>generate-sources</phase>
+                        <goals>
+                            <goal>add-source</goal>
+                        </goals>
+                        <configuration>
+                            <sources>
+                                <source>${project.build.directory}/generated-sources/protobuf/java</source>
+                            </sources>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+
+            <!-- Maven Shade Plugin - Creates executable JAR with all dependencies -->
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-shade-plugin</artifactId>
+                <version>3.5.1</version>
+                <executions>
+                    <execution>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>shade</goal>
+                        </goals>
+                        <configuration>
+                            <transformers>
+                                <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
+                                    <mainClass>com.mediamanager.MediaManagerApplication</mainClass>
+                                </transformer>
+                            </transformers>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
         </plugins>
     </build>
 

src/main/java/com/mediamanager/MediaManagerApplication.java

@@ -1,5 +1,8 @@
 package com.mediamanager;
 
+import com.mediamanager.service.database.DatabaseManager;
+import com.mediamanager.service.delegate.DelegateActionManager;
+import com.mediamanager.service.ipc.IPCManager;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
@@ -7,9 +10,25 @@ import java.io.IOException;
 import java.io.InputStream;
 import java.util.Properties;
 
+import com.mediamanager.service.database.SqliteDatabaseManager;
+
 public class MediaManagerApplication {
     private static final Logger logger = LogManager.getLogger(MediaManagerApplication.class);
     private static Properties config;
+    private static DatabaseManager databaseManager;
+    private static DelegateActionManager actionManager;
+    private static IPCManager ipcManager;
+
+    public enum ApplicationMode {
+        LOCAL("local"),
+        SERVER("server");
+
+        private final String value;
+
+        ApplicationMode(String value) {
+            this.value = value;
+        }
+    }
 
     public static void main(String[] args) {
         logger.info("Starting MediaManager Core Application...");
@@ -17,19 +36,85 @@ public class MediaManagerApplication {
         try {
             // Load configuration
             loadConfiguration();
+            String runTypeString = config.getProperty("runtype","local");
+            ApplicationMode mode = null;
+
+            for (ApplicationMode am : ApplicationMode.values()) {
+                if (am.value.equalsIgnoreCase(runTypeString)) {
+                    mode = am;
+                    break;
+                }
+            }
+            if (mode == null) {
+                logger.error("Invalid run type: {}", runTypeString);
+                throw new Exception("Invalid run type: " + runTypeString);
+            }
+            logger.info("Run type: {}", mode);
+            switch (mode) {
+                case LOCAL:
+                    logger.info("Starting local database...");
+                    databaseManager = new SqliteDatabaseManager(config);
+                    break;
+                case SERVER:
+                    throw new Exception("Server mode not yet implemented");
+                default:
+            }
+            databaseManager.init();
+            actionManager = new DelegateActionManager(databaseManager.getEntityManagerFactory());
+            actionManager.start();
+            ipcManager = new IPCManager(config,actionManager);
+            ipcManager.init();
 
-            // TODO: Initialize database connection
-            // TODO: Initialize IPC server with named pipes
             // TODO: Start application services
 
             logger.info("MediaManager Core started successfully");
-            logger.info("IPC Pipe: {}", config.getProperty("ipc.pipe.path") + "/" + config.getProperty("ipc.pipe.name"));
+            logger.info("IPC Socket: {}", ipcManager.getSocketPath().toAbsolutePath().toString());
 
             // Keep application running
             Runtime.getRuntime().addShutdownHook(new Thread(() -> {
+
                 logger.info("Shutting down MediaManager Core...");
-                // TODO: Cleanup resources
+
+
+                if (databaseManager != null) {
+                    databaseManager.close();
+                }
+
+                if (ipcManager != null) {
+                    try {
+                        ipcManager.close();
+                    } catch (Exception e) {
+                        throw new RuntimeException(e);
+                    }
+                }
+
+                if (actionManager != null) {
+                    actionManager.stop();
+                }
+
+                logger.info("MediaManager Core shutdown successfully");
+                logger.info("Goodbye!");
+
+
+                // Give Log4j2 time to write all pending messages before shutting down
+                try {
+                    Thread.sleep(1000);
+                } catch (InterruptedException e) {
+                    Thread.currentThread().interrupt();
+                }
+
+                // Now shutdown Log4j2
+                org.apache.logging.log4j.LogManager.shutdown();
             }));
+            logger.info("Application is running");
+            logger.info("Press Ctrl+C to exit");
+            Thread.currentThread().join();
+
+        } catch (InterruptedException e) {
+
+            logger.info("Application interrupted, initiating shutdown...");
+
+            Thread.currentThread().interrupt();
 
         } catch (Exception e) {
             logger.error("Failed to start MediaManager Core", e);
@@ -39,10 +124,9 @@ public class MediaManagerApplication {
 
     private static void loadConfiguration() throws IOException {
         config = new Properties();
-        try (InputStream input = MediaManagerApplication.class.getClassLoader()
+        try (InputStream input = MediaManagerApplication.class.getClassLoader().getResourceAsStream("config.properties")) {
-                .getResourceAsStream("application.properties")) {
             if (input == null) {
-                throw new IOException("Unable to find application.properties");
+                throw new IOException("Unable to find config.properties");
             }
             config.load(input);
             logger.info("Configuration loaded successfully");
@@ -52,4 +136,4 @@ public class MediaManagerApplication {
     public static Properties getConfig() {
         return config;
     }
-}
+}

src/main/java/com/mediamanager/mapper/AlbumArtMapper.java

@@ -0,0 +1,35 @@
+package com.mediamanager.mapper;
+
+import com.mediamanager.model.AlbumArt;
+import com.mediamanager.protocol.messages.AlbumArtMessages;
+
+public class AlbumArtMapper {
+    public static AlbumArtMessages.AlbumArt toProtobuf(AlbumArt entity) {
+        if (entity == null) {
+            return null;
+        }
+        String filepath = entity.getFilepath();
+        if (filepath == null || filepath.isEmpty()) {
+            throw new IllegalArgumentException("Filepath cannot be null or empty");
+        }
+        AlbumArtMessages.AlbumArt.Builder builder = AlbumArtMessages.AlbumArt.newBuilder()
+                .setFilepath(filepath);
+        Integer id = entity.getId();
+        if (id != null) {
+            builder.setId(id);
+        }
+        return builder.build();
+    }
+
+    public static AlbumArt toEntity(AlbumArtMessages.AlbumArt protobuf) {
+        if (protobuf == null) {
+            return null;
+        }
+        AlbumArt entity = new AlbumArt();
+        if (protobuf.getId() >0) {
+            entity.setId(protobuf.getId());
+        }
+        entity.setFilepath(protobuf.getFilepath());
+        return entity;
+    }
+}

src/main/java/com/mediamanager/mapper/AlbumHasArtistMapper.java

@@ -0,0 +1,47 @@
+package com.mediamanager.mapper;
+
+import com.mediamanager.model.AlbumHasArtist;
+import com.mediamanager.protocol.messages.AlbumHasArtistMessages;
+
+public class AlbumHasArtistMapper {
+    public static AlbumHasArtistMessages.AlbumHasArtist toProtobuf(AlbumHasArtist entity) {
+        if (entity == null) {
+            return null;
+        }
+
+        AlbumHasArtistMessages.AlbumHasArtist.Builder builder = AlbumHasArtistMessages.AlbumHasArtist.newBuilder();
+
+        Integer id = entity.getId();
+        if (id != null) {
+            builder.setId(id);
+        }
+
+        // Map Album foreign key
+        if (entity.getAlbum() != null && entity.getAlbum().getId() != null) {
+            builder.setFkAlbumId(entity.getAlbum().getId());
+        }
+
+        // Map Artist foreign key
+        if (entity.getArtist() != null && entity.getArtist().getId() != null) {
+            builder.setFkArtistId(entity.getArtist().getId());
+        }
+
+        return builder.build();
+    }
+
+    public static AlbumHasArtist toEntity(AlbumHasArtistMessages.AlbumHasArtist protobuf) {
+        if (protobuf == null) {
+            return null;
+        }
+
+        AlbumHasArtist entity = new AlbumHasArtist();
+
+        if (protobuf.getId() > 0) {
+            entity.setId(protobuf.getId());
+        }
+
+        // Note: Foreign key relationships (Album, Artist) are handled in the service layer
+
+        return entity;
+    }
+}

src/main/java/com/mediamanager/mapper/AlbumHasGenreMapper.java

@@ -0,0 +1,47 @@
+package com.mediamanager.mapper;
+
+import com.mediamanager.model.AlbumHasGenre;
+import com.mediamanager.protocol.messages.AlbumHasGenreMessages;
+
+public class AlbumHasGenreMapper {
+    public static AlbumHasGenreMessages.AlbumHasGenre toProtobuf(AlbumHasGenre entity) {
+        if (entity == null) {
+            return null;
+        }
+
+        AlbumHasGenreMessages.AlbumHasGenre.Builder builder = AlbumHasGenreMessages.AlbumHasGenre.newBuilder();
+
+        Integer id = entity.getId();
+        if (id != null) {
+            builder.setId(id);
+        }
+
+        // Map Album foreign key
+        if (entity.getAlbum() != null && entity.getAlbum().getId() != null) {
+            builder.setFkAlbumId(entity.getAlbum().getId());
+        }
+
+        // Map Genre foreign key
+        if (entity.getGenre() != null && entity.getGenre().getId() != null) {
+            builder.setFkGenreId(entity.getGenre().getId());
+        }
+
+        return builder.build();
+    }
+
+    public static AlbumHasGenre toEntity(AlbumHasGenreMessages.AlbumHasGenre protobuf) {
+        if (protobuf == null) {
+            return null;
+        }
+
+        AlbumHasGenre entity = new AlbumHasGenre();
+
+        if (protobuf.getId() > 0) {
+            entity.setId(protobuf.getId());
+        }
+
+        // Note: Foreign key relationships (Album, Genre) are handled in the service layer
+
+        return entity;
+    }
+}

src/main/java/com/mediamanager/mapper/AlbumMapper.java

@@ -0,0 +1,110 @@
+package com.mediamanager.mapper;
+
+import com.mediamanager.model.Album;
+import com.mediamanager.protocol.messages.AlbumMessages;
+
+import java.time.Instant;
+import java.time.ZoneId;
+
+public class AlbumMapper {
+    public static AlbumMessages.Album toProtobuf(Album entity) {
+        if (entity == null) {
+            return null;
+        }
+
+        String name = entity.getName();
+        if (name == null || name.isEmpty()) {
+            throw new IllegalArgumentException("Name cannot be null or empty");
+        }
+
+        AlbumMessages.Album.Builder builder = AlbumMessages.Album.newBuilder()
+                .setName(name);
+
+        Integer id = entity.getId();
+        if (id != null) {
+            builder.setId(id);
+        }
+
+        Integer year = entity.getYear();
+        if (year != null) {
+            builder.setYear(year);
+        }
+
+        Integer numberOfDiscs = entity.getNumberOfDiscs();
+        if (numberOfDiscs != null) {
+            builder.setNumberOfDiscs(numberOfDiscs);
+        }
+
+        String code = entity.getCode();
+        if (code != null) {
+            builder.setCode(code);
+        }
+
+        Boolean isCompilation = entity.getIsCompilation();
+        if (isCompilation != null) {
+            builder.setIsCompilation(isCompilation);
+        }
+
+        // Map AlbumType foreign key
+        if (entity.getAlbumType() != null && entity.getAlbumType().getId() != null) {
+            builder.setFkAlbumtypeId(entity.getAlbumType().getId());
+        }
+
+        // Map AlbumArt foreign key
+        if (entity.getAlbumArt() != null && entity.getAlbumArt().getId() != null) {
+            builder.setFkAlbumartId(entity.getAlbumArt().getId());
+        }
+
+        // Map timestamps
+        if (entity.getCreatedAt() != null) {
+            long createdAtEpoch = entity.getCreatedAt()
+                    .atZone(ZoneId.systemDefault())
+                    .toInstant()
+                    .toEpochMilli();
+            builder.setCreatedAt(createdAtEpoch);
+        }
+
+        if (entity.getUpdatedAt() != null) {
+            long updatedAtEpoch = entity.getUpdatedAt()
+                    .atZone(ZoneId.systemDefault())
+                    .toInstant()
+                    .toEpochMilli();
+            builder.setUpdatedAt(updatedAtEpoch);
+        }
+
+        return builder.build();
+    }
+
+    public static Album toEntity(AlbumMessages.Album protobuf) {
+        if (protobuf == null) {
+            return null;
+        }
+
+        Album entity = new Album();
+
+        if (protobuf.getId() > 0) {
+            entity.setId(protobuf.getId());
+        }
+
+        entity.setName(protobuf.getName());
+
+        if (protobuf.getYear() > 0) {
+            entity.setYear(protobuf.getYear());
+        }
+
+        if (protobuf.getNumberOfDiscs() > 0) {
+            entity.setNumberOfDiscs(protobuf.getNumberOfDiscs());
+        }
+
+        if (!protobuf.getCode().isEmpty()) {
+            entity.setCode(protobuf.getCode());
+        }
+
+        entity.setIsCompilation(protobuf.getIsCompilation());
+
+        // Note: Foreign key relationships (AlbumType, AlbumArt) are handled in the service layer
+        // Timestamps are managed by JPA @PrePersist and @PreUpdate
+
+        return entity;
+    }
+}

src/main/java/com/mediamanager/mapper/AlbumTypeMapper.java

@@ -0,0 +1,35 @@
+package com.mediamanager.mapper;
+
+import com.mediamanager.model.AlbumType;
+import com.mediamanager.protocol.messages.AlbumTypeMessages;
+
+public class AlbumTypeMapper {
+    public static AlbumTypeMessages.AlbumType toProtobuf(AlbumType entity) {
+        if (entity == null) {
+            return null;
+        }
+        String value = entity.getValue();
+        if (value == null || value.isEmpty()) {
+            throw new IllegalArgumentException("Value cannot be null or empty");
+        }
+        AlbumTypeMessages.AlbumType.Builder builder = AlbumTypeMessages.AlbumType.newBuilder()
+                .setValue(value);
+        Integer id = entity.getId();
+        if (id != null) {
+            builder.setId(id);
+        }
+        return builder.build();
+    }
+
+    public static AlbumType toEntity(AlbumTypeMessages.AlbumType protobuf) {
+        if (protobuf == null) {
+            return null;
+        }
+        AlbumType entity = new AlbumType();
+        if (protobuf.getId() >0) {
+            entity.setId(protobuf.getId());
+        }
+        entity.setValue(protobuf.getValue());
+        return entity;
+    }
+}

src/main/java/com/mediamanager/mapper/ArtistMapper.java

@@ -0,0 +1,41 @@
+package com.mediamanager.mapper;
+
+import com.mediamanager.model.Artist;
+import com.mediamanager.protocol.messages.ArtistMessages;
+
+
+public class ArtistMapper {
+    public static ArtistMessages.Artist toProtobuf(Artist entity){
+        if (entity == null) {
+            return null;
+        }
+
+        String name = entity.getName();
+        if (name == null) {
+            throw new IllegalArgumentException("Artist name cannot be null");
+        }
+
+        ArtistMessages.Artist.Builder builder = ArtistMessages.Artist.newBuilder()
+                .setName(name);
+
+        // Only set ID when it's present and valid (> 0). Avoids NPE for null IDs.
+        Integer id = entity.getId();
+        if (id != null && id > 0) {
+            builder.setId(id);
+        }
+
+        return builder.build();
+    }
+    public static Artist toEntity(ArtistMessages.Artist protobuf) {
+        if (protobuf == null) {
+            return null;
+        }
+        Artist entity = new Artist();
+
+        if (protobuf.getId() > 0) {
+            entity.setId(protobuf.getId());
+        }
+        entity.setName(protobuf.getName());
+        return entity;
+    }
+}

src/main/java/com/mediamanager/mapper/BitDepthMapper.java

@@ -0,0 +1,39 @@
+package com.mediamanager.mapper;
+
+import com.mediamanager.model.BitDepth;
+import com.mediamanager.protocol.messages.BitDepthMessages;
+
+public class BitDepthMapper {
+    public static BitDepthMessages.BitDepth toProtobuf(BitDepth entity) {
+        if (entity == null){
+            return null;
+        }
+
+        String value = entity.getValue();
+        if (value == null) {
+            throw new IllegalArgumentException("Bit depth value cannot be null");
+        }
+        BitDepthMessages.BitDepth.Builder builder = BitDepthMessages.BitDepth.newBuilder()
+                .setValue(value);
+
+        Integer id = entity.getId();
+        if (id != null && id > 0) {
+            builder.setId(id);
+        }
+
+        return builder.build();
+    }
+
+    public static BitDepth toEntity(BitDepthMessages.BitDepth protobuf) {
+        if (protobuf == null) {
+            return null;
+        }
+        BitDepth entity = new BitDepth();
+
+        if (protobuf.getId() > 0) {
+            entity.setId(protobuf.getId());
+        }
+        entity.setValue(protobuf.getValue());
+        return entity;
+    }
+}

src/main/java/com/mediamanager/mapper/BitRateMapper.java

@@ -0,0 +1,39 @@
+package com.mediamanager.mapper;
+
+import com.mediamanager.model.BitRate;
+import com.mediamanager.protocol.messages.BitRateMessages;
+
+public class BitRateMapper {
+    public static BitRateMessages.BitRate toProtobuf(BitRate entity) {
+        if (entity == null) {
+            return null;
+        }
+
+        String value = entity.getValue();
+        if (value == null) {
+            throw new IllegalArgumentException("Bit rate value cannot be null");
+        }
+
+        BitRateMessages.BitRate.Builder builder = BitRateMessages.BitRate.newBuilder()
+                .setValue(value);
+
+        Integer id = entity.getId();
+        if (id != null && id > 0) {
+            builder.setId(id);
+        }
+        return builder.build();
+    }
+
+    public static BitRate toEntity(BitRateMessages.BitRate protobuf) {
+        if (protobuf == null) {
+            return null;
+        }
+        BitRate entity = new BitRate();
+
+        if (protobuf.getId() > 0) {
+            entity.setId(protobuf.getId());
+        }
+        entity.setValue(protobuf.getValue());
+        return entity;
+    }
+}

src/main/java/com/mediamanager/mapper/ComposerMapper.java

@@ -0,0 +1,38 @@
+package com.mediamanager.mapper;
+
+import com.mediamanager.model.Composer;
+import com.mediamanager.protocol.messages.ComposerMessages;
+
+public class ComposerMapper {
+    public static ComposerMessages.Composer toProtobuf(Composer entity) {
+        if (entity == null) {
+            return null;
+        }
+        ComposerMessages.Composer.Builder builder = ComposerMessages.Composer.newBuilder()
+                .setName(entity.getName());
+
+        Integer id = entity.getId();
+        if (id != null && id > 0) {
+            builder.setId(id);
+        }
+
+        return builder.build();
+
+    }
+
+    public static Composer toEntity(ComposerMessages.Composer protobuf) {
+        if (protobuf == null) {
+            return null;
+        }
+
+        Composer entity = new Composer();
+
+        if (protobuf.getId() > 0) {
+            entity.setId(protobuf.getId());
+        }
+
+        entity.setName(protobuf.getName());
+
+        return entity;
+    }
+}

src/main/java/com/mediamanager/mapper/DiscMapper.java

@@ -0,0 +1,50 @@
+package com.mediamanager.mapper;
+
+import com.mediamanager.model.Disc;
+import com.mediamanager.protocol.messages.DiscMessages;
+
+public class DiscMapper {
+    public static DiscMessages.Disc toProtobuf(Disc entity) {
+        if (entity == null) {
+            return null;
+        }
+
+        Integer discNumber = entity.getDiscNumber();
+        if (discNumber == null) {
+            throw new IllegalArgumentException("Disc number cannot be null");
+        }
+
+        DiscMessages.Disc.Builder builder = DiscMessages.Disc.newBuilder()
+                .setDiscNumber(discNumber);
+
+        Integer id = entity.getId();
+        if (id != null) {
+            builder.setId(id);
+        }
+
+        // Map Album foreign key
+        if (entity.getAlbum() != null && entity.getAlbum().getId() != null) {
+            builder.setFkAlbumId(entity.getAlbum().getId());
+        }
+
+        return builder.build();
+    }
+
+    public static Disc toEntity(DiscMessages.Disc protobuf) {
+        if (protobuf == null) {
+            return null;
+        }
+
+        Disc entity = new Disc();
+
+        if (protobuf.getId() > 0) {
+            entity.setId(protobuf.getId());
+        }
+
+        entity.setDiscNumber(protobuf.getDiscNumber());
+
+        // Note: Foreign key relationship (Album) is handled in the service layer
+
+        return entity;
+    }
+}

src/main/java/com/mediamanager/mapper/GenreMapper.java

@@ -0,0 +1,40 @@
+package com.mediamanager.mapper;
+
+import com.mediamanager.model.Genre;
+import com.mediamanager.protocol.messages.GenreMessages;
+
+public class GenreMapper {
+    public static GenreMessages.Genre toProtobuf(Genre entity) {
+        if (entity == null) {
+            return null;
+        }
+
+        GenreMessages.Genre.Builder builder = GenreMessages.Genre.newBuilder()
+                .setName(entity.getName());
+
+        // Only set ID when it's present and valid (> 0). Avoids NPE for null IDs.
+        Integer id = entity.getId();
+        if (id != null && id > 0) {
+            builder.setId(id);
+        }
+
+        return builder.build();
+    }
+    public static Genre toEntity(GenreMessages.Genre protobuf) {
+        if (protobuf == null) {
+            return null;
+        }
+
+        Genre entity = new Genre();
+
+        // Só seta ID se for > 0 (protobuf default é 0)
+        if (protobuf.getId() > 0) {
+            entity.setId(protobuf.getId());
+        }
+
+        entity.setName(protobuf.getName());
+
+        return entity;
+    }
+}
+

src/main/java/com/mediamanager/mapper/SamplingRateMapper.java

@@ -0,0 +1,35 @@
+package com.mediamanager.mapper;
+
+import com.mediamanager.model.SamplingRate;
+import com.mediamanager.protocol.messages.SamplingRateMessages;
+
+public class SamplingRateMapper {
+    public static SamplingRateMessages.SamplingRate toProtobuf(SamplingRate entity) {
+        if (entity == null) {
+            return null;
+        }
+        String value = entity.getValue();
+        if (value == null || value.isEmpty()) {
+            throw new IllegalArgumentException("Value cannot be null or empty");
+        }
+        SamplingRateMessages.SamplingRate.Builder builder = SamplingRateMessages.SamplingRate.newBuilder()
+                .setValue(value);
+        Integer id = entity.getId();
+        if (id != null) {
+            builder.setId(id);
+        }
+        return builder.build();
+    }
+
+    public static SamplingRate toEntity(SamplingRateMessages.SamplingRate protobuf) {
+        if (protobuf == null) {
+            return null;
+        }
+        SamplingRate entity = new SamplingRate();
+        if (protobuf.getId() >0) {
+            entity.setId(protobuf.getId());
+        }
+        entity.setValue(protobuf.getValue());
+        return entity;
+    }
+}

src/main/java/com/mediamanager/mapper/TrackHasArtistMapper.java

@@ -0,0 +1,47 @@
+package com.mediamanager.mapper;
+
+import com.mediamanager.model.TrackHasArtist;
+import com.mediamanager.protocol.messages.TrackHasArtistMessages;
+
+public class TrackHasArtistMapper {
+    public static TrackHasArtistMessages.TrackHasArtist toProtobuf(TrackHasArtist entity) {
+        if (entity == null) {
+            return null;
+        }
+
+        TrackHasArtistMessages.TrackHasArtist.Builder builder = TrackHasArtistMessages.TrackHasArtist.newBuilder();
+
+        Integer id = entity.getId();
+        if (id != null) {
+            builder.setId(id);
+        }
+
+        // Map Track foreign key
+        if (entity.getTrack() != null && entity.getTrack().getId() != null) {
+            builder.setFkTrackId(entity.getTrack().getId());
+        }
+
+        // Map Artist foreign key
+        if (entity.getArtist() != null && entity.getArtist().getId() != null) {
+            builder.setFkArtistId(entity.getArtist().getId());
+        }
+
+        return builder.build();
+    }
+
+    public static TrackHasArtist toEntity(TrackHasArtistMessages.TrackHasArtist protobuf) {
+        if (protobuf == null) {
+            return null;
+        }
+
+        TrackHasArtist entity = new TrackHasArtist();
+
+        if (protobuf.getId() > 0) {
+            entity.setId(protobuf.getId());
+        }
+
+        // Note: Foreign key relationships (Track, Artist) are handled in the service layer
+
+        return entity;
+    }
+}

src/main/java/com/mediamanager/mapper/TrackHasComposerMapper.java

@@ -0,0 +1,47 @@
+package com.mediamanager.mapper;
+
+import com.mediamanager.model.TrackHasComposer;
+import com.mediamanager.protocol.messages.TrackHasComposerMessages;
+
+public class TrackHasComposerMapper {
+    public static TrackHasComposerMessages.TrackHasComposer toProtobuf(TrackHasComposer entity) {
+        if (entity == null) {
+            return null;
+        }
+
+        TrackHasComposerMessages.TrackHasComposer.Builder builder = TrackHasComposerMessages.TrackHasComposer.newBuilder();
+
+        Integer id = entity.getId();
+        if (id != null) {
+            builder.setId(id);
+        }
+
+        // Map Track foreign key
+        if (entity.getTrack() != null && entity.getTrack().getId() != null) {
+            builder.setFkTrackId(entity.getTrack().getId());
+        }
+
+        // Map Composer foreign key
+        if (entity.getComposer() != null && entity.getComposer().getId() != null) {
+            builder.setFkComposerId(entity.getComposer().getId());
+        }
+
+        return builder.build();
+    }
+
+    public static TrackHasComposer toEntity(TrackHasComposerMessages.TrackHasComposer protobuf) {
+        if (protobuf == null) {
+            return null;
+        }
+
+        TrackHasComposer entity = new TrackHasComposer();
+
+        if (protobuf.getId() > 0) {
+            entity.setId(protobuf.getId());
+        }
+
+        // Note: Foreign key relationships (Track, Composer) are handled in the service layer
+
+        return entity;
+    }
+}

src/main/java/com/mediamanager/mapper/TrackHasGenreMapper.java

@@ -0,0 +1,47 @@
+package com.mediamanager.mapper;
+
+import com.mediamanager.model.TrackHasGenre;
+import com.mediamanager.protocol.messages.TrackHasGenreMessages;
+
+public class TrackHasGenreMapper {
+    public static TrackHasGenreMessages.TrackHasGenre toProtobuf(TrackHasGenre entity) {
+        if (entity == null) {
+            return null;
+        }
+
+        TrackHasGenreMessages.TrackHasGenre.Builder builder = TrackHasGenreMessages.TrackHasGenre.newBuilder();
+
+        Integer id = entity.getId();
+        if (id != null) {
+            builder.setId(id);
+        }
+
+        // Map Track foreign key
+        if (entity.getTrack() != null && entity.getTrack().getId() != null) {
+            builder.setFkTrackId(entity.getTrack().getId());
+        }
+
+        // Map Genre foreign key
+        if (entity.getGenre() != null && entity.getGenre().getId() != null) {
+            builder.setFkGenreId(entity.getGenre().getId());
+        }
+
+        return builder.build();
+    }
+
+    public static TrackHasGenre toEntity(TrackHasGenreMessages.TrackHasGenre protobuf) {
+        if (protobuf == null) {
+            return null;
+        }
+
+        TrackHasGenre entity = new TrackHasGenre();
+
+        if (protobuf.getId() > 0) {
+            entity.setId(protobuf.getId());
+        }
+
+        // Note: Foreign key relationships (Track, Genre) are handled in the service layer
+
+        return entity;
+    }
+}

src/main/java/com/mediamanager/mapper/TrackMapper.java

@@ -0,0 +1,95 @@
+package com.mediamanager.mapper;
+
+import com.mediamanager.model.Track;
+import com.mediamanager.protocol.messages.TrackMessages;
+
+public class TrackMapper {
+    public static TrackMessages.Track toProtobuf(Track entity) {
+        if (entity == null) {
+            return null;
+        }
+
+        Integer trackNumber = entity.getTrackNumber();
+        if (trackNumber == null) {
+            throw new IllegalArgumentException("Track number cannot be null");
+        }
+
+        String title = entity.getTitle();
+        if (title == null) {
+            throw new IllegalArgumentException("Title cannot be null");
+        }
+
+        String filepath = entity.getFilepath();
+        if (filepath == null) {
+            throw new IllegalArgumentException("Filepath cannot be null");
+        }
+
+        TrackMessages.Track.Builder builder = TrackMessages.Track.newBuilder()
+                .setTrackNumber(trackNumber)
+                .setTitle(title)
+                .setFilepath(filepath);
+
+        Integer id = entity.getId();
+        if (id != null) {
+            builder.setId(id);
+        }
+
+        // Map duration (optional)
+        Integer duration = entity.getDuration();
+        if (duration != null) {
+            builder.setDuration(duration);
+        }
+
+        // Map Disc foreign key (required)
+        if (entity.getDisc() != null && entity.getDisc().getId() != null) {
+            builder.setFkDiscId(entity.getDisc().getId());
+        }
+
+        // Map Composer foreign key (optional)
+        if (entity.getComposer() != null && entity.getComposer().getId() != null) {
+            builder.setFkComposerId(entity.getComposer().getId());
+        }
+
+        // Map BitDepth foreign key (optional)
+        if (entity.getBitDepth() != null && entity.getBitDepth().getId() != null) {
+            builder.setFkBitdepthId(entity.getBitDepth().getId());
+        }
+
+        // Map BitRate foreign key (optional)
+        if (entity.getBitRate() != null && entity.getBitRate().getId() != null) {
+            builder.setFkBitrateId(entity.getBitRate().getId());
+        }
+
+        // Map SamplingRate foreign key (optional)
+        if (entity.getSamplingRate() != null && entity.getSamplingRate().getId() != null) {
+            builder.setFkSamplingrateId(entity.getSamplingRate().getId());
+        }
+
+        return builder.build();
+    }
+
+    public static Track toEntity(TrackMessages.Track protobuf) {
+        if (protobuf == null) {
+            return null;
+        }
+
+        Track entity = new Track();
+
+        if (protobuf.getId() > 0) {
+            entity.setId(protobuf.getId());
+        }
+
+        entity.setTrackNumber(protobuf.getTrackNumber());
+        entity.setTitle(protobuf.getTitle());
+        entity.setFilepath(protobuf.getFilepath());
+
+        if (protobuf.getDuration() > 0) {
+            entity.setDuration(protobuf.getDuration());
+        }
+
+        // Note: Foreign key relationships (Disc, Composer, BitDepth, BitRate, SamplingRate)
+        // are handled in the service layer
+
+        return entity;
+    }
+}

src/main/java/com/mediamanager/model/Album.java

@@ -0,0 +1,229 @@
+package com.mediamanager.model;
+
+import jakarta.persistence.*;
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+@Entity
+@Table(name = "album")
+public class Album {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Integer id;
+
+    @Column(nullable = false)
+    private String name;
+
+    @Column
+    private Integer year;
+
+    @Column(name = "number_of_discs")
+    private Integer numberOfDiscs;
+
+    @Column
+    private String code;
+
+    @Column(name = "is_compilation")
+    private Boolean isCompilation;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "fk_albumtype_id")
+    private AlbumType albumType;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "fk_albumart_id")
+    private AlbumArt albumArt;
+
+    // Relacionamento ManyToMany com Artist através da tabela de junção
+    @OneToMany(mappedBy = "album", cascade = CascadeType.ALL, orphanRemoval = true)
+    private List<AlbumHasArtist> albumArtists = new ArrayList<>();
+
+    // Relacionamento ManyToMany com Genre através da tabela de junção
+    @OneToMany(mappedBy = "album", cascade = CascadeType.ALL, orphanRemoval = true)
+    private List<AlbumHasGenre> albumGenres = new ArrayList<>();  // ← ADICIONE ESSA LINHA
+
+    @Column(name = "created_at", nullable = false, updatable = false)
+    private LocalDateTime createdAt;
+
+    @Column(name = "updated_at")
+    private LocalDateTime updatedAt;
+
+    @PrePersist
+    protected void onCreate() {
+        this.createdAt = LocalDateTime.now();
+        this.updatedAt = LocalDateTime.now();
+    }
+
+    @PreUpdate
+    protected void onUpdate() {
+        this.updatedAt = LocalDateTime.now();
+    }
+
+    public Album() {}
+
+    // Métodos helper para Artist (ManyToMany)
+    public void addArtist(Artist artist) {
+        AlbumHasArtist albumHasArtist = new AlbumHasArtist();
+        albumHasArtist.setAlbum(this);
+        albumHasArtist.setArtist(artist);
+        albumArtists.add(albumHasArtist);
+    }
+
+    public void removeArtist(Artist artist) {
+        albumArtists.removeIf(aa ->
+                aa.getArtist() != null && 
+                aa.getArtist().getId() != null && 
+                aa.getArtist().getId().equals(artist.getId())
+        );
+    }
+
+    // Método conveniente para pegar só os artistas
+    public List<Artist> getArtists() {
+        return albumArtists.stream()
+                .map(AlbumHasArtist::getArtist)
+                .collect(Collectors.toList());
+    }
+
+    // ========== ADICIONE ESSES MÉTODOS PARA GENRE ==========
+
+    // Métodos helper para Genre (ManyToMany)
+    public void addGenre(Genre genre) {
+        AlbumHasGenre albumHasGenre = new AlbumHasGenre();
+        albumHasGenre.setAlbum(this);
+        albumHasGenre.setGenre(genre);
+        albumGenres.add(albumHasGenre);
+    }
+
+    public void removeGenre(Genre genre) {
+        if (genre == null) {
+            return;
+        }
+        albumGenres.removeIf(ag ->
+                ag.getGenre() != null &&
+                        ag.getGenre().getId() != null &&
+                        ag.getGenre().getId().equals(genre.getId())
+        );
+    }
+
+    // Método conveniente para pegar só os gêneros
+    public List<Genre> getGenres() {
+        return albumGenres.stream()
+                .map(AlbumHasGenre::getGenre)
+                .collect(Collectors.toList());
+    }
+
+    // ========== FIM DOS MÉTODOS DE GENRE ==========
+
+    // Getters and Setters
+    public Integer getId() {
+        return id;
+    }
+
+    public void setId(Integer id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public Integer getYear() {
+        return year;
+    }
+
+    public void setYear(Integer year) {
+        this.year = year;
+    }
+
+    public Integer getNumberOfDiscs() {
+        return numberOfDiscs;
+    }
+
+    public void setNumberOfDiscs(Integer numberOfDiscs) {
+        this.numberOfDiscs = numberOfDiscs;
+    }
+
+    public String getCode() {
+        return code;
+    }
+
+    public void setCode(String code) {
+        this.code = code;
+    }
+
+    public Boolean getIsCompilation() {
+        return isCompilation;
+    }
+
+    public void setIsCompilation(Boolean isCompilation) {
+        this.isCompilation = isCompilation;
+    }
+
+    public AlbumType getAlbumType() {
+        return albumType;
+    }
+
+    public void setAlbumType(AlbumType albumType) {
+        this.albumType = albumType;
+    }
+
+    public AlbumArt getAlbumArt() {
+        return albumArt;
+    }
+
+    public void setAlbumArt(AlbumArt albumArt) {
+        this.albumArt = albumArt;
+    }
+
+    public List<AlbumHasArtist> getAlbumArtists() {
+        return albumArtists;
+    }
+
+    public void setAlbumArtists(List<AlbumHasArtist> albumArtists) {
+        this.albumArtists = albumArtists;
+    }
+
+    // ========== ADICIONE ESSES GETTERS/SETTERS ==========
+
+    public List<AlbumHasGenre> getAlbumGenres() {
+        return albumGenres;
+    }
+
+    public void setAlbumGenres(List<AlbumHasGenre> albumGenres) {
+        this.albumGenres = albumGenres;
+    }
+
+    // ========== FIM DOS GETTERS/SETTERS DE GENRE ==========
+
+    public LocalDateTime getCreatedAt() {
+        return createdAt;
+    }
+
+    public void setCreatedAt(LocalDateTime createdAt) {
+        this.createdAt = createdAt;
+    }
+
+    public LocalDateTime getUpdatedAt() {
+        return updatedAt;
+    }
+
+    public void setUpdatedAt(LocalDateTime updatedAt) {
+        this.updatedAt = updatedAt;
+    }
+
+    @Override
+    public String toString() {
+        return "Album{" +
+                "id=" + id +
+                ", name='" + name + '\'' +
+                ", year=" + year +
+                '}';
+    }
+}

src/main/java/com/mediamanager/model/AlbumArt.java

@@ -0,0 +1,33 @@
+package com.mediamanager.model;
+
+
+import jakarta.persistence.*;
+
+@Entity
+@Table(name = "albumArt")
+public class AlbumArt {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Integer id;
+
+    @Column(nullable = false)
+    private String filepath;
+
+
+    public Integer getId() {
+        return id;
+    }
+
+    public void setId(Integer id) {
+        this.id = id;
+    }
+
+    public String getFilepath() {
+        return filepath;
+    }
+
+    public void setFilepath(String filepath) {
+        this.filepath = filepath;
+    }
+}

src/main/java/com/mediamanager/model/AlbumHasArtist.java

@@ -0,0 +1,56 @@
+package com.mediamanager.model;
+
+import jakarta.persistence.*;
+
+@Entity
+@Table(name = "albumshasartist")
+public class AlbumHasArtist {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Integer id;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "fk_album_id", nullable = false)
+    private Album album;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "fk_artist_id", nullable = false)
+    private Artist artist;
+
+    public AlbumHasArtist() {}
+
+    // Getters and Setters
+    public Integer getId() {
+        return id;
+    }
+
+    public void setId(Integer id) {
+        this.id = id;
+    }
+
+    public Album getAlbum() {
+        return album;
+    }
+
+    public void setAlbum(Album album) {
+        this.album = album;
+    }
+
+    public Artist getArtist() {
+        return artist;
+    }
+
+    public void setArtist(Artist artist) {
+        this.artist = artist;
+    }
+
+    @Override
+    public String toString() {
+        return "AlbumHasArtist{" +
+                "id=" + id +
+                ", albumId=" + (album != null ? album.getId() : null) +
+                ", artistId=" + (artist != null ? artist.getId() : null) +
+                '}';
+    }
+}

src/main/java/com/mediamanager/model/AlbumHasGenre.java

@@ -0,0 +1,56 @@
+package com.mediamanager.model;
+
+import jakarta.persistence.*;
+
+@Entity
+@Table(name = "albumshasgenre")
+public class AlbumHasGenre {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Integer id;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "fk_album_id", nullable = false)
+    private Album album;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "fk_genre_id", nullable = false)
+    private Genre genre;
+
+    public AlbumHasGenre() {}
+
+    // Getters and Setters
+    public Integer getId() {
+        return id;
+    }
+
+    public void setId(Integer id) {
+        this.id = id;
+    }
+
+    public Album getAlbum() {
+        return album;
+    }
+
+    public void setAlbum(Album album) {
+        this.album = album;
+    }
+
+    public Genre getGenre() {
+        return genre;
+    }
+
+    public void setGenre(Genre genre) {
+        this.genre = genre;
+    }
+
+    @Override
+    public String toString() {
+        return "AlbumHasGenre{" +
+                "id=" + id +
+                ", albumId=" + (album != null ? album.getId() : null) +
+                ", genreId=" + (genre != null ? genre.getId() : null) +
+                '}';
+    }
+}

src/main/java/com/mediamanager/model/AlbumType.java

@@ -0,0 +1,31 @@
+package com.mediamanager.model;
+
+import jakarta.persistence.*;
+
+@Entity
+@Table(name = "albumtype")
+public class AlbumType {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Integer id;
+
+    @Column(nullable = false)
+    private String value;
+
+    public Integer getId() {
+        return id;
+    }
+
+    public void setId(Integer id) {
+        this.id = id;
+    }
+
+    public String getValue() {
+        return value;
+    }
+
+    public void setValue(String value) {
+        this.value = value;
+    }
+}

src/main/java/com/mediamanager/model/Artist.java

@@ -0,0 +1,27 @@
+package com.mediamanager.model;
+
+import jakarta.persistence.*;
+
+@Entity
+@Table(name = "artist")
+public class Artist {
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Integer id;
+
+    @Column(nullable = false)
+    private String name;
+
+    public Integer getId() {
+        return id;
+    }
+    public void setId(Integer id) {
+        this.id = id;
+    }
+    public String getName() {
+        return name;
+    }
+    public void setName(String name) {
+        this.name = name;
+    }
+}

src/main/java/com/mediamanager/model/BitDepth.java

@@ -0,0 +1,32 @@
+package com.mediamanager.model;
+
+import jakarta.persistence.*;
+
+@Entity
+@Table(name = "bit_depth")
+public class BitDepth {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Integer id;
+
+    @Column(nullable = false)
+    private String value;
+
+    public Integer getId() {
+        return id;
+    }
+
+    public void setId(Integer id) {
+        this.id = id;
+    }
+
+    public String getValue() {
+        return value;
+    }
+
+    public void setValue(String value) {
+        this.value = value;
+    }
+}
+

src/main/java/com/mediamanager/model/BitRate.java

@@ -0,0 +1,31 @@
+package com.mediamanager.model;
+
+import jakarta.persistence.*;
+
+@Entity
+@Table(name = "bit_rate")
+public class BitRate {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Integer id;
+
+    @Column(nullable = false)
+    private String value;
+
+    public Integer getId() {
+        return id;
+    }
+
+    public void setId(Integer id) {
+        this.id = id;
+    }
+
+    public String getValue() {
+        return value;
+    }
+
+    public void setValue(String value) {
+        this.value = value;
+    }
+}

src/main/java/com/mediamanager/model/Composer.java

@@ -0,0 +1,31 @@
+package com.mediamanager.model;
+
+
+import jakarta.persistence.*;
+
+@Entity
+@Table(name = "composer")
+public class Composer {
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Integer id;
+
+    @Column(nullable = false)
+    private String name;
+
+    public Integer getId() {
+        return id;
+    }
+
+    public void setId(Integer id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+}

src/main/java/com/mediamanager/model/Disc.java

@@ -0,0 +1,47 @@
+package com.mediamanager.model;
+
+import jakarta.persistence.*;
+
+@Entity
+@Table(name = "disc")
+public class Disc {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Integer id;
+
+    @Column(name = "disc_number", nullable = false)
+    private Integer discNumber;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "fk_album_id",nullable = false)
+    private Album album;
+
+    public Disc() {
+
+    }
+
+    public Integer getId() {
+        return id;
+    }
+
+    public void setId(Integer id) {
+        this.id = id;
+    }
+
+    public Integer getDiscNumber() {
+        return discNumber;
+    }
+
+    public void setDiscNumber(Integer discNumber) {
+        this.discNumber = discNumber;
+    }
+
+    public Album getAlbum() {
+        return album;
+    }
+
+    public void setAlbum(Album album) {
+        this.album = album;
+    }
+}

src/main/java/com/mediamanager/model/Genre.java

@@ -0,0 +1,30 @@
+package com.mediamanager.model;
+
+import jakarta.persistence.*;
+
+@Entity
+@Table(name = "genre")
+public class Genre {
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Integer id;
+
+    @Column(nullable = false)
+    private String name;
+
+    public Integer getId() {
+        return id;
+    }
+
+    public void setId(Integer id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+}

src/main/java/com/mediamanager/model/Media.java

@@ -1,128 +0,0 @@
-package com.mediamanager.model;
-
-import jakarta.persistence.*;
-import java.time.LocalDateTime;
-
-@Entity
-@Table(name = "media")
-public class Media {
-    
-    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    private Long id;
-    
-    @Column(nullable = false)
-    private String title;
-    
-    @Column(nullable = false, unique = true)
-    private String filePath;
-    
-    @Enumerated(EnumType.STRING)
-    @Column(nullable = false)
-    private MediaType type;
-    
-    @Column
-    private Long fileSize;
-    
-    @Column
-    private String mimeType;
-    
-    @Column(name = "created_at", nullable = false, updatable = false)
-    private LocalDateTime createdAt;
-    
-    @Column(name = "updated_at")
-    private LocalDateTime updatedAt;
-    
-    @PrePersist
-    protected void onCreate() {
-        createdAt = LocalDateTime.now();
-        updatedAt = LocalDateTime.now();
-    }
-    
-    @PreUpdate
-    protected void onUpdate() {
-        updatedAt = LocalDateTime.now();
-    }
-    
-    // Constructors
-    public Media() {}
-    
-    public Media(String title, String filePath, MediaType type) {
-        this.title = title;
-        this.filePath = filePath;
-        this.type = type;
-    }
-    
-    // Getters and Setters
-    public Long getId() {
-        return id;
-    }
-    
-    public void setId(Long id) {
-        this.id = id;
-    }
-    
-    public String getTitle() {
-        return title;
-    }
-    
-    public void setTitle(String title) {
-        this.title = title;
-    }
-    
-    public String getFilePath() {
-        return filePath;
-    }
-    
-    public void setFilePath(String filePath) {
-        this.filePath = filePath;
-    }
-    
-    public MediaType getType() {
-        return type;
-    }
-    
-    public void setType(MediaType type) {
-        this.type = type;
-    }
-    
-    public Long getFileSize() {
-        return fileSize;
-    }
-    
-    public void setFileSize(Long fileSize) {
-        this.fileSize = fileSize;
-    }
-    
-    public String getMimeType() {
-        return mimeType;
-    }
-    
-    public void setMimeType(String mimeType) {
-        this.mimeType = mimeType;
-    }
-    
-    public LocalDateTime getCreatedAt() {
-        return createdAt;
-    }
-    
-    public void setCreatedAt(LocalDateTime createdAt) {
-        this.createdAt = createdAt;
-    }
-    
-    public LocalDateTime getUpdatedAt() {
-        return updatedAt;
-    }
-    
-    public void setUpdatedAt(LocalDateTime updatedAt) {
-        this.updatedAt = updatedAt;
-    }
-    
-    public enum MediaType {
-        VIDEO,
-        AUDIO,
-        IMAGE,
-        DOCUMENT,
-        OTHER
-    }
-}

src/main/java/com/mediamanager/model/SamplingRate.java

@@ -0,0 +1,30 @@
+package com.mediamanager.model;
+
+import jakarta.persistence.*;
+
+@Entity
+@Table(name = "sampling_rate")
+public class SamplingRate {
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private  Integer id;
+
+    @Column(nullable = false)
+    private String value;
+
+    public Integer getId() {
+        return id;
+    }
+
+    public void setId(Integer id) {
+        this.id = id;
+    }
+
+    public String getValue() {
+        return value;
+    }
+
+    public void setValue(String value) {
+        this.value = value;
+    }
+}

src/main/java/com/mediamanager/model/Track.java

@@ -0,0 +1,128 @@
+package com.mediamanager.model;
+
+import jakarta.persistence.*;
+
+@Entity
+@Table(name = "track")
+public class Track {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Integer id;
+
+    @Column(name = "track_number")
+    private Integer trackNumber;
+
+    @Column
+    private String title;
+
+    @Column
+    private Integer duration;
+
+    @Column
+    private String filepath;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "fk_disc_id")
+    private Disc disc;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "fk_composer_id")
+    private Composer composer;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "fk_bit_depth_id")
+    private BitDepth bitDepth;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "fk_bit_rate_id")
+    private BitRate bitRate;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "fk_sampling_rate_id")
+    private SamplingRate samplingRate;
+
+    public Track() {
+
+    }
+
+    public Integer getId() {
+        return id;
+    }
+
+    public void setId(Integer id) {
+        this.id = id;
+    }
+
+    public Integer getTrackNumber() {
+        return trackNumber;
+    }
+
+    public void setTrackNumber(Integer trackNumber) {
+        this.trackNumber = trackNumber;
+    }
+
+    public String getTitle() {
+        return title;
+    }
+
+    public void setTitle(String name) {
+        this.title = name;
+    }
+
+    public Integer getDuration() {
+        return duration;
+    }
+
+    public void setDuration(Integer duration) {
+        this.duration = duration;
+    }
+
+    public String getFilepath() {
+        return filepath;
+    }
+
+    public void setFilepath(String filepath) {
+        this.filepath = filepath;
+    }
+
+    public Disc getDisc() {
+        return disc;
+    }
+
+    public void setDisc(Disc disc) {
+        this.disc = disc;
+    }
+
+    public Composer getComposer() {
+        return composer;
+    }
+
+    public void setComposer(Composer composer) {
+        this.composer = composer;
+    }
+
+    public BitDepth getBitDepth() {
+        return bitDepth;
+    }
+
+    public void setBitDepth(BitDepth bitDepth) {
+        this.bitDepth = bitDepth;
+    }
+
+    public BitRate getBitRate() {
+        return bitRate;
+    }
+
+    public void setBitRate(BitRate bitRate) {
+        this.bitRate = bitRate;
+    }
+
+    public SamplingRate getSamplingRate() {
+        return samplingRate;
+    }
+
+    public void setSamplingRate(SamplingRate samplingRate) {
+        this.samplingRate = samplingRate;
+    }
+}

src/main/java/com/mediamanager/model/TrackHasArtist.java

@@ -0,0 +1,58 @@
+package com.mediamanager.model;
+
+import jakarta.persistence.*;
+
+@Entity
+@Table(
+    name = "trackhasartist",
+    uniqueConstraints = @UniqueConstraint(columnNames = {"fk_track_id", "fk_artist_id"})
+)
+public class TrackHasArtist {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Integer id;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "fk_track_id", nullable = false)
+    private Track track;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "fk_artist_id", nullable = false)
+    private Artist artist;
+
+    public TrackHasArtist() {}
+
+    public Integer getId() {
+        return id;
+    }
+
+    public void setId(Integer id) {
+        this.id = id;
+    }
+
+    public Track getTrack() {
+        return track;
+    }
+
+    public void setTrack(Track track) {
+        this.track = track;
+    }
+
+    public Artist getArtist() {
+        return artist;
+    }
+
+    public void setArtist(Artist artist) {
+        this.artist = artist;
+    }
+
+    @Override
+    public String toString() {
+        return "TrackHasArtist{" +
+                "id=" + id +
+                ", trackId=" + (track != null ? track.getId() : null) +
+                ", artistId=" + (artist != null ? artist.getId() : null) +
+                '}';
+    }
+}

src/main/java/com/mediamanager/model/TrackHasComposer.java

@@ -0,0 +1,58 @@
+package com.mediamanager.model;
+
+import jakarta.persistence.*;
+
+@Entity
+@Table(
+    name = "trackhascomposer",
+    uniqueConstraints = @UniqueConstraint(columnNames = {"fk_track_id", "fk_composer_id"})
+)
+public class TrackHasComposer {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Integer id;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "fk_track_id", nullable = false)
+    private Track track;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "fk_composer_id", nullable = false)
+    private Composer composer;
+
+    public TrackHasComposer() {}
+
+    public Integer getId() {
+        return id;
+    }
+
+    public void setId(Integer id) {
+        this.id = id;
+    }
+
+    public Track getTrack() {
+        return track;
+    }
+
+    public void setTrack(Track track) {
+        this.track = track;
+    }
+
+    public Composer getComposer() {
+        return composer;
+    }
+
+    public void setComposer(Composer composer) {
+        this.composer = composer;
+    }
+
+    @Override
+    public String toString() {
+        return "TrackHasComposer{" +
+                "id=" + id +
+                ", trackId=" + (track != null ? track.getId() : null) +
+                ", composerId=" + (composer != null ? composer.getId() : null) +
+                '}';
+    }
+}

src/main/java/com/mediamanager/model/TrackHasGenre.java

@@ -0,0 +1,56 @@
+package com.mediamanager.model;
+
+import jakarta.persistence.*;
+
+@Entity
+@Table(name = "trackhasgenre", 
+    uniqueConstraints = @UniqueConstraint(columnNames = {"fk_track_id", "fk_genre_id"}))
+public class TrackHasGenre {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Integer id;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "fk_track_id", nullable = false)
+    private Track track;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "fk_genre_id", nullable = false)
+    private Genre genre;
+
+    public TrackHasGenre() {}
+
+    public Integer getId() {
+        return id;
+    }
+
+    public void setId(Integer id) {
+        this.id = id;
+    }
+
+    public Track getTrack() {
+        return track;
+    }
+
+    public void setTrack(Track track) {
+        this.track = track;
+    }
+
+    public Genre getGenre() {
+        return genre;
+    }
+
+    public void setGenre(Genre genre) {
+        this.genre = genre;
+    }
+
+    @Override
+    public String toString() {
+        return "TrackHasGenre{" +
+                "id=" + id +
+                ", trackId=" + (track != null ? track.getId() : null) +
+                ", genreId=" + (genre != null ? genre.getId() : null) +
+                '}';
+    }
+}

src/main/java/com/mediamanager/repository/AlbumArtRepository.java

@@ -0,0 +1,103 @@
+package com.mediamanager.repository;
+
+
+import com.mediamanager.model.AlbumArt;
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.EntityManagerFactory;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+
+import java.util.List;
+import java.util.Optional;
+
+public class AlbumArtRepository {
+    private static final Logger logger = LogManager.getLogger(AlbumArtRepository.class);
+
+    private final EntityManagerFactory entityManagerFactory;
+
+    public AlbumArtRepository(EntityManagerFactory entityManagerFactory) {
+        this.entityManagerFactory = entityManagerFactory;
+    }
+
+    public AlbumArt save(AlbumArt albumArt) {
+        logger.debug("Saving AlbumArt: {}", albumArt.getFilepath());
+        EntityManager em = entityManagerFactory.createEntityManager();
+        em.getTransaction().begin();
+        try {
+            em.persist(albumArt);
+            em.getTransaction().commit();
+            logger.debug("AlbumArt has been saved successfully");
+            return albumArt;
+        } catch (Exception e) {
+            em.getTransaction().rollback();
+            logger.error("Error while saving AlbumArt: {}", e.getMessage());
+            throw e;
+        } finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+    public List<AlbumArt> findAll() {
+        logger.debug("Finding All AlbumArt");
+        EntityManager em = entityManagerFactory.createEntityManager();
+        try{
+            return em.createQuery("select a from AlbumArt a", AlbumArt.class).getResultList();
+        }finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+    public Optional<AlbumArt> findById(Integer id) {
+        logger.debug("Finding AlbumArt with id: {}", id);
+        EntityManager em = entityManagerFactory.createEntityManager();
+        try{
+            AlbumArt albumArt = em.find(AlbumArt.class, id);
+            return Optional.ofNullable(albumArt);
+        }finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+    public AlbumArt update(AlbumArt albumArt) {
+        logger.debug("Updating AlbumArt: {}", albumArt.getFilepath());
+        EntityManager em = entityManagerFactory.createEntityManager();
+        em.getTransaction().begin();
+        try {
+            AlbumArt updated = em.merge(albumArt);
+            em.getTransaction().commit();
+            logger.debug("AlbumArt has been updated successfully");
+            return updated;
+        } catch (Exception e) {
+            em.getTransaction().rollback();
+            logger.error("Error while updating AlbumArt: {}", e.getMessage());
+            throw e;
+        } finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+    public boolean deleteById(Integer id){
+        logger.debug("Deleting AlbumArt with id: {}", id);
+        EntityManager em = entityManagerFactory.createEntityManager();
+        em.getTransaction().begin();
+        try{
+            AlbumArt albumArt = em.find(AlbumArt.class, id);
+            if (albumArt == null) {
+                em.getTransaction().rollback();
+                return false;
+            }
+            em.remove(albumArt);
+            em.getTransaction().commit();
+            logger.debug("AlbumArt has been deleted successfully");
+            return true;
+        } catch (Exception e) {
+            em.getTransaction().rollback();
+            logger.error("Error while deleting AlbumArt: {}", e.getMessage());
+            throw e;
+        } finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+}

src/main/java/com/mediamanager/repository/AlbumHasArtistRepository.java

@@ -0,0 +1,85 @@
+package com.mediamanager.repository;
+
+
+import com.mediamanager.model.AlbumHasArtist;
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.EntityManagerFactory;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+
+import java.util.List;
+import java.util.Optional;
+
+public class AlbumHasArtistRepository {
+    private static final Logger logger = LogManager.getLogger(AlbumHasArtistRepository.class);
+
+    private final EntityManagerFactory entityManagerFactory;
+
+    public AlbumHasArtistRepository(EntityManagerFactory entityManagerFactory) {
+        this.entityManagerFactory = entityManagerFactory;
+    }
+
+    public AlbumHasArtist save(AlbumHasArtist albumHasArtist) {
+        logger.debug("Saving AlbumHasArtist: {}", albumHasArtist);
+        EntityManager em = entityManagerFactory.createEntityManager();
+        em.getTransaction().begin();
+        try {
+            em.persist(albumHasArtist);
+            em.getTransaction().commit();
+            logger.debug("AlbumHasArtist has been saved successfully");
+            return albumHasArtist;
+        } catch (Exception e) {
+            em.getTransaction().rollback();
+            logger.error("Error while saving AlbumHasArtist: {}", e.getMessage());
+            throw e;
+        } finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+    public List<AlbumHasArtist> findAll() {
+        logger.debug("Finding All AlbumHasArtist");
+        EntityManager em = entityManagerFactory.createEntityManager();
+        try{
+            return em.createQuery("select a from AlbumHasArtist a", AlbumHasArtist.class).getResultList();
+        }finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+    public Optional<AlbumHasArtist> findById(Integer id) {
+        logger.debug("Finding AlbumHasArtist with id: {}", id);
+        EntityManager em = entityManagerFactory.createEntityManager();
+        try{
+            AlbumHasArtist albumHasArtist = em.find(AlbumHasArtist.class, id);
+            return Optional.ofNullable(albumHasArtist);
+        }finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+    public boolean deleteById(Integer id){
+        logger.debug("Deleting AlbumHasArtist with id: {}", id);
+        EntityManager em = entityManagerFactory.createEntityManager();
+        em.getTransaction().begin();
+        try{
+            AlbumHasArtist albumHasArtist = em.find(AlbumHasArtist.class, id);
+            if (albumHasArtist == null) {
+                em.getTransaction().rollback();
+                return false;
+            }
+            em.remove(albumHasArtist);
+            em.getTransaction().commit();
+            logger.debug("AlbumHasArtist has been deleted successfully");
+            return true;
+        } catch (Exception e) {
+            em.getTransaction().rollback();
+            logger.error("Error while deleting AlbumHasArtist: {}", e.getMessage());
+            throw e;
+        } finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+}

src/main/java/com/mediamanager/repository/AlbumHasGenreRepository.java

@@ -0,0 +1,85 @@
+package com.mediamanager.repository;
+
+
+import com.mediamanager.model.AlbumHasGenre;
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.EntityManagerFactory;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+
+import java.util.List;
+import java.util.Optional;
+
+public class AlbumHasGenreRepository {
+    private static final Logger logger = LogManager.getLogger(AlbumHasGenreRepository.class);
+
+    private final EntityManagerFactory entityManagerFactory;
+
+    public AlbumHasGenreRepository(EntityManagerFactory entityManagerFactory) {
+        this.entityManagerFactory = entityManagerFactory;
+    }
+
+    public AlbumHasGenre save(AlbumHasGenre albumHasGenre) {
+        logger.debug("Saving AlbumHasGenre: {}", albumHasGenre);
+        EntityManager em = entityManagerFactory.createEntityManager();
+        em.getTransaction().begin();
+        try {
+            em.persist(albumHasGenre);
+            em.getTransaction().commit();
+            logger.debug("AlbumHasGenre has been saved successfully");
+            return albumHasGenre;
+        } catch (Exception e) {
+            em.getTransaction().rollback();
+            logger.error("Error while saving AlbumHasGenre: {}", e.getMessage());
+            throw e;
+        } finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+    public List<AlbumHasGenre> findAll() {
+        logger.debug("Finding All AlbumHasGenre");
+        EntityManager em = entityManagerFactory.createEntityManager();
+        try{
+            return em.createQuery("select a from AlbumHasGenre a", AlbumHasGenre.class).getResultList();
+        }finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+    public Optional<AlbumHasGenre> findById(Integer id) {
+        logger.debug("Finding AlbumHasGenre with id: {}", id);
+        EntityManager em = entityManagerFactory.createEntityManager();
+        try{
+            AlbumHasGenre albumHasGenre = em.find(AlbumHasGenre.class, id);
+            return Optional.ofNullable(albumHasGenre);
+        }finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+    public boolean deleteById(Integer id){
+        logger.debug("Deleting AlbumHasGenre with id: {}", id);
+        EntityManager em = entityManagerFactory.createEntityManager();
+        em.getTransaction().begin();
+        try{
+            AlbumHasGenre albumHasGenre = em.find(AlbumHasGenre.class, id);
+            if (albumHasGenre == null) {
+                em.getTransaction().rollback();
+                return false;
+            }
+            em.remove(albumHasGenre);
+            em.getTransaction().commit();
+            logger.debug("AlbumHasGenre has been deleted successfully");
+            return true;
+        } catch (Exception e) {
+            em.getTransaction().rollback();
+            logger.error("Error while deleting AlbumHasGenre: {}", e.getMessage());
+            throw e;
+        } finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+}

src/main/java/com/mediamanager/repository/AlbumRepository.java

@@ -0,0 +1,103 @@
+package com.mediamanager.repository;
+
+
+import com.mediamanager.model.Album;
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.EntityManagerFactory;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+
+import java.util.List;
+import java.util.Optional;
+
+public class AlbumRepository {
+    private static final Logger logger = LogManager.getLogger(AlbumRepository.class);
+
+    private final EntityManagerFactory entityManagerFactory;
+
+    public AlbumRepository(EntityManagerFactory entityManagerFactory) {
+        this.entityManagerFactory = entityManagerFactory;
+    }
+
+    public Album save(Album album) {
+        logger.debug("Saving Album: {}", album.getName());
+        EntityManager em = entityManagerFactory.createEntityManager();
+        em.getTransaction().begin();
+        try {
+            em.persist(album);
+            em.getTransaction().commit();
+            logger.debug("Album has been saved successfully");
+            return album;
+        } catch (Exception e) {
+            em.getTransaction().rollback();
+            logger.error("Error while saving Album: {}", e.getMessage());
+            throw e;
+        } finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+    public List<Album> findAll() {
+        logger.debug("Finding All Album");
+        EntityManager em = entityManagerFactory.createEntityManager();
+        try{
+            return em.createQuery("select a from Album a", Album.class).getResultList();
+        }finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+    public Optional<Album> findById(Integer id) {
+        logger.debug("Finding Album with id: {}", id);
+        EntityManager em = entityManagerFactory.createEntityManager();
+        try{
+            Album album = em.find(Album.class, id);
+            return Optional.ofNullable(album);
+        }finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+    public Album update(Album album) {
+        logger.debug("Updating Album: {}", album.getName());
+        EntityManager em = entityManagerFactory.createEntityManager();
+        em.getTransaction().begin();
+        try {
+            Album updated = em.merge(album);
+            em.getTransaction().commit();
+            logger.debug("Album has been updated successfully");
+            return updated;
+        } catch (Exception e) {
+            em.getTransaction().rollback();
+            logger.error("Error while updating Album: {}", e.getMessage());
+            throw e;
+        } finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+    public boolean deleteById(Integer id){
+        logger.debug("Deleting Album with id: {}", id);
+        EntityManager em = entityManagerFactory.createEntityManager();
+        em.getTransaction().begin();
+        try{
+            Album album = em.find(Album.class, id);
+            if (album == null) {
+                em.getTransaction().rollback();
+                return false;
+            }
+            em.remove(album);
+            em.getTransaction().commit();
+            logger.debug("Album has been deleted successfully");
+            return true;
+        } catch (Exception e) {
+            em.getTransaction().rollback();
+            logger.error("Error while deleting Album: {}", e.getMessage());
+            throw e;
+        } finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+}

src/main/java/com/mediamanager/repository/AlbumTypeRepository.java

@@ -0,0 +1,103 @@
+package com.mediamanager.repository;
+
+
+import com.mediamanager.model.AlbumType;
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.EntityManagerFactory;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+
+import java.util.List;
+import java.util.Optional;
+
+public class AlbumTypeRepository {
+    private static final Logger logger = LogManager.getLogger(AlbumTypeRepository.class);
+
+    private final EntityManagerFactory entityManagerFactory;
+
+    public AlbumTypeRepository(EntityManagerFactory entityManagerFactory) {
+        this.entityManagerFactory = entityManagerFactory;
+    }
+
+    public AlbumType save(AlbumType albumType) {
+        logger.debug("Saving AlbumType: {}", albumType.getValue());
+        EntityManager em = entityManagerFactory.createEntityManager();
+        em.getTransaction().begin();
+        try {
+            em.persist(albumType);
+            em.getTransaction().commit();
+            logger.debug("AlbumType has been saved successfully");
+            return albumType;
+        } catch (Exception e) {
+            em.getTransaction().rollback();
+            logger.error("Error while saving AlbumType: {}", e.getMessage());
+            throw e;
+        } finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+    public List<AlbumType> findAll() {
+        logger.debug("Finding All AlbumType");
+        EntityManager em = entityManagerFactory.createEntityManager();
+        try{
+            return em.createQuery("select a from AlbumType a", AlbumType.class).getResultList();
+        }finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+    public Optional<AlbumType> findById(Integer id) {
+        logger.debug("Finding AlbumType with id: {}", id);
+        EntityManager em = entityManagerFactory.createEntityManager();
+        try{
+            AlbumType albumType = em.find(AlbumType.class, id);
+            return Optional.ofNullable(albumType);
+        }finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+    public AlbumType update(AlbumType albumType) {
+        logger.debug("Updating AlbumType: {}", albumType.getValue());
+        EntityManager em = entityManagerFactory.createEntityManager();
+        em.getTransaction().begin();
+        try {
+            AlbumType updated = em.merge(albumType);
+            em.getTransaction().commit();
+            logger.debug("AlbumType has been updated successfully");
+            return updated;
+        } catch (Exception e) {
+            em.getTransaction().rollback();
+            logger.error("Error while updating AlbumType: {}", e.getMessage());
+            throw e;
+        } finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+    public boolean deleteById(Integer id){
+        logger.debug("Deleting AlbumType with id: {}", id);
+        EntityManager em = entityManagerFactory.createEntityManager();
+        em.getTransaction().begin();
+        try{
+            AlbumType albumType = em.find(AlbumType.class, id);
+            if (albumType == null) {
+                em.getTransaction().rollback();
+                return false;
+            }
+            em.remove(albumType);
+            em.getTransaction().commit();
+            logger.debug("AlbumType has been deleted successfully");
+            return true;
+        } catch (Exception e) {
+            em.getTransaction().rollback();
+            logger.error("Error while deleting AlbumType: {}", e.getMessage());
+            throw e;
+        } finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+}

src/main/java/com/mediamanager/repository/ArtistRepository.java

@@ -0,0 +1,104 @@
+package com.mediamanager.repository;
+import com.mediamanager.model.Artist;
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.EntityManagerFactory;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.List;
+import java.util.Optional;
+
+public class ArtistRepository {
+    private static final Logger logger = LogManager.getLogger(ArtistRepository.class);
+
+    private final EntityManagerFactory entityManagerFactory;
+
+    public ArtistRepository(EntityManagerFactory entityManagerFactory) {
+        this.entityManagerFactory = entityManagerFactory;
+    }
+
+    public Artist save(Artist artist){
+        logger.debug("Saving Artist: {}", artist.getName());
+        EntityManager em = entityManagerFactory.createEntityManager();
+        em.getTransaction().begin();
+        try {
+            em.persist(artist);
+            em.getTransaction().commit();
+            logger.debug("Artist saved with ID: {}", artist.getId());
+            return artist;
+        } catch (Exception e) {
+            em.getTransaction().rollback();
+            logger.error("Error saving Artist", e);
+            throw e;
+        } finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+    public List<Artist> findAll(){
+        logger.debug("Finding all Artists");
+        EntityManager em = entityManagerFactory.createEntityManager();
+        try {
+            return em
+                    .createQuery("SELECT a FROM Artist a ORDER BY a.name", Artist.class)
+                    .getResultList();
+        } finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+    public Optional<Artist> findById(Integer id){
+        logger.debug("Finding artist by ID: {}", id);
+        EntityManager em = entityManagerFactory.createEntityManager();
+        try {
+            Artist artist = em.find(Artist.class, id);
+            return Optional.ofNullable(artist);
+        } finally {
+            if (em.isOpen()) em.close();
+        }
+
+    }
+
+    public Artist update(Artist artist){
+        logger.debug("Updating artist ID: {}", artist.getId());
+        EntityManager em = entityManagerFactory.createEntityManager();
+        em.getTransaction().begin();
+        try {
+            Artist updated = em.merge(artist);
+            em.getTransaction().commit();
+            logger.debug("Artist updated successfully");
+            return updated;
+        } catch (Exception e) {
+            em.getTransaction().rollback();
+            logger.error("Error updating artist", e);
+            throw e;
+        } finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+    public boolean deleteById(Integer id){
+        logger.debug("Deleting Artist by ID: {}", id);
+        EntityManager em = entityManagerFactory.createEntityManager();
+        em.getTransaction().begin();
+        try {
+            Artist artist = em.find(Artist.class, id);
+            if (artist == null) {
+                em.getTransaction().rollback();
+                return false;
+            }
+            em.remove(artist);
+            em.getTransaction().commit();
+            logger.debug("Artist deleted successfully");
+            return true;
+        } catch (Exception e) {
+            em.getTransaction().rollback();
+            logger.error("Error deleting artist", e);
+            throw e;
+        } finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+        }
+
+

src/main/java/com/mediamanager/repository/BitDepthRepository.java

@@ -0,0 +1,100 @@
+package com.mediamanager.repository;
+
+import com.mediamanager.model.BitDepth;
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.EntityManagerFactory;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.List;
+import java.util.Optional;
+
+public class BitDepthRepository {
+    private static final Logger logger = LogManager.getLogger(BitDepthRepository.class);
+
+    private final EntityManagerFactory entityManagerFactory;
+
+    public BitDepthRepository(EntityManagerFactory entityManagerFactory) {
+        this.entityManagerFactory = entityManagerFactory;
+    }
+
+    public BitDepth save(BitDepth bitDepth) {
+        logger.debug("Saving BitDepth: {}", bitDepth.getValue());
+        EntityManager em = entityManagerFactory.createEntityManager();
+        em.getTransaction().begin();
+        try {
+            em.persist(bitDepth);
+            em.getTransaction().commit();
+            logger.debug("BitDepth saved with ID: {}", bitDepth.getId());
+            return bitDepth;
+        } catch (Exception e) {
+            em.getTransaction().rollback();
+            logger.error("Error saving BitDepth", e);
+            throw e;
+        } finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+    public List<BitDepth> findAll(){
+        logger.debug("Finding all BitDepths");
+        EntityManager em = entityManagerFactory.createEntityManager();
+        try{
+            return em.createQuery("SELECT b FROM BitDepth b ORDER BY b.value", BitDepth.class).getResultList();
+        }finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+    public Optional<BitDepth> findById(Integer id){
+        logger.debug("Finding BitDepth by ID: {}", id);
+        EntityManager em = entityManagerFactory.createEntityManager();
+        try{
+            BitDepth bitDepth = em.find(BitDepth.class, id);
+            return Optional.ofNullable(bitDepth);
+        }finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+    public BitDepth update(BitDepth bitDepth){
+        logger.debug("Updating BitDepth ID: {}", bitDepth.getId());
+        EntityManager em = entityManagerFactory.createEntityManager();
+        em.getTransaction().begin();
+        try{
+            BitDepth updated = em.merge(bitDepth);
+            em.getTransaction().commit();
+            logger.debug("BitDepth updated successfully");
+            return updated;
+        }catch (Exception e){
+            em.getTransaction().rollback();
+            logger.error("Error updating BitDepth", e);
+            throw e;
+        }finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+    public boolean deleteById(Integer id){
+        logger.debug("Deleting BitDepth by ID: {}", id);
+        EntityManager em = entityManagerFactory.createEntityManager();
+        em.getTransaction().begin();
+        try{
+           BitDepth bitDepth = em.find(BitDepth.class, id);
+           if (bitDepth == null) {
+               em.getTransaction().rollback();
+               return false;
+           }
+           em.remove(bitDepth);
+           em.getTransaction().commit();
+           logger.debug("BitDepth deleted successfully");
+           return true;
+        } catch (Exception e) {
+            em.getTransaction().rollback();
+            logger.error("Error deleting BitDepth", e);
+            throw e;
+        }finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+}

src/main/java/com/mediamanager/repository/BitRateRepository.java

@@ -0,0 +1,101 @@
+package com.mediamanager.repository;
+
+import com.mediamanager.model.BitRate;
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.EntityManagerFactory;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.List;
+import java.util.Optional;
+
+public class BitRateRepository {
+        private static final Logger logger = LogManager.getLogger(BitRateRepository.class);
+
+        private final EntityManagerFactory entityManagerFactory;
+
+        public BitRateRepository(EntityManagerFactory entityManagerFactory) {
+            this.entityManagerFactory = entityManagerFactory;
+        }
+
+        public BitRate save(BitRate bitRate) {
+            logger.debug("Saving BitRate: {}", bitRate.getValue());
+            EntityManager em = entityManagerFactory.createEntityManager();
+            em.getTransaction().begin();
+            try {
+                em.persist(bitRate);
+                em.getTransaction().commit();
+                logger.debug("BitRate saved with ID: {}", bitRate.getId());
+                return bitRate;
+            } catch (Exception e) {
+                em.getTransaction().rollback();
+                logger.error("Error saving BitRate", e);
+                throw e;
+            } finally {
+                if (em.isOpen()) em.close();
+            }
+        }
+
+     public List<BitRate> findAll(){
+            logger.debug("Finding all BitRates");
+            EntityManager em = entityManagerFactory.createEntityManager();
+            try{
+                return em.createQuery("SELECT b FROM BitRate b ORDER BY b.value", BitRate.class).getResultList();
+            }finally {
+                if (em.isOpen()) em.close();
+            }
+     }
+
+     public Optional<BitRate> findById(Integer id){
+        logger.debug("Finding BitRate by ID: {}", id);
+        EntityManager em = entityManagerFactory.createEntityManager();
+        try{
+            BitRate bitRate = em.find(BitRate.class, id);
+            return Optional.ofNullable(bitRate);
+        } finally {
+            if (em.isOpen()) em.close();
+        }
+     }
+
+     public BitRate update(BitRate bitRate){
+            logger.debug("Updating BitRate ID: {}", bitRate.getId());
+             EntityManager em = entityManagerFactory.createEntityManager();
+             em.getTransaction().begin();
+             try{
+                 BitRate updated = em.merge(bitRate);
+                 em.getTransaction().commit();
+                 logger.debug("BitRate updated with ID: {}", bitRate.getId());
+                 return updated;
+             } catch (Exception e) {
+                 em.getTransaction().rollback();
+                 logger.error("Error updating BitRate", e);
+                 throw e;
+             } finally {
+                 if (em.isOpen()) em.close();
+             }
+     }
+
+     public boolean deleteById(Integer id){
+        logger.debug("Deleting BitRate by ID: {}", id);
+        EntityManager em = entityManagerFactory.createEntityManager();
+        em.getTransaction().begin();
+        try{
+            BitRate bitRate = em.find(BitRate.class, id);
+            if (bitRate == null) {
+                em.getTransaction().rollback();
+                return false;
+            }
+            em.remove(bitRate);
+            em.getTransaction().commit();
+            logger.debug("BitRate deleted successfully");
+            return true;
+        } catch (Exception e) {
+            em.getTransaction().rollback();
+            logger.error("Error deleting BitRate", e);
+            throw e;
+        } finally {
+            if (em.isOpen()) em.close();
+        }
+
+     }
+}

src/main/java/com/mediamanager/repository/ComposerRepository.java

@@ -0,0 +1,102 @@
+package com.mediamanager.repository;
+
+import com.mediamanager.model.Composer;
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.EntityManagerFactory;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.List;
+import java.util.Optional;
+
+public class ComposerRepository {
+    private static final Logger logger = LogManager.getLogger(ComposerRepository.class);
+
+    private final EntityManagerFactory entityManagerFactory;
+
+    public ComposerRepository(EntityManagerFactory entityManagerFactory) {
+        this.entityManagerFactory = entityManagerFactory;
+    }
+
+    public Composer save(Composer composer) {
+        logger.debug("Saving composer: {}", composer.getName());
+        EntityManager em = entityManagerFactory.createEntityManager();
+        em.getTransaction().begin();
+        try{
+            //ToDo: Add Id Validation
+            //ToDo: Add to all Repositories
+            em.persist(composer);
+            em.getTransaction().commit();
+            logger.debug("Composer saved with IS: {}", composer.getId());
+            return composer;
+        } catch (Exception e) {
+            em.getTransaction().rollback();
+            logger.error("Error saving composer", e);
+            throw e;
+        }finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+    public List<Composer> findAll(){
+        logger.debug("Finding all composers");
+        EntityManager em = entityManagerFactory.createEntityManager();
+        try{
+            return em.createQuery("SELECT c FROM Composer c ORDER BY c.name", Composer.class).getResultList();
+        } finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+    public Optional<Composer> findById(Integer id){
+        logger.debug("Finding composer by ID: {}", id);
+        EntityManager em = entityManagerFactory.createEntityManager();
+        try{
+            Composer composer = em.find(Composer.class, id);
+            return Optional.ofNullable(composer);
+        } finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+    public Composer update(Composer composer){
+        logger.debug("Updating composer ID: {}", composer.getId());
+        EntityManager em = entityManagerFactory.createEntityManager();
+        em.getTransaction().begin();
+        try{
+            Composer updated = em.merge(composer);
+            em.getTransaction().commit();
+            logger.debug("Composer updated successfully");
+            return updated;
+        } catch (Exception e) {
+            em.getTransaction().rollback();
+            logger.error("Error updating composer", e);
+            throw e;
+        } finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+    public boolean deleteById(Integer id){
+        logger.debug("Deleting composer by ID: {}", id);
+        EntityManager em = entityManagerFactory.createEntityManager();
+        em.getTransaction().begin();
+        try{
+           Composer composer = em.find(Composer.class, id);
+           if (composer == null) {
+               em.getTransaction().rollback();
+               return false;
+           }
+           em.remove(composer);
+           em.getTransaction().commit();
+           logger.debug("Composer deleted successfully");
+           return true;
+        } catch (Exception e) {
+            em.getTransaction().rollback();
+            logger.error("Error deleting composer", e);
+            throw e;
+        }finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+}

src/main/java/com/mediamanager/repository/DiscRepository.java

@@ -0,0 +1,100 @@
+package com.mediamanager.repository;
+
+import com.mediamanager.model.Disc;
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.EntityManagerFactory;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.List;
+import java.util.Optional;
+
+public class DiscRepository {
+    private static final Logger logger = LogManager.getLogger(DiscRepository.class);
+
+    private final EntityManagerFactory entityManagerFactory;
+
+    public DiscRepository(EntityManagerFactory entityManagerFactory) {
+        this.entityManagerFactory = entityManagerFactory;
+    }
+
+    public Disc save(Disc disc) {
+        logger.debug("Saving Disc: {}", disc.getDiscNumber());
+        EntityManager em = entityManagerFactory.createEntityManager();
+        em.getTransaction().begin();
+        try {
+            em.persist(disc);
+            em.getTransaction().commit();
+            logger.debug("Disc has been saved successfully");
+            return disc;
+        } catch (Exception e) {
+            em.getTransaction().rollback();
+            logger.error("Error while saving Disc: {}", e.getMessage());
+            throw e;
+        } finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+    public List<Disc> findAll() {
+        logger.debug("Finding All Disc");
+        EntityManager em = entityManagerFactory.createEntityManager();
+        try{
+            return em.createQuery("select d from Disc d", Disc.class).getResultList();
+        }finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+    public Optional<Disc> findById(Integer id) {
+        logger.debug("Finding Disc with id: {}", id);
+        EntityManager em = entityManagerFactory.createEntityManager();
+        try{
+            Disc disc = em.find(Disc.class, id);
+            return Optional.ofNullable(disc);
+        }finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+    public Disc update(Disc disc) {
+        logger.debug("Updating Disc: {}", disc.getDiscNumber());
+        EntityManager em = entityManagerFactory.createEntityManager();
+        em.getTransaction().begin();
+        try {
+            Disc updated = em.merge(disc);
+            em.getTransaction().commit();
+            logger.debug("Disc has been updated successfully");
+            return updated;
+        } catch (Exception e) {
+            em.getTransaction().rollback();
+            logger.error("Error while updating Disc: {}", e.getMessage());
+            throw e;
+        } finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+    public boolean deleteById(Integer id){
+        logger.debug("Deleting Disc with id: {}", id);
+        EntityManager em = entityManagerFactory.createEntityManager();
+        em.getTransaction().begin();
+        try{
+            Disc disc = em.find(Disc.class, id);
+            if (disc == null) {
+                em.getTransaction().rollback();
+                return false;
+            }
+            em.remove(disc);
+            em.getTransaction().commit();
+            logger.debug("Disc has been deleted successfully");
+            return true;
+        } catch (Exception e) {
+            em.getTransaction().rollback();
+            logger.error("Error while deleting Disc: {}", e.getMessage());
+            throw e;
+        } finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+}

src/main/java/com/mediamanager/repository/GenreRepository.java

@@ -0,0 +1,121 @@
+package com.mediamanager.repository;
+
+import com.mediamanager.model.Genre;
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.EntityManagerFactory;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * Repository para acesso a dados de Genre
+ * Encapsula todas as operações de banco de dados
+ */
+public class GenreRepository {
+    private static final Logger logger = LogManager.getLogger(GenreRepository.class);
+
+    private final EntityManagerFactory entityManagerFactory;
+
+    public GenreRepository(EntityManagerFactory entityManagerFactory) {
+        this.entityManagerFactory = entityManagerFactory;
+    }
+
+    /**
+     * Salva um novo genre
+     */
+    public Genre save(Genre genre) {
+        logger.debug("Saving genre: {}", genre.getName());
+        EntityManager em = entityManagerFactory.createEntityManager();
+        em.getTransaction().begin();
+        try {
+            em.persist(genre);
+            em.getTransaction().commit();
+            logger.debug("Genre saved with ID: {}", genre.getId());
+            return genre;
+        } catch (Exception e) {
+            em.getTransaction().rollback();
+            logger.error("Error saving genre", e);
+            throw e;
+        } finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+    /**
+     * Busca todos os genres
+     */
+    public List<Genre> findAll() {
+        logger.debug("Finding all genres");
+        EntityManager em = entityManagerFactory.createEntityManager();
+        try {
+            return em
+                    .createQuery("SELECT g FROM Genre g ORDER BY g.name", Genre.class)
+                    .getResultList();
+        } finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+    /**
+     * Busca genre por ID
+     */
+    public Optional<Genre> findById(Integer id) {
+        logger.debug("Finding genre by ID: {}", id);
+        EntityManager em = entityManagerFactory.createEntityManager();
+        try {
+            Genre genre = em.find(Genre.class, id);
+            return Optional.ofNullable(genre);
+        } finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+    /**
+     * Atualiza um genre existente
+     */
+    public Genre update(Genre genre) {
+        logger.debug("Updating genre ID: {}", genre.getId());
+        EntityManager em = entityManagerFactory.createEntityManager();
+        em.getTransaction().begin();
+        try {
+            Genre updated = em.merge(genre);
+            em.getTransaction().commit();
+            logger.debug("Genre updated successfully");
+            return updated;
+        } catch (Exception e) {
+            em.getTransaction().rollback();
+            logger.error("Error updating genre", e);
+            throw e;
+        } finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+    /**
+     * Deleta um genre por ID
+     */
+    public boolean deleteById(Integer id) {
+        logger.debug("Deleting genre by ID: {}", id);
+        EntityManager em = entityManagerFactory.createEntityManager();
+        em.getTransaction().begin();
+        try {
+            Genre genre = em.find(Genre.class, id);
+            if (genre == null) {
+                em.getTransaction().rollback();
+                return false;
+            }
+            em.remove(genre);
+            em.getTransaction().commit();
+            logger.debug("Genre deleted successfully");
+            return true;
+        } catch (Exception e) {
+            em.getTransaction().rollback();
+            logger.error("Error deleting genre", e);
+            throw e;
+        } finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+}

src/main/java/com/mediamanager/repository/SamplingRateRepository.java

@@ -0,0 +1,103 @@
+package com.mediamanager.repository;
+
+
+import com.mediamanager.model.SamplingRate;
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.EntityManagerFactory;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+
+import java.util.List;
+import java.util.Optional;
+
+public class SamplingRateRepository {
+    private static final Logger logger = LogManager.getLogger(SamplingRateRepository.class);
+
+    private final EntityManagerFactory entityManagerFactory;
+
+    public SamplingRateRepository(EntityManagerFactory entityManagerFactory) {
+        this.entityManagerFactory = entityManagerFactory;
+    }
+
+    public SamplingRate save(SamplingRate samplingRate) {
+        logger.debug("Saving SamplingRate: {}", samplingRate.getValue());
+        EntityManager em = entityManagerFactory.createEntityManager();
+        em.getTransaction().begin();
+        try {
+            em.persist(samplingRate);
+            em.getTransaction().commit();
+            logger.debug("SamplingRate has been saved successfully");
+            return samplingRate;
+        } catch (Exception e) {
+            em.getTransaction().rollback();
+            logger.error("Error while saving SamplingRate: {}", e.getMessage());
+            throw e;
+        } finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+    public List<SamplingRate> findAll() {
+        logger.debug("Finding All SamplingRate");
+        EntityManager em = entityManagerFactory.createEntityManager();
+        try{
+            return em.createQuery("select s from SamplingRate s", SamplingRate.class).getResultList();
+        }finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+    public Optional<SamplingRate> findById(Integer id) {
+        logger.debug("Finding SamplingRate with id: {}", id);
+        EntityManager em = entityManagerFactory.createEntityManager();
+        try{
+            SamplingRate samplingRate = em.find(SamplingRate.class, id);
+            return Optional.ofNullable(samplingRate);
+        }finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+    public SamplingRate update(SamplingRate samplingRate) {
+        logger.debug("Updating SamplingRate: {}", samplingRate.getValue());
+        EntityManager em = entityManagerFactory.createEntityManager();
+        em.getTransaction().begin();
+        try {
+            SamplingRate updated = em.merge(samplingRate);
+            em.getTransaction().commit();
+            logger.debug("SamplingRate has been updated successfully");
+            return updated;
+        } catch (Exception e) {
+            em.getTransaction().rollback();
+            logger.error("Error while updating SamplingRate: {}", e.getMessage());
+            throw e;
+        } finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+    public boolean deleteById(Integer id){
+        logger.debug("Deleting SamplingRate with id: {}", id);
+        EntityManager em = entityManagerFactory.createEntityManager();
+        em.getTransaction().begin();
+        try{
+            SamplingRate samplingRate = em.find(SamplingRate.class, id);
+            if (samplingRate == null) {
+                em.getTransaction().rollback();
+                return false;
+            }
+            em.remove(samplingRate);
+            em.getTransaction().commit();
+            logger.debug("SamplingRate has been deleted successfully");
+            return true;
+        } catch (Exception e) {
+            em.getTransaction().rollback();
+            logger.error("Error while deleting SamplingRate: {}", e.getMessage());
+            throw e;
+        } finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+}

src/main/java/com/mediamanager/repository/TrackHasArtistRepository.java

@@ -0,0 +1,85 @@
+package com.mediamanager.repository;
+
+
+import com.mediamanager.model.TrackHasArtist;
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.EntityManagerFactory;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+
+import java.util.List;
+import java.util.Optional;
+
+public class TrackHasArtistRepository {
+    private static final Logger logger = LogManager.getLogger(TrackHasArtistRepository.class);
+
+    private final EntityManagerFactory entityManagerFactory;
+
+    public TrackHasArtistRepository(EntityManagerFactory entityManagerFactory) {
+        this.entityManagerFactory = entityManagerFactory;
+    }
+
+    public TrackHasArtist save(TrackHasArtist trackHasArtist) {
+        logger.debug("Saving TrackHasArtist: {}", trackHasArtist);
+        EntityManager em = entityManagerFactory.createEntityManager();
+        em.getTransaction().begin();
+        try {
+            em.persist(trackHasArtist);
+            em.getTransaction().commit();
+            logger.debug("TrackHasArtist has been saved successfully");
+            return trackHasArtist;
+        } catch (Exception e) {
+            em.getTransaction().rollback();
+            logger.error("Error while saving TrackHasArtist: {}", e.getMessage());
+            throw e;
+        } finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+    public List<TrackHasArtist> findAll() {
+        logger.debug("Finding All TrackHasArtist");
+        EntityManager em = entityManagerFactory.createEntityManager();
+        try{
+            return em.createQuery("select t from TrackHasArtist t", TrackHasArtist.class).getResultList();
+        }finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+    public Optional<TrackHasArtist> findById(Integer id) {
+        logger.debug("Finding TrackHasArtist with id: {}", id);
+        EntityManager em = entityManagerFactory.createEntityManager();
+        try{
+            TrackHasArtist trackHasArtist = em.find(TrackHasArtist.class, id);
+            return Optional.ofNullable(trackHasArtist);
+        }finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+    public boolean deleteById(Integer id){
+        logger.debug("Deleting TrackHasArtist with id: {}", id);
+        EntityManager em = entityManagerFactory.createEntityManager();
+        em.getTransaction().begin();
+        try{
+            TrackHasArtist trackHasArtist = em.find(TrackHasArtist.class, id);
+            if (trackHasArtist == null) {
+                em.getTransaction().rollback();
+                return false;
+            }
+            em.remove(trackHasArtist);
+            em.getTransaction().commit();
+            logger.debug("TrackHasArtist has been deleted successfully");
+            return true;
+        } catch (Exception e) {
+            em.getTransaction().rollback();
+            logger.error("Error while deleting TrackHasArtist: {}", e.getMessage());
+            throw e;
+        } finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+}

src/main/java/com/mediamanager/repository/TrackHasComposerRepository.java

@@ -0,0 +1,85 @@
+package com.mediamanager.repository;
+
+
+import com.mediamanager.model.TrackHasComposer;
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.EntityManagerFactory;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+
+import java.util.List;
+import java.util.Optional;
+
+public class TrackHasComposerRepository {
+    private static final Logger logger = LogManager.getLogger(TrackHasComposerRepository.class);
+
+    private final EntityManagerFactory entityManagerFactory;
+
+    public TrackHasComposerRepository(EntityManagerFactory entityManagerFactory) {
+        this.entityManagerFactory = entityManagerFactory;
+    }
+
+    public TrackHasComposer save(TrackHasComposer trackHasComposer) {
+        logger.debug("Saving TrackHasComposer: {}", trackHasComposer);
+        EntityManager em = entityManagerFactory.createEntityManager();
+        em.getTransaction().begin();
+        try {
+            em.persist(trackHasComposer);
+            em.getTransaction().commit();
+            logger.debug("TrackHasComposer has been saved successfully");
+            return trackHasComposer;
+        } catch (Exception e) {
+            em.getTransaction().rollback();
+            logger.error("Error while saving TrackHasComposer: {}", e.getMessage());
+            throw e;
+        } finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+    public List<TrackHasComposer> findAll() {
+        logger.debug("Finding All TrackHasComposer");
+        EntityManager em = entityManagerFactory.createEntityManager();
+        try{
+            return em.createQuery("select t from TrackHasComposer t", TrackHasComposer.class).getResultList();
+        }finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+    public Optional<TrackHasComposer> findById(Integer id) {
+        logger.debug("Finding TrackHasComposer with id: {}", id);
+        EntityManager em = entityManagerFactory.createEntityManager();
+        try{
+            TrackHasComposer trackHasComposer = em.find(TrackHasComposer.class, id);
+            return Optional.ofNullable(trackHasComposer);
+        }finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+    public boolean deleteById(Integer id){
+        logger.debug("Deleting TrackHasComposer with id: {}", id);
+        EntityManager em = entityManagerFactory.createEntityManager();
+        em.getTransaction().begin();
+        try{
+            TrackHasComposer trackHasComposer = em.find(TrackHasComposer.class, id);
+            if (trackHasComposer == null) {
+                em.getTransaction().rollback();
+                return false;
+            }
+            em.remove(trackHasComposer);
+            em.getTransaction().commit();
+            logger.debug("TrackHasComposer has been deleted successfully");
+            return true;
+        } catch (Exception e) {
+            em.getTransaction().rollback();
+            logger.error("Error while deleting TrackHasComposer: {}", e.getMessage());
+            throw e;
+        } finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+}

src/main/java/com/mediamanager/repository/TrackHasGenreRepository.java

@@ -0,0 +1,85 @@
+package com.mediamanager.repository;
+
+
+import com.mediamanager.model.TrackHasGenre;
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.EntityManagerFactory;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+
+import java.util.List;
+import java.util.Optional;
+
+public class TrackHasGenreRepository {
+    private static final Logger logger = LogManager.getLogger(TrackHasGenreRepository.class);
+
+    private final EntityManagerFactory entityManagerFactory;
+
+    public TrackHasGenreRepository(EntityManagerFactory entityManagerFactory) {
+        this.entityManagerFactory = entityManagerFactory;
+    }
+
+    public TrackHasGenre save(TrackHasGenre trackHasGenre) {
+        logger.debug("Saving TrackHasGenre: {}", trackHasGenre);
+        EntityManager em = entityManagerFactory.createEntityManager();
+        em.getTransaction().begin();
+        try {
+            em.persist(trackHasGenre);
+            em.getTransaction().commit();
+            logger.debug("TrackHasGenre has been saved successfully");
+            return trackHasGenre;
+        } catch (Exception e) {
+            em.getTransaction().rollback();
+            logger.error("Error while saving TrackHasGenre: {}", e.getMessage());
+            throw e;
+        } finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+    public List<TrackHasGenre> findAll() {
+        logger.debug("Finding All TrackHasGenre");
+        EntityManager em = entityManagerFactory.createEntityManager();
+        try{
+            return em.createQuery("select t from TrackHasGenre t", TrackHasGenre.class).getResultList();
+        }finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+    public Optional<TrackHasGenre> findById(Integer id) {
+        logger.debug("Finding TrackHasGenre with id: {}", id);
+        EntityManager em = entityManagerFactory.createEntityManager();
+        try{
+            TrackHasGenre trackHasGenre = em.find(TrackHasGenre.class, id);
+            return Optional.ofNullable(trackHasGenre);
+        }finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+    public boolean deleteById(Integer id){
+        logger.debug("Deleting TrackHasGenre with id: {}", id);
+        EntityManager em = entityManagerFactory.createEntityManager();
+        em.getTransaction().begin();
+        try{
+            TrackHasGenre trackHasGenre = em.find(TrackHasGenre.class, id);
+            if (trackHasGenre == null) {
+                em.getTransaction().rollback();
+                return false;
+            }
+            em.remove(trackHasGenre);
+            em.getTransaction().commit();
+            logger.debug("TrackHasGenre has been deleted successfully");
+            return true;
+        } catch (Exception e) {
+            em.getTransaction().rollback();
+            logger.error("Error while deleting TrackHasGenre: {}", e.getMessage());
+            throw e;
+        } finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+}

src/main/java/com/mediamanager/repository/TrackRepository.java

@@ -0,0 +1,100 @@
+package com.mediamanager.repository;
+
+import com.mediamanager.model.Track;
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.EntityManagerFactory;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.List;
+import java.util.Optional;
+
+public class TrackRepository {
+    private static final Logger logger = LogManager.getLogger(TrackRepository.class);
+
+    private final EntityManagerFactory entityManagerFactory;
+
+    public TrackRepository(EntityManagerFactory entityManagerFactory) {
+        this.entityManagerFactory = entityManagerFactory;
+    }
+
+    public Track save(Track track) {
+        logger.debug("Saving Track: {}", track.getTitle());
+        EntityManager em = entityManagerFactory.createEntityManager();
+        em.getTransaction().begin();
+        try {
+            em.persist(track);
+            em.getTransaction().commit();
+            logger.debug("Track has been saved successfully");
+            return track;
+        } catch (Exception e) {
+            em.getTransaction().rollback();
+            logger.error("Error while saving Track: {}", e.getMessage());
+            throw e;
+        } finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+    public List<Track> findAll() {
+        logger.debug("Finding All Track");
+        EntityManager em = entityManagerFactory.createEntityManager();
+        try{
+            return em.createQuery("select t from Track t", Track.class).getResultList();
+        }finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+    public Optional<Track> findById(Integer id) {
+        logger.debug("Finding Track with id: {}", id);
+        EntityManager em = entityManagerFactory.createEntityManager();
+        try{
+            Track track = em.find(Track.class, id);
+            return Optional.ofNullable(track);
+        }finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+    public Track update(Track track) {
+        logger.debug("Updating Track: {}", track.getTitle());
+        EntityManager em = entityManagerFactory.createEntityManager();
+        em.getTransaction().begin();
+        try {
+            Track updated = em.merge(track);
+            em.getTransaction().commit();
+            logger.debug("Track has been updated successfully");
+            return updated;
+        } catch (Exception e) {
+            em.getTransaction().rollback();
+            logger.error("Error while updating Track: {}", e.getMessage());
+            throw e;
+        } finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+    public boolean deleteById(Integer id){
+        logger.debug("Deleting Track with id: {}", id);
+        EntityManager em = entityManagerFactory.createEntityManager();
+        em.getTransaction().begin();
+        try{
+            Track track = em.find(Track.class, id);
+            if (track == null) {
+                em.getTransaction().rollback();
+                return false;
+            }
+            em.remove(track);
+            em.getTransaction().commit();
+            logger.debug("Track has been deleted successfully");
+            return true;
+        } catch (Exception e) {
+            em.getTransaction().rollback();
+            logger.error("Error while deleting Track: {}", e.getMessage());
+            throw e;
+        } finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+}

src/main/java/com/mediamanager/service/album/AlbumService.java

@@ -0,0 +1,153 @@
+package com.mediamanager.service.album;
+
+import com.mediamanager.model.Album;
+import com.mediamanager.model.AlbumArt;
+import com.mediamanager.model.AlbumType;
+import com.mediamanager.repository.AlbumRepository;
+import com.mediamanager.repository.AlbumArtRepository;
+import com.mediamanager.repository.AlbumTypeRepository;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.List;
+import java.util.Optional;
+
+public class AlbumService {
+    private static final Logger logger = LogManager.getLogger(AlbumService.class);
+    private final AlbumRepository repository;
+    private final AlbumTypeRepository albumTypeRepository;
+    private final AlbumArtRepository albumArtRepository;
+
+    public AlbumService(AlbumRepository repository, AlbumTypeRepository albumTypeRepository, AlbumArtRepository albumArtRepository) {
+        this.repository = repository;
+        this.albumTypeRepository = albumTypeRepository;
+        this.albumArtRepository = albumArtRepository;
+    }
+
+    public Album createAlbum(String name, Integer year, Integer numberOfDiscs, String code, Boolean isCompilation, Integer albumTypeId, Integer albumArtId) {
+        logger.debug("Creating album:{}", name);
+        if (name == null || name.trim().isEmpty()) {
+            throw new IllegalArgumentException("Album name cannot be null or empty");
+        }
+
+        Album album = new Album();
+        album.setName(name);
+        album.setYear(year);
+        album.setNumberOfDiscs(numberOfDiscs);
+        album.setCode(code);
+        album.setIsCompilation(isCompilation);
+
+        // Set AlbumType if provided
+        if (albumTypeId != null && albumTypeId > 0) {
+            Optional<AlbumType> albumType = albumTypeRepository.findById(albumTypeId);
+            if (albumType.isEmpty()) {
+                throw new IllegalArgumentException("AlbumType not found with id: " + albumTypeId);
+            }
+            album.setAlbumType(albumType.get());
+        }
+
+        // Set AlbumArt if provided
+        if (albumArtId != null && albumArtId > 0) {
+            Optional<AlbumArt> albumArt = albumArtRepository.findById(albumArtId);
+            if (albumArt.isEmpty()) {
+                throw new IllegalArgumentException("AlbumArt not found with id: " + albumArtId);
+            }
+            album.setAlbumArt(albumArt.get());
+        }
+
+        return repository.save(album);
+    }
+
+    public List<Album> getAllAlbums() {
+        logger.info("Getting all albums");
+        return repository.findAll();
+    }
+
+    public Optional<Album> getAlbumById(Integer id) {
+        if (id == null) {
+            throw new IllegalArgumentException("ID cannot be null");
+        }
+        logger.info("Getting album by id:{}", id);
+        return repository.findById(id);
+    }
+
+    public Optional<Album> updateAlbum(Integer id, String name, Integer year,
+                                       Integer numberOfDiscs, String code,
+                                       Boolean isCompilation, Integer albumTypeId,
+                                       Integer albumArtId,
+                                       boolean updateYear,          // ← Novo!
+                                       boolean updateNumberOfDiscs, // ← Novo!
+                                       boolean updateAlbumType,     // ← Novo!
+                                       boolean updateAlbumArt) {    // ← Novo!
+        if (id == null) {
+            throw new IllegalArgumentException("ID cannot be null");
+        }
+        logger.info("Updating album: {}", name);
+        if (name == null || name.trim().isEmpty()) {
+            throw new IllegalArgumentException("Album name cannot be null or empty");
+        }
+
+        Optional<Album> existingAlbum = repository.findById(id);
+        if (existingAlbum.isEmpty()) {
+            logger.warn("Album not found with id: {}", id);
+            return Optional.empty();
+        }
+
+        Album album = existingAlbum.get();
+        album.setName(name);
+        album.setCode(code);
+        album.setIsCompilation(isCompilation);
+
+        // Atualiza year SOMENTE se o campo foi fornecido
+        if (updateYear) {
+            album.setYear(year);
+        }
+
+        // Atualiza numberOfDiscs SOMENTE se o campo foi fornecido
+        if (updateNumberOfDiscs) {
+            album.setNumberOfDiscs(numberOfDiscs);
+        }
+
+        // Update AlbumType SOMENTE se o campo foi fornecido
+        if (updateAlbumType) {
+            if (albumTypeId != null && albumTypeId > 0) {
+                Optional<AlbumType> albumType = albumTypeRepository.findById(albumTypeId);
+                if (albumType.isEmpty()) {
+                    throw new IllegalArgumentException("AlbumType not found with id: " + albumTypeId);
+                }
+                album.setAlbumType(albumType.get());
+            } else {
+                // Explicitamente passado como 0 ou null = remover a relação
+                album.setAlbumType(null);
+            }
+        }
+        // Se não foi fornecido, mantém o existente
+
+        // Update AlbumArt SOMENTE se o campo foi fornecido
+        if (updateAlbumArt) {
+            if (albumArtId != null && albumArtId > 0) {
+                Optional<AlbumArt> albumArt = albumArtRepository.findById(albumArtId);
+                if (albumArt.isEmpty()) {
+                    throw new IllegalArgumentException("AlbumArt not found with id: " + albumArtId);
+                }
+                album.setAlbumArt(albumArt.get());
+            } else {
+                // Explicitamente passado como 0 ou null = remover a relação
+                album.setAlbumArt(null);
+            }
+        }
+        // Se não foi fornecido, mantém o existente
+
+        Album updatedAlbum = repository.update(album);
+        return Optional.of(updatedAlbum);
+    }
+
+    public boolean deleteAlbum(Integer id) {
+        if (id == null) {
+            throw new IllegalArgumentException("Album id cannot be null");
+        }
+        logger.info("Deleting album:{}", id);
+        return repository.deleteById(id);
+    }
+
+}

src/main/java/com/mediamanager/service/albumart/AlbumArtService.java

@@ -0,0 +1,69 @@
+package com.mediamanager.service.albumart;
+
+import com.mediamanager.model.AlbumArt;
+import com.mediamanager.repository.AlbumArtRepository;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.List;
+import java.util.Optional;
+
+public class AlbumArtService {
+    private static final Logger logger = LogManager.getLogger(AlbumArtService.class);
+    private final AlbumArtRepository repository;
+
+    public AlbumArtService(AlbumArtRepository repository) {
+        this.repository = repository;
+    }
+
+    public AlbumArt createAlbumArt(String filepath) {
+        logger.debug("Creating album art:{}", filepath);
+        if (filepath == null || filepath.trim().isEmpty()) {
+            throw new IllegalArgumentException("AlbumArt filepath cannot be null or empty");
+        }
+        AlbumArt albumArt = new AlbumArt();
+        albumArt.setFilepath(filepath);
+        return repository.save(albumArt);
+    }
+
+    public List<AlbumArt> getAllAlbumArts() {
+        logger.info("Getting all album arts");
+        return repository.findAll();
+    }
+
+    public Optional<AlbumArt> getAlbumArtById(Integer id) {
+        if (id == null) {
+            throw new IllegalArgumentException("ID cannot be null");
+        }
+        logger.info("Getting album art by id:{}", id);
+        return repository.findById(id);
+    }
+
+    public Optional<AlbumArt> updateAlbumArt(Integer id, String filepath) {
+        if (id == null) {
+            throw new IllegalArgumentException("ID cannot be null");
+        }
+        logger.info("Updating album art:{}", filepath);
+        if (filepath == null || filepath.trim().isEmpty()) {
+            throw new IllegalArgumentException("AlbumArt filepath cannot be null or empty");
+        }
+        Optional<AlbumArt> existingAlbumArt = repository.findById(id);
+        if(existingAlbumArt.isEmpty()) {
+            logger.warn("Album art not found with id:{}", id);
+            return Optional.empty();
+        }
+        AlbumArt albumArt = existingAlbumArt.get();
+        albumArt.setFilepath(filepath);
+        AlbumArt updatedAlbumArt = repository.update(albumArt);
+        return Optional.of(updatedAlbumArt);
+    }
+
+    public boolean deleteAlbumArt(Integer id) {
+        if (id == null) {
+            throw new IllegalArgumentException("Album art id cannot be null");
+        }
+        logger.info("Deleting album art:{}", id);
+        return repository.deleteById(id);
+    }
+
+}

src/main/java/com/mediamanager/service/albumhasartist/AlbumHasArtistService.java

@@ -0,0 +1,77 @@
+package com.mediamanager.service.albumhasartist;
+
+import com.mediamanager.model.Album;
+import com.mediamanager.model.AlbumHasArtist;
+import com.mediamanager.model.Artist;
+import com.mediamanager.repository.AlbumHasArtistRepository;
+import com.mediamanager.repository.AlbumRepository;
+import com.mediamanager.repository.ArtistRepository;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.List;
+import java.util.Optional;
+
+public class AlbumHasArtistService {
+    private static final Logger logger = LogManager.getLogger(AlbumHasArtistService.class);
+    private final AlbumHasArtistRepository repository;
+    private final AlbumRepository albumRepository;
+    private final ArtistRepository artistRepository;
+
+    public AlbumHasArtistService(AlbumHasArtistRepository repository, AlbumRepository albumRepository, ArtistRepository artistRepository) {
+        this.repository = repository;
+        this.albumRepository = albumRepository;
+        this.artistRepository = artistRepository;
+    }
+
+    public AlbumHasArtist createAlbumHasArtist(Integer albumId, Integer artistId) {
+        logger.debug("Creating album has artist relationship - albumId:{}, artistId:{}", albumId, artistId);
+
+        if (albumId == null || albumId <= 0) {
+            throw new IllegalArgumentException("Album ID cannot be null or invalid");
+        }
+        if (artistId == null || artistId <= 0) {
+            throw new IllegalArgumentException("Artist ID cannot be null or invalid");
+        }
+
+        // Verify Album exists
+        Optional<Album> album = albumRepository.findById(albumId);
+        if (album.isEmpty()) {
+            throw new IllegalArgumentException("Album not found with id: " + albumId);
+        }
+
+        // Verify Artist exists
+        Optional<Artist> artist = artistRepository.findById(artistId);
+        if (artist.isEmpty()) {
+            throw new IllegalArgumentException("Artist not found with id: " + artistId);
+        }
+
+        AlbumHasArtist albumHasArtist = new AlbumHasArtist();
+        albumHasArtist.setAlbum(album.get());
+        albumHasArtist.setArtist(artist.get());
+
+        return repository.save(albumHasArtist);
+    }
+
+    public List<AlbumHasArtist> getAllAlbumHasArtists() {
+        logger.info("Getting all album has artist relationships");
+        return repository.findAll();
+    }
+
+    public Optional<AlbumHasArtist> getAlbumHasArtistById(Integer id) {
+        if (id == null) {
+            throw new IllegalArgumentException("ID cannot be null");
+        }
+        logger.info("Getting album has artist by id:{}", id);
+        return repository.findById(id);
+    }
+
+    public boolean deleteAlbumHasArtist(Integer id) {
+        if (id == null) {
+            throw new IllegalArgumentException("Album has artist id cannot be null");
+        }
+        logger.info("Deleting album has artist:{}", id);
+        return repository.deleteById(id);
+    }
+
+}

src/main/java/com/mediamanager/service/albumhasgenre/AlbumHasGenreService.java

@@ -0,0 +1,77 @@
+package com.mediamanager.service.albumhasgenre;
+
+import com.mediamanager.model.Album;
+import com.mediamanager.model.AlbumHasGenre;
+import com.mediamanager.model.Genre;
+import com.mediamanager.repository.AlbumHasGenreRepository;
+import com.mediamanager.repository.AlbumRepository;
+import com.mediamanager.repository.GenreRepository;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.List;
+import java.util.Optional;
+
+public class AlbumHasGenreService {
+    private static final Logger logger = LogManager.getLogger(AlbumHasGenreService.class);
+    private final AlbumHasGenreRepository repository;
+    private final AlbumRepository albumRepository;
+    private final GenreRepository genreRepository;
+
+    public AlbumHasGenreService(AlbumHasGenreRepository repository, AlbumRepository albumRepository, GenreRepository genreRepository) {
+        this.repository = repository;
+        this.albumRepository = albumRepository;
+        this.genreRepository = genreRepository;
+    }
+
+    public AlbumHasGenre createAlbumHasGenre(Integer albumId, Integer genreId) {
+        logger.debug("Creating album has genre relationship - albumId:{}, genreId:{}", albumId, genreId);
+
+        if (albumId == null || albumId <= 0) {
+            throw new IllegalArgumentException("Album ID cannot be null or invalid");
+        }
+        if (genreId == null || genreId <= 0) {
+            throw new IllegalArgumentException("Genre ID cannot be null or invalid");
+        }
+
+        // Verify Album exists
+        Optional<Album> album = albumRepository.findById(albumId);
+        if (album.isEmpty()) {
+            throw new IllegalArgumentException("Album not found with id: " + albumId);
+        }
+
+        // Verify Genre exists
+        Optional<Genre> genre = genreRepository.findById(genreId);
+        if (genre.isEmpty()) {
+            throw new IllegalArgumentException("Genre not found with id: " + genreId);
+        }
+
+        AlbumHasGenre albumHasGenre = new AlbumHasGenre();
+        albumHasGenre.setAlbum(album.get());
+        albumHasGenre.setGenre(genre.get());
+
+        return repository.save(albumHasGenre);
+    }
+
+    public List<AlbumHasGenre> getAllAlbumHasGenres() {
+        logger.info("Getting all album has genre relationships");
+        return repository.findAll();
+    }
+
+    public Optional<AlbumHasGenre> getAlbumHasGenreById(Integer id) {
+        if (id == null) {
+            throw new IllegalArgumentException("ID cannot be null");
+        }
+        logger.info("Getting album has genre by id:{}", id);
+        return repository.findById(id);
+    }
+
+    public boolean deleteAlbumHasGenre(Integer id) {
+        if (id == null) {
+            throw new IllegalArgumentException("Album has genre id cannot be null");
+        }
+        logger.info("Deleting album has genre:{}", id);
+        return repository.deleteById(id);
+    }
+
+}

src/main/java/com/mediamanager/service/albumtype/AlbumTypeService.java

@@ -0,0 +1,69 @@
+package com.mediamanager.service.albumtype;
+
+import com.mediamanager.model.AlbumType;
+import com.mediamanager.repository.AlbumTypeRepository;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.List;
+import java.util.Optional;
+
+public class AlbumTypeService {
+    private static final Logger logger = LogManager.getLogger(AlbumTypeService.class);
+    private final AlbumTypeRepository repository;
+
+    public AlbumTypeService(AlbumTypeRepository repository) {
+        this.repository = repository;
+    }
+
+    public AlbumType createAlbumType(String value) {
+        logger.debug("Creating album type:{}", value);
+        if (value == null || value.trim().isEmpty()) {
+            throw new IllegalArgumentException("AlbumType value cannot be null or empty");
+        }
+        AlbumType albumType = new AlbumType();
+        albumType.setValue(value);
+        return repository.save(albumType);
+    }
+
+    public List<AlbumType> getAllAlbumTypes() {
+        logger.info("Getting all album types");
+        return repository.findAll();
+    }
+
+    public Optional<AlbumType> getAlbumTypeById(Integer id) {
+        if (id == null) {
+            throw new IllegalArgumentException("ID cannot be null");
+        }
+        logger.info("Getting album type by id:{}", id);
+        return repository.findById(id);
+    }
+
+    public Optional<AlbumType> updateAlbumType(Integer id, String value) {
+        if (id == null) {
+            throw new IllegalArgumentException("ID cannot be null");
+        }
+        logger.info("Updating album type:{}", value);
+        if (value == null || value.trim().isEmpty()) {
+            throw new IllegalArgumentException("AlbumType value cannot be null or empty");
+        }
+        Optional<AlbumType> existingAlbumType = repository.findById(id);
+        if(existingAlbumType.isEmpty()) {
+            logger.warn("Album type not found with id:{}", id);
+            return Optional.empty();
+        }
+        AlbumType albumType = existingAlbumType.get();
+        albumType.setValue(value);
+        AlbumType updatedAlbumType = repository.update(albumType);
+        return Optional.of(updatedAlbumType);
+    }
+
+    public boolean deleteAlbumType(Integer id) {
+        if (id == null) {
+            throw new IllegalArgumentException("Album type id cannot be null");
+        }
+        logger.info("Deleting album type:{}", id);
+        return repository.deleteById(id);
+    }
+
+}

src/main/java/com/mediamanager/service/artist/ArtistService.java

@@ -0,0 +1,65 @@
+package com.mediamanager.service.artist;
+
+import com.mediamanager.model.Artist;
+import com.mediamanager.repository.ArtistRepository;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.List;
+import java.util.Optional;
+
+public class ArtistService {
+    private static final Logger logger = LogManager.getLogger(ArtistService.class);
+    private final ArtistRepository artistRepository;
+
+    public ArtistService(ArtistRepository artistRepository) {
+        this.artistRepository = artistRepository;
+    }
+
+    public Artist createArtist(String name){
+        logger.info("Creating artist: {}", name);
+        if (name == null || name.trim().isEmpty()) {
+            throw new IllegalArgumentException("Artist name cannot be empty");
+        }
+        Artist artist = new Artist();
+        artist.setName(name.trim());
+        return artistRepository.save(artist);
+    }
+
+    public List<Artist> getAllArtists(){
+        logger.info("Getting all artists");
+        return artistRepository.findAll();
+    }
+
+    public Optional<Artist> getArtistById(Integer id){
+        logger.info("Getting artist by ID: {}", id);
+        return artistRepository.findById(id);
+    }
+
+    public Optional<Artist> updateArtist(Integer id, String name){
+        logger.info("Updating artist ID {}: {}", id, name);
+
+        if (name == null || name.trim().isEmpty()) {
+            throw new IllegalArgumentException("Artist name cannot be empty");
+        }
+
+        Optional<Artist> existingArtist = artistRepository.findById(id);
+
+        if(existingArtist.isEmpty()){
+            logger.warn("Artist not found with ID: {}", id);
+            return Optional.empty();
+        }
+        Artist artist = existingArtist.get();
+        artist.setName(name.trim());
+        Artist updatedArtist = artistRepository.update(artist);
+        return Optional.of(updatedArtist);
+    }
+
+    public boolean deleteArtist(Integer id){
+        logger.info("Deleting artist ID: {}", id);
+        return artistRepository.deleteById(id);
+    }
+
+
+
+}

src/main/java/com/mediamanager/service/bitdepth/BitDepthService.java

@@ -0,0 +1,61 @@
+package com.mediamanager.service.bitdepth;
+
+import com.mediamanager.model.BitDepth;
+import com.mediamanager.repository.BitDepthRepository;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.List;
+import java.util.Optional;
+
+public class BitDepthService {
+    private static final Logger logger = LogManager.getLogger(BitDepthService.class);
+    private final BitDepthRepository bitDepthRepository;
+
+    public BitDepthService(BitDepthRepository bitDepthRepository) {
+        this.bitDepthRepository = bitDepthRepository;
+    }
+    public BitDepth createBitDepth(String value){
+        logger.info("Creating bit-depth: {}", value);
+        if (value == null || value.trim().isEmpty()) {
+            throw new IllegalArgumentException("Bit-depth value cannot be empty");
+        }
+        BitDepth bitDepth = new BitDepth();
+        bitDepth.setValue(value.trim());
+        return bitDepthRepository.save(bitDepth);
+
+    }
+
+    public List<BitDepth> getAllBitDepths(){
+        logger.info("Getting all bit-depths");
+        return bitDepthRepository.findAll();
+    }
+
+    public Optional<BitDepth> getBitDepthById(Integer id){
+        logger.info("Getting bit-depth by ID: {}", id);
+        return bitDepthRepository.findById(id);
+    }
+
+    public Optional<BitDepth> updateBitDepth(Integer id, String value){
+        logger.info("Updating bit-depth ID {}: {}", id, value);
+
+        if (value == null || value.trim().isEmpty()) {
+            throw new IllegalArgumentException("Bit-depth value cannot be empty");
+        }
+        Optional<BitDepth> existingBitDepth = bitDepthRepository.findById(id);
+        if(existingBitDepth.isEmpty()){
+            logger.warn("Bit-depth not found with ID: {}", id);
+            return Optional.empty();
+        }
+        BitDepth bitDepth = existingBitDepth.get();
+        bitDepth.setValue(value.trim());
+        BitDepth updatedBitDepth = bitDepthRepository.update(bitDepth);
+        return Optional.of(updatedBitDepth);
+
+    }
+
+    public boolean deleteBitDepth(Integer id){
+        logger.info("Deleting bit-depth ID: {}", id);
+        return bitDepthRepository.deleteById(id);
+    }
+}

src/main/java/com/mediamanager/service/bitrate/BitRateService.java

@@ -0,0 +1,65 @@
+package com.mediamanager.service.bitrate;
+
+
+import com.mediamanager.model.BitRate;
+import com.mediamanager.repository.BitRateRepository;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.List;
+import java.util.Optional;
+
+public class BitRateService {
+    private static final Logger logger = LogManager.getLogger(BitRateService.class);
+    private final BitRateRepository bitRateRepository;
+
+    public BitRateService(BitRateRepository bitRateRepository) {
+        this.bitRateRepository = bitRateRepository;
+    }
+
+    public BitRate createBitRate(String value){
+        logger.info("Creating bit-rate: {}",value);
+        if (value == null || value.trim().isEmpty()) {
+            throw new IllegalArgumentException("Bit-rate value cannot be empty");
+        }
+        BitRate bitRate = new BitRate();
+        bitRate.setValue(value.trim());
+        return bitRateRepository.save(bitRate);
+    }
+
+    public List<BitRate> getAllBitRates(){
+        logger.info("Getting all bit-rates");
+        return bitRateRepository.findAll();
+    }
+
+    public Optional<BitRate> getBitRateById(Integer id){
+        logger.info("Getting bit-rate by ID: {}", id);
+        return bitRateRepository.findById(id);
+    }
+
+    public Optional<BitRate> updateBitRate(Integer id, String value){
+        logger.info("Updating bit-rate ID {}: {}", id, value);
+
+        if (value == null || value.trim().isEmpty()) {
+            throw new IllegalArgumentException("Bit-rate value cannot be empty");
+        }
+
+        Optional<BitRate> existingBitRate = bitRateRepository.findById(id);
+
+        if(existingBitRate.isEmpty()) {
+            logger.warn("Bit-rate not found with ID: {}", id);
+            return Optional.empty();
+        }
+        BitRate bitRate = existingBitRate.get();
+        bitRate.setValue(value.trim());
+
+        BitRate updatedBitRate = bitRateRepository.update(bitRate);
+        return Optional.of(updatedBitRate);
+    }
+
+    public boolean deleteBitRate(Integer id){
+        logger.info("Deleting bit-rate ID: {}", id);
+        return bitRateRepository.deleteById(id);
+    }
+
+}

src/main/java/com/mediamanager/service/composer/ComposerService.java

@@ -0,0 +1,70 @@
+package com.mediamanager.service.composer;
+
+import com.mediamanager.model.Composer;
+import com.mediamanager.repository.ComposerRepository;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.List;
+import java.util.Optional;
+
+public class ComposerService {
+    private static final Logger logger = LogManager.getLogger(ComposerService.class);
+
+    private final ComposerRepository composerRepository;
+
+    public ComposerService(ComposerRepository composerRepository) {
+        this.composerRepository = composerRepository;
+    }
+
+    public Composer createComposer(String name) {
+        logger.info("Creating composer: {}", name);
+        if(name == null || name.trim().isEmpty()) {
+            throw new IllegalArgumentException("Composer name cannot be empty");
+        }
+        Composer composer = new Composer();
+        composer.setName(name.trim());
+        return composerRepository.save(composer);
+
+
+    }
+
+    public List<Composer> getAllComposers() {
+        logger.info("Getting all composers");
+        return composerRepository.findAll();
+    }
+
+    public Optional<Composer> getComposerById(Integer id) {
+        logger.info("Getting composer by ID: {}", id);
+        return composerRepository.findById(id);
+    }
+
+    public Optional<Composer> updateComposer(Integer id, String name) {
+        logger.info("Updating composer ID {}: {}", id, name);
+
+        if(name == null || name.trim().isEmpty()) {
+            throw new IllegalArgumentException("Composer name cannot be empty");
+        }
+
+        Optional<Composer> existingComposer = composerRepository.findById(id);
+
+        if(existingComposer.isEmpty()) {
+            logger.warn("Composer not found with ID: {}", id);
+            return Optional.empty();
+        }
+
+        Composer composer = existingComposer.get();
+        composer.setName(name.trim());
+
+        Composer updated = composerRepository.update(composer);
+        return Optional.of(updated);
+
+    }
+
+    public boolean deleteComposer(Integer id) {
+        logger.info("Deleting composer ID: {}", id);
+        return composerRepository.deleteById(id);
+    }
+
+
+}

src/main/java/com/mediamanager/service/database/DatabaseManager.java

@@ -0,0 +1,142 @@
+package com.mediamanager.service.database;
+
+import jakarta.persistence.EntityManagerFactory;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.hibernate.cfg.Configuration;
+import org.reflections.Reflections;
+import org.reflections.scanners.Scanners;
+import jakarta.persistence.Entity;
+import java.util.Set;
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.Properties;
+
+
+public abstract class DatabaseManager {
+    protected final Properties configuration;
+    protected Connection connection;
+    protected String connectionUrl;
+    protected EntityManagerFactory entityManagerFactory;
+    protected static final Logger logger = LogManager.getLogger(DatabaseManager.class);
+
+    public DatabaseManager(Properties config) {
+        this.configuration = config;
+        logger.debug("DatabaseManager created with configuration:");
+    }
+
+    public abstract void init() throws Exception;
+
+    protected abstract Connection createConnection() throws Exception;
+
+    protected void performSanityChecks() throws SQLException {
+        logger.debug("Performing sanity checks...");
+        try (Statement stmt = connection.createStatement()) {
+            stmt.execute("SELECT 1");
+
+        }
+        String databaseProductName = connection.getMetaData().getDatabaseProductName();
+        String databaseProductVersion = connection.getMetaData().getDatabaseProductVersion();
+        logger.info("Connected to database: {} v{}", databaseProductName, databaseProductVersion);
+    }
+
+    public Connection getConnection() {
+        return connection;
+    }
+
+    public void close() {
+        if (entityManagerFactory != null && entityManagerFactory.isOpen()) {
+            try {
+                entityManagerFactory.close();
+                logger.info("EntityManagerFactory closed");
+            } catch (Exception e) {
+                logger.error("Error closing EntityManagerFactory: {}", e.getMessage());
+            }
+        }
+        if (connection != null) {
+            try {
+                logger.info("Closing database connection...");
+                connection.close();
+                logger.info("Database connection closed successfully");
+            } catch (SQLException e) {
+                logger.error("Error closing database connection: {}", e.getMessage());
+            }
+        } else {
+            logger.debug("No database connection to close");
+        }
+    }
+
+    protected boolean testConnection() {
+        try (Statement stmt = connection.createStatement()) {
+            stmt.execute("SELECT 1");
+            return true;
+        } catch (SQLException e) {
+            logger.error("Connection test failed", e);
+            return false;
+        }
+    }
+    protected void initializeHibernate() {
+        logger.info("Initializing Hibernate ORM...");
+
+        Configuration hibernateConfig = new Configuration();
+
+
+        String dialect = configuration.getProperty("hibernate.dialect");
+        String hbm2ddl = configuration.getProperty("hibernate.hbm2ddl.auto");
+        String driver = configuration.getProperty("database.driver");
+
+        if (dialect == null || dialect.isEmpty()) {
+            throw new IllegalStateException("hibernate.dialect property is required but not configured");
+        }
+        if (driver == null || driver.isEmpty()) {
+            throw new IllegalStateException("database.driver property is required but not configured");
+        }
+        if (connectionUrl == null || connectionUrl.isEmpty()) {
+             throw new IllegalStateException("connectionUrl must be set before initializing Hibernate");
+        }
+
+
+        hibernateConfig.setProperty("hibernate.connection.url", connectionUrl);
+        hibernateConfig.setProperty("hibernate.connection.driver_class", driver);
+        hibernateConfig.setProperty("hibernate.dialect", dialect);
+        hibernateConfig.setProperty("hibernate.hbm2ddl.auto", hbm2ddl);
+        hibernateConfig.setProperty("hibernate.show_sql",
+                configuration.getProperty("hibernate.show_sql", "false"));
+        hibernateConfig.setProperty("hibernate.format_sql",
+                configuration.getProperty("hibernate.format_sql", "true"));
+
+        logger.info("Scanning for entities in package: com.mediamanager.model");
+
+        Set<Class<?>> entityClasses;
+        try {
+            Reflections reflections = new Reflections("com.mediamanager.model", Scanners.TypesAnnotated);
+            entityClasses = reflections.getTypesAnnotatedWith(Entity.class);
+            } catch (Exception e) {
+            logger.error("Failed to scan for entities: {}", e.getMessage());
+            throw new RuntimeException("Entity scanning failed", e);
+            }
+
+        logger.info("Found {} entities", entityClasses.size());
+        if (entityClasses.isEmpty()) {
+            logger.warn("No @Entity classes found in package com.mediamanager.model - is this expected?");
+        }
+        for (Class<?> entityClass : entityClasses) {
+            logger.debug("Registering entity: {}", entityClass.getSimpleName());
+            hibernateConfig.addAnnotatedClass(entityClass);
+        }
+
+        try {
+            entityManagerFactory = hibernateConfig.buildSessionFactory().unwrap(EntityManagerFactory.class);
+            } catch (Exception e) {
+            logger.error("Failed to initialize Hibernate: {}", e.getMessage());
+            throw new RuntimeException("Hibernate initialization failed", e);
+            }
+
+        logger.info("Hibernate ORM initialized successfully");
+    }
+
+    public EntityManagerFactory getEntityManagerFactory() {
+        return entityManagerFactory;
+    }
+}

src/main/java/com/mediamanager/service/database/SqliteDatabaseManager.java

@@ -0,0 +1,99 @@
+package com.mediamanager.service.database;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.Properties;
+
+public class SqliteDatabaseManager extends DatabaseManager {
+    private static final Logger logger = LogManager.getLogger(SqliteDatabaseManager.class);
+
+
+
+
+    public SqliteDatabaseManager(Properties config) {
+        super(config);
+    }
+
+        @Override
+        public void init() throws Exception {
+
+            logger.info("Initializing SQLite database...");
+            String dataDir = configuration.getProperty("database.dir",
+                    System.getProperty("user.home") + "/.mediamanager/db");
+            String dbFilename = configuration.getProperty("database.filename", "mediamanager.db");
+            String driverClassName = configuration.getProperty("database.driver", "org.sqlite.JDBC");
+            try {
+                Class.forName(driverClassName);
+            }catch(ClassNotFoundException e) {
+                logger.error("Failed to load SQLite driver", e);
+                throw e;
+            }
+            Path dataPath = Paths.get(dataDir);
+            if (!Files.exists(dataPath)) {
+                Files.createDirectories(dataPath);
+                logger.debug("Created database directory: {}", dataDir);
+            }
+            Path dbFile = dataPath.resolve(dbFilename);
+            this.connectionUrl = "jdbc:sqlite:" + dbFile.toAbsolutePath().toString();
+            logger.info("Database file path: {}", dbFile);
+            logger.info("Connection URL: {}", this.connectionUrl);
+            initializeHibernate();
+            this.connection = createConnection();
+            configurePerformancePragmas();
+            performSanityChecks();
+            ensureSchemaExists();
+            logger.info("SQLite database initialized successfully");
+
+
+    }
+
+    @Override
+    protected Connection createConnection() throws Exception {
+        try {
+            // O driver org.xerial.sqlite-jdbc é carregado automaticamente aqui
+            Connection conn = DriverManager.getConnection(this.connectionUrl);
+            logger.debug("Got connection to SQLite file");
+            return conn;
+        } catch (SQLException e) {
+            logger.error("Failed to create SQLite connection", e);
+            throw new Exception("SQLite connection failed: " + e.getMessage(), e);
+        }
+    }
+
+
+    private void configurePerformancePragmas() throws SQLException {
+        try (Statement stmt = connection.createStatement()) {
+
+            stmt.execute("PRAGMA journal_mode=WAL;");
+
+
+            stmt.execute("PRAGMA foreign_keys=ON;");
+
+
+            stmt.execute("PRAGMA synchronous=NORMAL;");
+
+            stmt.execute("PRAGMA busy_timeout=5000;");
+
+            logger.debug("SQLite performance PRAGMAs applied (WAL, Synchronous, ForeignKeys).");
+        }
+    }
+
+    private void ensureSchemaExists() throws SQLException {
+
+    }
+
+    @Override
+    public void close() {
+
+        super.close();
+        logger.info("SQLite resources released.");
+    }
+}

src/main/java/com/mediamanager/service/delegate/ActionHandler.java

@@ -0,0 +1,11 @@
+package com.mediamanager.service.delegate;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.protocol.TransportProtocol;
+
+@FunctionalInterface
+public interface ActionHandler {
+    TransportProtocol.Response.Builder handle(ByteString requestPayload) throws InvalidProtocolBufferException;
+}
+

src/main/java/com/mediamanager/service/delegate/DelegateActionManager.java

@@ -0,0 +1,280 @@
+package com.mediamanager.service.delegate;
+
+import com.google.protobuf.ByteString;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.repository.*;
+import com.mediamanager.repository.DiscRepository;
+import com.mediamanager.service.album.AlbumService;
+import com.mediamanager.service.albumart.AlbumArtService;
+import com.mediamanager.service.albumhasartist.AlbumHasArtistService;
+import com.mediamanager.service.albumhasgenre.AlbumHasGenreService;
+import com.mediamanager.service.albumtype.AlbumTypeService;
+import com.mediamanager.service.bitdepth.BitDepthService;
+import com.mediamanager.service.bitrate.BitRateService;
+import com.mediamanager.service.composer.ComposerService;
+import com.mediamanager.service.trackhasgenre.TrackHasGenreService;
+import com.mediamanager.service.trackhasartist.TrackHasArtistService;
+import com.mediamanager.service.trackhascomposer.TrackHasComposerService;
+
+import com.mediamanager.repository.GenreRepository;
+import com.mediamanager.service.artist.ArtistService;
+import com.mediamanager.service.track.TrackService;
+import com.mediamanager.service.delegate.annotation.Action;
+
+import com.mediamanager.service.disc.DiscService;
+import com.mediamanager.service.genre.GenreService;
+import com.mediamanager.service.samplingrate.SamplingRateService;
+import jakarta.persistence.EntityManagerFactory;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.reflections.Reflections;
+import org.reflections.scanners.Scanners;
+import java.lang.reflect.Constructor;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+
+public class DelegateActionManager {
+    private static final Logger logger = LogManager.getLogger(DelegateActionManager.class);
+    
+    private final Map<String, ActionHandler> handlerRegistry;
+    private final ServiceLocator serviceLocator;
+    private final EntityManagerFactory entityManagerFactory;
+
+
+    public DelegateActionManager(EntityManagerFactory entityManagerFactory) {
+        this.entityManagerFactory = entityManagerFactory;
+        this.serviceLocator = new ServiceLocator();
+
+        initializeServices();
+
+
+        logger.debug("DelegateActionManager created");
+        this.handlerRegistry = new HashMap<>();
+        autoRegisterHandlers();
+
+    }
+
+    private void initializeServices() {
+        logger.info("Initializing services...");
+
+
+        GenreRepository genreRepository = new GenreRepository(entityManagerFactory);
+        GenreService genreService = new GenreService(genreRepository);
+
+
+        serviceLocator.register(GenreService.class, genreService);
+
+        ArtistRepository artistRepository = new ArtistRepository(entityManagerFactory);
+        ArtistService artistService = new ArtistService(artistRepository);
+
+        serviceLocator.register(ArtistService.class, artistService);
+
+        ComposerRepository composerRepository = new ComposerRepository(entityManagerFactory);
+        ComposerService composerService = new ComposerService(composerRepository);
+        serviceLocator.register(ComposerService.class, composerService);
+
+        BitDepthRepository bitDepthRepository = new BitDepthRepository(entityManagerFactory);
+        BitDepthService bitDepthService = new BitDepthService(bitDepthRepository);
+        serviceLocator.register(BitDepthService.class, bitDepthService);
+
+        BitRateRepository bitRateRepository = new BitRateRepository(entityManagerFactory);
+        BitRateService bitRateService = new BitRateService(bitRateRepository);
+        serviceLocator.register(BitRateService.class, bitRateService);
+
+        SamplingRateRepository samplingRateRepository = new SamplingRateRepository(entityManagerFactory);
+        SamplingRateService  samplingRateService = new SamplingRateService(samplingRateRepository);
+        serviceLocator.register(SamplingRateService.class, samplingRateService);
+
+        AlbumArtRepository albumArtRepository = new AlbumArtRepository(entityManagerFactory);
+        AlbumArtService albumArtService = new AlbumArtService(albumArtRepository);
+        serviceLocator.register(AlbumArtService.class, albumArtService);
+
+        AlbumTypeRepository albumTypeRepository = new AlbumTypeRepository(entityManagerFactory);
+        AlbumTypeService albumTypeService = new AlbumTypeService(albumTypeRepository);
+        serviceLocator.register(AlbumTypeService.class, albumTypeService);
+
+        AlbumRepository albumRepository = new AlbumRepository(entityManagerFactory);
+        AlbumService albumService = new AlbumService(albumRepository, albumTypeRepository, albumArtRepository);
+        serviceLocator.register(AlbumService.class, albumService);
+
+        AlbumHasArtistRepository albumHasArtistRepository = new AlbumHasArtistRepository(entityManagerFactory);
+        AlbumHasArtistService albumHasArtistService = new AlbumHasArtistService(albumHasArtistRepository, albumRepository, artistRepository);
+        serviceLocator.register(AlbumHasArtistService.class, albumHasArtistService);
+
+        AlbumHasGenreRepository albumHasGenreRepository = new AlbumHasGenreRepository(entityManagerFactory);
+        AlbumHasGenreService albumHasGenreService = new AlbumHasGenreService(albumHasGenreRepository, albumRepository, genreRepository);
+        serviceLocator.register(AlbumHasGenreService.class, albumHasGenreService);
+
+        DiscRepository discRepository = new DiscRepository(entityManagerFactory);
+        DiscService discService = new DiscService(discRepository, albumRepository);
+        serviceLocator.register(DiscService.class, discService);
+
+        TrackRepository trackRepository = new TrackRepository(entityManagerFactory);
+        TrackService trackService = new TrackService(trackRepository, discRepository, composerRepository, bitDepthRepository, bitRateRepository, samplingRateRepository);
+        serviceLocator.register(TrackService.class, trackService);
+
+        TrackHasGenreRepository trackHasGenreRepository = new TrackHasGenreRepository(entityManagerFactory);
+        TrackHasGenreService trackHasGenreService = new TrackHasGenreService(trackHasGenreRepository, trackRepository, genreRepository);
+        serviceLocator.register(TrackHasGenreService.class, trackHasGenreService);
+
+        TrackHasArtistRepository trackHasArtistRepository = new TrackHasArtistRepository(entityManagerFactory);
+        TrackHasArtistService trackHasArtistService = new TrackHasArtistService(trackHasArtistRepository, trackRepository, artistRepository);
+        serviceLocator.register(TrackHasArtistService.class, trackHasArtistService);
+
+        TrackHasComposerRepository trackHasComposerRepository = new TrackHasComposerRepository(entityManagerFactory);
+        TrackHasComposerService trackHasComposerService = new TrackHasComposerService(trackHasComposerRepository, trackRepository, composerRepository);
+        serviceLocator.register(TrackHasComposerService.class, trackHasComposerService);
+
+        serviceLocator.logRegisteredServices();
+
+        logger.info("Services initialized successfully");
+    }
+
+
+
+    public void start(){
+        logger.info("DelegateActionManager started");
+    }
+
+    public void stop(){
+        logger.info("DelegateActionManager stopped");
+    }
+
+    @SuppressWarnings("unchecked")
+    private ActionHandler instantiateHandler(Class<?> clazz) throws Exception {
+        if(!ActionHandler.class.isAssignableFrom(clazz)){
+            throw new IllegalArgumentException(
+                    clazz.getName() + " is annotated with @Action but does not implement ActionHandler");
+
+        }
+        logger.debug("Attempting to instantiate handler: {}", clazz.getSimpleName());
+
+
+        Constructor<?>[] constructors = clazz.getDeclaredConstructors();
+
+
+        // Sort constructors by parameter count (descending) to prefer DI constructors
+        java.util.Arrays.sort(constructors, (c1, c2) -> 
+            Integer.compare(c2.getParameterCount(), c1.getParameterCount()));
+
+        for (Constructor<?> constructor : constructors) {
+
+            Class<?>[] paramTypes = constructor.getParameterTypes();
+
+
+            Object[] params = new Object[paramTypes.length];
+            boolean allDependenciesResolved = true;
+
+            for (int i = 0; i < paramTypes.length; i++) {
+
+                Object service = serviceLocator.get(paramTypes[i]);
+
+                if (service == null) {
+
+                    allDependenciesResolved = false;
+                    logger.debug("Cannot resolve dependency {} for {}",
+                            paramTypes[i].getSimpleName(),
+                            clazz.getSimpleName());
+                    break;  // Para de tentar esse construtor
+                }
+
+
+                params[i] = service;
+            }
+
+
+            if (allDependenciesResolved) {
+                logger.debug("Using constructor with {} params for {}",
+                        paramTypes.length, clazz.getSimpleName());
+                return (ActionHandler) constructor.newInstance(params);
+            }
+        }
+
+
+        throw new IllegalStateException(
+                String.format(
+                        "Cannot instantiate handler %s. No suitable constructor found. " +
+                                "Make sure all required services are registered in ServiceLocator.",
+                        clazz.getName()
+                )
+        );
+    }
+
+    private void autoRegisterHandlers() {
+        logger.info("Starting auto-registration of handlers...");
+        Reflections reflections = new Reflections(
+                "com.mediamanager.service.delegate.handler",
+                Scanners.TypesAnnotated
+        );
+        Set<Class<?>> annotatedClasses = reflections.getTypesAnnotatedWith(Action.class);
+        logger.info("Found {} handler classes with @Action annotation", annotatedClasses.size());
+        int successCount = 0;
+        int failureCount = 0;
+        for (Class<?> handlerClass : annotatedClasses) {
+            try {
+
+                Action actionAnnotation = handlerClass.getAnnotation(Action.class);
+                String actionName = actionAnnotation.value();
+
+                logger.debug("Processing handler: {} for action '{}'",
+                        handlerClass.getSimpleName(),
+                        actionName);
+
+
+                ActionHandler handler = instantiateHandler(handlerClass);
+
+
+                handlerRegistry.put(actionName, handler);
+
+                logger.info("✓ Registered handler: '{}' -> {}",
+                        actionName,
+                        handlerClass.getSimpleName());
+                successCount++;
+
+            } catch (Exception e) {
+
+                logger.error("✗ Failed to register handler: {}",
+                        handlerClass.getName(),
+                        e);
+                failureCount++;
+            }
+        }
+
+
+        logger.info("Auto-registration complete: {} successful, {} failed, {} total",
+                successCount,
+                failureCount,
+                successCount + failureCount);
+
+        if (failureCount > 0) {
+            logger.warn("Some handlers failed to register. Check logs above for details.");
+        }
+    }
+
+    public TransportProtocol.Response ProcessedRequest(TransportProtocol.Request request){
+        String requestId = request.getRequestId();
+        logger.info("Processing request: {}", requestId);
+        String action = request.getHeadersMap().getOrDefault("action", "unknown");
+        ActionHandler handler = handlerRegistry.get(action);
+        TransportProtocol.Response.Builder responseBuilder;
+        if (handler == null) {
+            logger.warn("No handler found for action: {}", action);
+            responseBuilder = TransportProtocol.Response.newBuilder()
+                    .setStatusCode(404) // 404 Not Found
+                    .setPayload(ByteString.copyFromUtf8("Error: Action '" + action + "' not found."));
+        } else{
+            try {
+                logger.debug("Delegating action '{}' to handler...", action);
+                responseBuilder = handler.handle(request.getPayload());
+            }catch (Exception e) {
+                logger.error("Handler for action '{}' threw an exception:", action, e);
+                responseBuilder = TransportProtocol.Response.newBuilder()
+                        .setStatusCode(500) // 500 Internal Server Error
+                        .setPayload(ByteString.copyFromUtf8("Error: " + e.getMessage()));
+            }
+        }
+            return responseBuilder.setRequestId(requestId).build();
+    }
+}

src/main/java/com/mediamanager/service/delegate/ServiceLocator.java

@@ -0,0 +1,45 @@
+package com.mediamanager.service.delegate;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class ServiceLocator {
+    private static final Logger logger = LogManager.getLogger(ServiceLocator.class);
+    private final Map<Class<?>, Object> services = new HashMap<>();
+
+    public <T> void register(Class<T> serviceClass, T serviceInstance) {
+        if (serviceInstance == null) {
+            throw new IllegalArgumentException("Service instance cannot be null");
+        }
+        services.put(serviceClass, serviceInstance);
+        logger.debug("Registered service: {} -> {}",
+                serviceClass.getSimpleName(),
+                serviceInstance.getClass().getSimpleName());
+    }
+
+    @SuppressWarnings("unchecked")
+    public <T> T get(Class<T> serviceClass) {
+        return (T) services.get(serviceClass);
+    }
+
+    public boolean has(Class<?> serviceClass) {
+        return services.containsKey(serviceClass);
+    }
+    public int size() {
+        return services.size();
+    }
+    public void logRegisteredServices() {
+        logger.info("Registered services: {}", services.size());
+
+
+        services.forEach((clazz, instance) ->
+                logger.info("  - {} -> {}",
+                        clazz.getSimpleName(),
+                        instance.getClass().getSimpleName())
+        );
+    }
+}
+

src/main/java/com/mediamanager/service/delegate/annotation/Action.java

@@ -0,0 +1,13 @@
+package com.mediamanager.service.delegate.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.TYPE)
+public @interface Action {
+
+    String value();
+}

src/main/java/com/mediamanager/service/delegate/handler/CloseHandler.java

@@ -0,0 +1,34 @@
+package com.mediamanager.service.delegate.handler;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.protocol.TestProtocol.CloseCommand;
+import com.mediamanager.protocol.TestProtocol.CloseResponse;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+@Action("close")
+public class CloseHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(CloseHandler.class);
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload)
+            throws InvalidProtocolBufferException {
+
+        CloseCommand.parseFrom(requestPayload); // Valida
+
+        logger.info("Close command received - connection will close");
+
+        CloseResponse response = CloseResponse.newBuilder()
+                .setMessage("Connection closing. Goodbye!")
+                .build();
+
+        return TransportProtocol.Response.newBuilder()
+                .setPayload(ByteString.copyFrom(response.toByteArray()))
+                .setStatusCode(200)
+                .putHeaders("Connection", "close"); // ← Marca para fechar
+    }
+}

src/main/java/com/mediamanager/service/delegate/handler/EchoHandler.java

@@ -0,0 +1,41 @@
+package com.mediamanager.service.delegate.handler;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.protocol.TestProtocol.EchoCommand;      // ← Import
+import com.mediamanager.protocol.TestProtocol.EchoResponse;    // ← Import
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+@Action("echo")
+public class EchoHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(EchoHandler.class);
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload)
+            throws InvalidProtocolBufferException {  // ← Pode lançar exceção
+
+        // 1. Parse Protobuf bytes → EchoCommand
+        EchoCommand command = EchoCommand.parseFrom(requestPayload);
+
+        logger.debug("Echo received: {}", command.getMessage());
+
+        // 2. Cria EchoResponse (Protobuf)
+        EchoResponse echoResponse = EchoResponse.newBuilder()
+                .setMessage(command.getMessage())
+                .setServerTimestamp(System.currentTimeMillis())
+                .build();
+
+        // 3. Serializa EchoResponse → bytes
+        ByteString responsePayload = ByteString.copyFrom(echoResponse.toByteArray());
+
+        // 4. Retorna Response
+        return TransportProtocol.Response.newBuilder()
+                .setPayload(responsePayload)
+                .setStatusCode(200);
+
+    }
+}

src/main/java/com/mediamanager/service/delegate/handler/HeartbeatHandler.java

@@ -0,0 +1,38 @@
+package com.mediamanager.service.delegate.handler;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.protocol.TestProtocol.HeartbeatCommand;
+import com.mediamanager.protocol.TestProtocol.HeartbeatResponse;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+@Action("heartbeat")
+public class HeartbeatHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(HeartbeatHandler.class);
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload)
+            throws InvalidProtocolBufferException {
+
+        HeartbeatCommand command = HeartbeatCommand.parseFrom(requestPayload);
+
+        long serverTime = System.currentTimeMillis();
+
+        logger.debug("Heartbeat received. Client T1={}, Server T2={}",
+                command.getClientTimestamp(), serverTime);
+
+        HeartbeatResponse response = HeartbeatResponse.newBuilder()
+                .setClientTimestamp(command.getClientTimestamp())  // Echo T1
+                .setServerTimestamp(serverTime)                     // T2
+                .build();
+
+        return TransportProtocol.Response.newBuilder()
+                .setPayload(ByteString.copyFrom(response.toByteArray()))
+                .setStatusCode(200);
+
+    }
+}

src/main/java/com/mediamanager/service/delegate/handler/album/CreateAlbumHandler.java

@@ -0,0 +1,59 @@
+package com.mediamanager.service.delegate.handler.album;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.mapper.AlbumMapper;
+import com.mediamanager.model.Album;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.AlbumMessages;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import com.mediamanager.service.album.AlbumService;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+@Action("album.create")
+public class CreateAlbumHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(CreateAlbumHandler.class);
+    private final AlbumService albumService;
+
+    public CreateAlbumHandler(AlbumService albumService) {
+        this.albumService = albumService;
+    }
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload) throws InvalidProtocolBufferException {
+        try{
+            AlbumMessages.CreateAlbumRequest createRequest =
+                    AlbumMessages.CreateAlbumRequest.parseFrom(requestPayload);
+
+            Album album = albumService.createAlbum(
+                    createRequest.getName(),
+                    createRequest.getYear() > 0 ? createRequest.getYear() : null,
+                    createRequest.getNumberOfDiscs() > 0 ? createRequest.getNumberOfDiscs() : null,
+                    createRequest.getCode().isEmpty() ? null : createRequest.getCode(),
+                    createRequest.getIsCompilation(),
+                    createRequest.getFkAlbumtypeId() > 0 ? createRequest.getFkAlbumtypeId() : null,
+                    createRequest.getFkAlbumartId() > 0 ? createRequest.getFkAlbumartId() : null
+            );
+
+            AlbumMessages.Album albumProto = AlbumMapper.toProtobuf(album);
+            AlbumMessages.CreateAlbumResponse createAlbumResponse = AlbumMessages.CreateAlbumResponse.newBuilder()
+                    .setAlbum(albumProto)
+                    .build();
+            return TransportProtocol.Response.newBuilder()
+                    .setPayload(createAlbumResponse.toByteString());
+        } catch (IllegalArgumentException e) {
+            logger.error("Validation error", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(400)
+                    .setPayload(ByteString.copyFromUtf8("Validation error: " + e.getMessage()));
+
+        } catch (Exception e) {
+            logger.error("Error creating album", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(ByteString.copyFromUtf8("Error: " + e.getMessage()));
+        }
+    }
+}

src/main/java/com/mediamanager/service/delegate/handler/album/DeleteAlbumHandler.java

@@ -0,0 +1,62 @@
+package com.mediamanager.service.delegate.handler.album;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.AlbumMessages;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import com.mediamanager.service.album.AlbumService;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+@Action("album.delete")
+public class DeleteAlbumHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(DeleteAlbumHandler.class);
+
+    private final AlbumService albumService;
+
+    public DeleteAlbumHandler(AlbumService albumService) {
+        this.albumService = albumService;
+    }
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload)
+            throws InvalidProtocolBufferException {
+
+        try {
+            AlbumMessages.DeleteAlbumRequest deleteRequest =
+                    AlbumMessages.DeleteAlbumRequest.parseFrom(requestPayload);
+            int id = deleteRequest.getId();
+            boolean success = albumService.deleteAlbum(id);
+            AlbumMessages.DeleteAlbumResponse deleteResponse;
+            if (success) {
+                deleteResponse = AlbumMessages.DeleteAlbumResponse.newBuilder()
+                        .setSuccess(true)
+                        .setMessage("Album deleted successfully")
+                        .build();
+                return TransportProtocol.Response.newBuilder()
+                        .setPayload(deleteResponse.toByteString());
+            } else {
+                deleteResponse = AlbumMessages.DeleteAlbumResponse.newBuilder()
+                        .setSuccess(false)
+                        .setMessage("Album not found")
+                        .build();
+
+                return TransportProtocol.Response.newBuilder()
+                        .setStatusCode(404)
+                        .setPayload(deleteResponse.toByteString());
+            }
+        } catch (Exception e) {
+            logger.error("Error deleting album", e);
+            AlbumMessages.DeleteAlbumResponse deleteResponse =
+                    AlbumMessages.DeleteAlbumResponse.newBuilder()
+                            .setSuccess(false)
+                            .setMessage("Error: " + e.getMessage())
+                            .build();
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(deleteResponse.toByteString());
+        }
+    }
+    }

src/main/java/com/mediamanager/service/delegate/handler/album/GetAlbumByIdHandler.java

@@ -0,0 +1,56 @@
+package com.mediamanager.service.delegate.handler.album;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.mapper.AlbumMapper;
+import com.mediamanager.model.Album;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.AlbumMessages;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import com.mediamanager.service.album.AlbumService;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.Optional;
+
+@Action(value = "album.getById")
+public class GetAlbumByIdHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(GetAlbumByIdHandler.class);
+    private final AlbumService albumService;
+
+    public GetAlbumByIdHandler(AlbumService albumService) {
+        this.albumService = albumService;
+    }
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload)
+        throws InvalidProtocolBufferException{
+
+        try{
+            AlbumMessages.GetAlbumByIdRequest getByIdRequest =
+                    AlbumMessages.GetAlbumByIdRequest.parseFrom(requestPayload);
+            int id = getByIdRequest.getId();
+
+            Optional<Album> albumOpt = albumService.getAlbumById(id);
+
+            if (albumOpt.isEmpty()){
+                logger.warn("Album not found with ID: {}", id);
+                return TransportProtocol.Response.newBuilder()
+                        .setStatusCode(404)
+                        .setPayload(ByteString.copyFromUtf8("Album not found"));
+            }
+            AlbumMessages.Album albumProto = AlbumMapper.toProtobuf(albumOpt.get());
+            AlbumMessages.GetAlbumByIdResponse getByIdResponse = AlbumMessages.GetAlbumByIdResponse.newBuilder()
+                    .setAlbum(albumProto)
+                    .build();
+            return TransportProtocol.Response.newBuilder()
+                    .setPayload(getByIdResponse.toByteString());
+        } catch (Exception e) {
+            logger.error("Error getting album by ID", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(ByteString.copyFromUtf8("Error: "+ e.getMessage()));
+        }
+    }
+}

src/main/java/com/mediamanager/service/delegate/handler/album/GetAlbumHandler.java

@@ -0,0 +1,48 @@
+package com.mediamanager.service.delegate.handler.album;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.mapper.AlbumMapper;
+import com.mediamanager.model.Album;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.AlbumMessages;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import com.mediamanager.service.album.AlbumService;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.List;
+
+
+@Action("album.getAll")
+public class GetAlbumHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(GetAlbumHandler.class);
+
+    private final AlbumService albumService;
+
+    public GetAlbumHandler(AlbumService albumService){this.albumService = albumService;}
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload) throws InvalidProtocolBufferException {
+        try{
+            List<Album> albums = albumService.getAllAlbums();
+            AlbumMessages.GetAlbumsResponse.Builder responseBuilder = AlbumMessages.GetAlbumsResponse.newBuilder();
+
+            for (Album album : albums) {
+                AlbumMessages.Album albumProto = AlbumMapper.toProtobuf(album);
+                responseBuilder.addAlbums(albumProto);
+            }
+            AlbumMessages.GetAlbumsResponse getAlbumsResponse = responseBuilder.build();
+
+            return TransportProtocol.Response.newBuilder()
+                    .setPayload(getAlbumsResponse.toByteString());
+
+        }catch (Exception e){
+            logger.error("Error getting albums", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(ByteString.copyFromUtf8("Error: " + e.getMessage()));
+        }
+    }
+}

src/main/java/com/mediamanager/service/delegate/handler/album/UpdateAlbumHandler.java

@@ -0,0 +1,96 @@
+package com.mediamanager.service.delegate.handler.album;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.mapper.AlbumMapper;
+import com.mediamanager.model.Album;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.AlbumMessages;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import com.mediamanager.service.album.AlbumService;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.Optional;
+
+@Action("album.update")
+public class UpdateAlbumHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(UpdateAlbumHandler.class);
+    private final AlbumService albumService;
+
+    public UpdateAlbumHandler(AlbumService albumService) {
+        this.albumService = albumService;
+    }
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload)
+            throws InvalidProtocolBufferException {
+        try {
+            AlbumMessages.UpdateAlbumRequest updateRequest =
+                    AlbumMessages.UpdateAlbumRequest.parseFrom(requestPayload);
+
+            int id = updateRequest.getId();
+
+            // Extrai valores dos wrappers - null se não foi fornecido
+            Integer year = updateRequest.hasYear()
+                    ? updateRequest.getYear().getValue()
+                    : null;
+
+            Integer numberOfDiscs = updateRequest.hasNumberOfDiscs()
+                    ? updateRequest.getNumberOfDiscs().getValue()
+                    : null;
+
+            Integer albumTypeId = updateRequest.hasFkAlbumtypeId()
+                    ? updateRequest.getFkAlbumtypeId().getValue()
+                    : null;
+
+            Integer albumArtId = updateRequest.hasFkAlbumartId()
+                    ? updateRequest.getFkAlbumartId().getValue()
+                    : null;
+
+            Optional<Album> albumOpt = albumService.updateAlbum(
+                    id,
+                    updateRequest.getName(),
+                    year,
+                    numberOfDiscs,
+                    updateRequest.getCode().isEmpty() ? null : updateRequest.getCode(),
+                    updateRequest.getIsCompilation(),
+                    albumTypeId,
+                    albumArtId,
+                    updateRequest.hasYear(),              // ← Novo!
+                    updateRequest.hasNumberOfDiscs(),     // ← Novo!
+                    updateRequest.hasFkAlbumtypeId(),     // ← Novo!
+                    updateRequest.hasFkAlbumartId()       // ← Novo!
+            );
+
+            if (albumOpt.isEmpty()) {
+                logger.warn("Album not found with ID: {}", id);
+                return TransportProtocol.Response.newBuilder()
+                        .setStatusCode(404)
+                        .setPayload(ByteString.copyFromUtf8("Album not found"));
+            }
+
+            AlbumMessages.Album albumProto = AlbumMapper.toProtobuf(albumOpt.get());
+
+            AlbumMessages.UpdateAlbumResponse updateResponse =
+                    AlbumMessages.UpdateAlbumResponse.newBuilder()
+                            .setAlbum(albumProto)
+                            .build();
+
+            return TransportProtocol.Response.newBuilder()
+                    .setPayload(updateResponse.toByteString());
+
+        } catch (IllegalArgumentException e) {
+            logger.error("Validation error", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(400)
+                    .setPayload(ByteString.copyFromUtf8("Validation error: " + e.getMessage()));
+        } catch (Exception e) {
+            logger.error("Error updating album", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(ByteString.copyFromUtf8("Error: " + e.getMessage()));
+        }
+    }
+}

src/main/java/com/mediamanager/service/delegate/handler/albumart/CreateAlbumArtHandler.java

@@ -0,0 +1,49 @@
+package com.mediamanager.service.delegate.handler.albumart;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.mapper.AlbumArtMapper;
+import com.mediamanager.model.AlbumArt;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.AlbumArtMessages;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import com.mediamanager.service.albumart.AlbumArtService;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+@Action("albumart.create")
+public class CreateAlbumArtHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(CreateAlbumArtHandler.class);
+    private final AlbumArtService albumArtService;
+
+    public CreateAlbumArtHandler(AlbumArtService albumArtService) {
+        this.albumArtService = albumArtService;
+    }
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload) throws InvalidProtocolBufferException {
+        try{
+            AlbumArtMessages.CreateAlbumArtRequest createRequest =
+                    AlbumArtMessages.CreateAlbumArtRequest.parseFrom(requestPayload);
+            AlbumArt albumArt = albumArtService.createAlbumArt(createRequest.getFilepath());
+            AlbumArtMessages.AlbumArt albumArtProto = AlbumArtMapper.toProtobuf(albumArt);
+            AlbumArtMessages.CreateAlbumArtResponse createAlbumArtResponse = AlbumArtMessages.CreateAlbumArtResponse.newBuilder()
+                    .setAlbumart(albumArtProto)
+                    .build();
+            return TransportProtocol.Response.newBuilder()
+                    .setPayload(createAlbumArtResponse.toByteString());
+        } catch (IllegalArgumentException e) {
+            logger.error("Validation error", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(400)
+                    .setPayload(ByteString.copyFromUtf8("Validation error: " + e.getMessage()));
+
+        } catch (Exception e) {
+            logger.error("Error creating album art", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(ByteString.copyFromUtf8("Error: " + e.getMessage()));
+        }
+    }
+}

src/main/java/com/mediamanager/service/delegate/handler/albumart/DeleteAlbumArtHandler.java

@@ -0,0 +1,62 @@
+package com.mediamanager.service.delegate.handler.albumart;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.AlbumArtMessages;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import com.mediamanager.service.albumart.AlbumArtService;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+@Action("albumart.delete")
+public class DeleteAlbumArtHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(DeleteAlbumArtHandler.class);
+
+    private final AlbumArtService albumArtService;
+
+    public DeleteAlbumArtHandler(AlbumArtService albumArtService) {
+        this.albumArtService = albumArtService;
+    }
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload)
+            throws InvalidProtocolBufferException {
+
+        try {
+            AlbumArtMessages.DeleteAlbumArtRequest deleteRequest =
+                    AlbumArtMessages.DeleteAlbumArtRequest.parseFrom(requestPayload);
+            int id = deleteRequest.getId();
+            boolean success = albumArtService.deleteAlbumArt(id);
+            AlbumArtMessages.DeleteAlbumArtResponse deleteResponse;
+            if (success) {
+                deleteResponse = AlbumArtMessages.DeleteAlbumArtResponse.newBuilder()
+                        .setSuccess(true)
+                        .setMessage("Album art deleted successfully")
+                        .build();
+                return TransportProtocol.Response.newBuilder()
+                        .setPayload(deleteResponse.toByteString());
+            } else {
+                deleteResponse = AlbumArtMessages.DeleteAlbumArtResponse.newBuilder()
+                        .setSuccess(false)
+                        .setMessage("Album art not found")
+                        .build();
+
+                return TransportProtocol.Response.newBuilder()
+                        .setStatusCode(404)
+                        .setPayload(deleteResponse.toByteString());
+            }
+        } catch (Exception e) {
+            logger.error("Error deleting album art", e);
+            AlbumArtMessages.DeleteAlbumArtResponse deleteResponse =
+                    AlbumArtMessages.DeleteAlbumArtResponse.newBuilder()
+                            .setSuccess(false)
+                            .setMessage("Error: " + e.getMessage())
+                            .build();
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(deleteResponse.toByteString());
+        }
+    }
+    }

src/main/java/com/mediamanager/service/delegate/handler/albumart/GetAlbumArtByIdHandler.java

@@ -0,0 +1,56 @@
+package com.mediamanager.service.delegate.handler.albumart;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.mapper.AlbumArtMapper;
+import com.mediamanager.model.AlbumArt;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.AlbumArtMessages;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import com.mediamanager.service.albumart.AlbumArtService;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.Optional;
+
+@Action(value = "albumart.getById")
+public class GetAlbumArtByIdHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(GetAlbumArtByIdHandler.class);
+    private final AlbumArtService albumArtService;
+
+    public GetAlbumArtByIdHandler(AlbumArtService albumArtService) {
+        this.albumArtService = albumArtService;
+    }
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload)
+        throws InvalidProtocolBufferException{
+
+        try{
+            AlbumArtMessages.GetAlbumArtByIdRequest getByIdRequest =
+                    AlbumArtMessages.GetAlbumArtByIdRequest.parseFrom(requestPayload);
+            int id = getByIdRequest.getId();
+
+            Optional<AlbumArt> albumArtOpt = albumArtService.getAlbumArtById(id);
+
+            if (albumArtOpt.isEmpty()){
+                logger.warn("AlbumArt not found with ID: {}", id);
+                return TransportProtocol.Response.newBuilder()
+                        .setStatusCode(404)
+                        .setPayload(ByteString.copyFromUtf8("AlbumArt not found"));
+            }
+            AlbumArtMessages.AlbumArt albumArtProto = AlbumArtMapper.toProtobuf(albumArtOpt.get());
+            AlbumArtMessages.GetAlbumArtByIdResponse getByIdResponse = AlbumArtMessages.GetAlbumArtByIdResponse.newBuilder()
+                    .setAlbumart(albumArtProto)
+                    .build();
+            return TransportProtocol.Response.newBuilder()
+                    .setPayload(getByIdResponse.toByteString());
+        } catch (Exception e) {
+            logger.error("Error getting album art by ID", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(ByteString.copyFromUtf8("Error: "+ e.getMessage()));
+        }
+    }
+}

src/main/java/com/mediamanager/service/delegate/handler/albumart/GetAlbumArtHandler.java

@@ -0,0 +1,48 @@
+package com.mediamanager.service.delegate.handler.albumart;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.mapper.AlbumArtMapper;
+import com.mediamanager.model.AlbumArt;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.AlbumArtMessages;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import com.mediamanager.service.albumart.AlbumArtService;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.List;
+
+
+@Action("albumart.getAll")
+public class GetAlbumArtHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(GetAlbumArtHandler.class);
+
+    private final AlbumArtService albumArtService;
+
+    public GetAlbumArtHandler(AlbumArtService albumArtService){this.albumArtService = albumArtService;}
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload) throws InvalidProtocolBufferException {
+        try{
+            List<AlbumArt> albumArts = albumArtService.getAllAlbumArts();
+            AlbumArtMessages.GetAlbumArtsResponse.Builder responseBuilder = AlbumArtMessages.GetAlbumArtsResponse.newBuilder();
+
+            for (AlbumArt albumArt : albumArts) {
+                AlbumArtMessages.AlbumArt albumArtProto = AlbumArtMapper.toProtobuf(albumArt);
+                responseBuilder.addAlbumarts(albumArtProto);
+            }
+            AlbumArtMessages.GetAlbumArtsResponse getAlbumArtsResponse = responseBuilder.build();
+
+            return TransportProtocol.Response.newBuilder()
+                    .setPayload(getAlbumArtsResponse.toByteString());
+
+        }catch (Exception e){
+            logger.error("Error getting album arts", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(ByteString.copyFromUtf8("Error: " + e.getMessage()));
+        }
+    }
+}

src/main/java/com/mediamanager/service/delegate/handler/albumart/UpdateAlbumArtHandler.java

@@ -0,0 +1,65 @@
+package com.mediamanager.service.delegate.handler.albumart;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.mapper.AlbumArtMapper;
+import com.mediamanager.model.AlbumArt;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.AlbumArtMessages;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import com.mediamanager.service.albumart.AlbumArtService;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.Optional;
+
+@Action("albumart.update")
+public class UpdateAlbumArtHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(UpdateAlbumArtHandler.class);
+    private final AlbumArtService albumArtService;
+
+    public UpdateAlbumArtHandler(AlbumArtService albumArtService) {
+        this.albumArtService = albumArtService;
+    }
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload) throws InvalidProtocolBufferException {
+        try{
+            AlbumArtMessages.UpdateAlbumArtRequest updateRequest =
+                    AlbumArtMessages.UpdateAlbumArtRequest.parseFrom(requestPayload);
+
+            int id = updateRequest.getId();
+            String newFilepath = updateRequest.getFilepath();
+
+            Optional<AlbumArt> albumArtOpt = albumArtService.updateAlbumArt(id, newFilepath);
+
+            if(albumArtOpt.isEmpty()){
+                logger.warn("AlbumArt not found with ID: {}", id);
+                return TransportProtocol.Response.newBuilder()
+                        .setStatusCode(404)
+                        .setPayload(ByteString.copyFromUtf8("AlbumArt not found"));
+            }
+
+            AlbumArtMessages.AlbumArt albumArtProto = AlbumArtMapper.toProtobuf(albumArtOpt.get());
+
+            AlbumArtMessages.UpdateAlbumArtResponse updateResponse = AlbumArtMessages.UpdateAlbumArtResponse.newBuilder()
+                    .setAlbumart(albumArtProto)
+                    .build();
+
+            return TransportProtocol.Response.newBuilder()
+                    .setPayload(updateResponse.toByteString());
+
+        } catch (IllegalArgumentException e){
+            logger.error("Validation error", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(400)
+                    .setPayload(ByteString.copyFromUtf8("Validation error: " + e.getMessage()));
+        } catch (Exception e) {
+            logger.error("Error updating album art", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(ByteString.copyFromUtf8("Error: " + e.getMessage()));
+        }
+    }
+}

src/main/java/com/mediamanager/service/delegate/handler/albumhasartist/CreateAlbumHasArtistHandler.java

@@ -0,0 +1,54 @@
+package com.mediamanager.service.delegate.handler.albumhasartist;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.mapper.AlbumHasArtistMapper;
+import com.mediamanager.model.AlbumHasArtist;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.AlbumHasArtistMessages;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import com.mediamanager.service.albumhasartist.AlbumHasArtistService;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+@Action("albumhasartist.create")
+public class CreateAlbumHasArtistHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(CreateAlbumHasArtistHandler.class);
+    private final AlbumHasArtistService albumHasArtistService;
+
+    public CreateAlbumHasArtistHandler(AlbumHasArtistService albumHasArtistService) {
+        this.albumHasArtistService = albumHasArtistService;
+    }
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload) throws InvalidProtocolBufferException {
+        try{
+            AlbumHasArtistMessages.CreateAlbumHasArtistRequest createRequest =
+                    AlbumHasArtistMessages.CreateAlbumHasArtistRequest.parseFrom(requestPayload);
+
+            AlbumHasArtist albumHasArtist = albumHasArtistService.createAlbumHasArtist(
+                    createRequest.getFkAlbumId() > 0 ? createRequest.getFkAlbumId() : null,
+                    createRequest.getFkArtistId() > 0 ? createRequest.getFkArtistId() : null
+            );
+
+            AlbumHasArtistMessages.AlbumHasArtist albumHasArtistProto = AlbumHasArtistMapper.toProtobuf(albumHasArtist);
+            AlbumHasArtistMessages.CreateAlbumHasArtistResponse createAlbumHasArtistResponse = AlbumHasArtistMessages.CreateAlbumHasArtistResponse.newBuilder()
+                    .setAlbumhasartist(albumHasArtistProto)
+                    .build();
+            return TransportProtocol.Response.newBuilder()
+                    .setPayload(createAlbumHasArtistResponse.toByteString());
+        } catch (IllegalArgumentException e) {
+            logger.error("Validation error", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(400)
+                    .setPayload(ByteString.copyFromUtf8("Validation error: " + e.getMessage()));
+
+        } catch (Exception e) {
+            logger.error("Error creating album has artist", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(ByteString.copyFromUtf8("Error: " + e.getMessage()));
+        }
+    }
+}

src/main/java/com/mediamanager/service/delegate/handler/albumhasartist/DeleteAlbumHasArtistHandler.java

@@ -0,0 +1,62 @@
+package com.mediamanager.service.delegate.handler.albumhasartist;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.AlbumHasArtistMessages;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import com.mediamanager.service.albumhasartist.AlbumHasArtistService;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+@Action("albumhasartist.delete")
+public class DeleteAlbumHasArtistHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(DeleteAlbumHasArtistHandler.class);
+
+    private final AlbumHasArtistService albumHasArtistService;
+
+    public DeleteAlbumHasArtistHandler(AlbumHasArtistService albumHasArtistService) {
+        this.albumHasArtistService = albumHasArtistService;
+    }
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload)
+            throws InvalidProtocolBufferException {
+
+        try {
+            AlbumHasArtistMessages.DeleteAlbumHasArtistRequest deleteRequest =
+                    AlbumHasArtistMessages.DeleteAlbumHasArtistRequest.parseFrom(requestPayload);
+            int id = deleteRequest.getId();
+            boolean success = albumHasArtistService.deleteAlbumHasArtist(id);
+            AlbumHasArtistMessages.DeleteAlbumHasArtistResponse deleteResponse;
+            if (success) {
+                deleteResponse = AlbumHasArtistMessages.DeleteAlbumHasArtistResponse.newBuilder()
+                        .setSuccess(true)
+                        .setMessage("Album has artist deleted successfully")
+                        .build();
+                return TransportProtocol.Response.newBuilder()
+                        .setPayload(deleteResponse.toByteString());
+            } else {
+                deleteResponse = AlbumHasArtistMessages.DeleteAlbumHasArtistResponse.newBuilder()
+                        .setSuccess(false)
+                        .setMessage("Album has artist not found")
+                        .build();
+
+                return TransportProtocol.Response.newBuilder()
+                        .setStatusCode(404)
+                        .setPayload(deleteResponse.toByteString());
+            }
+        } catch (Exception e) {
+            logger.error("Error deleting album has artist", e);
+            AlbumHasArtistMessages.DeleteAlbumHasArtistResponse deleteResponse =
+                    AlbumHasArtistMessages.DeleteAlbumHasArtistResponse.newBuilder()
+                            .setSuccess(false)
+                            .setMessage("Error: " + e.getMessage())
+                            .build();
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(deleteResponse.toByteString());
+        }
+    }
+    }

src/main/java/com/mediamanager/service/delegate/handler/albumhasartist/GetAlbumHasArtistByIdHandler.java

@@ -0,0 +1,56 @@
+package com.mediamanager.service.delegate.handler.albumhasartist;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.mapper.AlbumHasArtistMapper;
+import com.mediamanager.model.AlbumHasArtist;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.AlbumHasArtistMessages;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import com.mediamanager.service.albumhasartist.AlbumHasArtistService;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.Optional;
+
+@Action(value = "albumhasartist.getById")
+public class GetAlbumHasArtistByIdHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(GetAlbumHasArtistByIdHandler.class);
+    private final AlbumHasArtistService albumHasArtistService;
+
+    public GetAlbumHasArtistByIdHandler(AlbumHasArtistService albumHasArtistService) {
+        this.albumHasArtistService = albumHasArtistService;
+    }
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload)
+        throws InvalidProtocolBufferException{
+
+        try{
+            AlbumHasArtistMessages.GetAlbumHasArtistByIdRequest getByIdRequest =
+                    AlbumHasArtistMessages.GetAlbumHasArtistByIdRequest.parseFrom(requestPayload);
+            int id = getByIdRequest.getId();
+
+            Optional<AlbumHasArtist> albumHasArtistOpt = albumHasArtistService.getAlbumHasArtistById(id);
+
+            if (albumHasArtistOpt.isEmpty()){
+                logger.warn("AlbumHasArtist not found with ID: {}", id);
+                return TransportProtocol.Response.newBuilder()
+                        .setStatusCode(404)
+                        .setPayload(ByteString.copyFromUtf8("AlbumHasArtist not found"));
+            }
+            AlbumHasArtistMessages.AlbumHasArtist albumHasArtistProto = AlbumHasArtistMapper.toProtobuf(albumHasArtistOpt.get());
+            AlbumHasArtistMessages.GetAlbumHasArtistByIdResponse getByIdResponse = AlbumHasArtistMessages.GetAlbumHasArtistByIdResponse.newBuilder()
+                    .setAlbumhasartist(albumHasArtistProto)
+                    .build();
+            return TransportProtocol.Response.newBuilder()
+                    .setPayload(getByIdResponse.toByteString());
+        } catch (Exception e) {
+            logger.error("Error getting album has artist by ID", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(ByteString.copyFromUtf8("Error: "+ e.getMessage()));
+        }
+    }
+}

src/main/java/com/mediamanager/service/delegate/handler/albumhasartist/GetAlbumHasArtistHandler.java

@@ -0,0 +1,48 @@
+package com.mediamanager.service.delegate.handler.albumhasartist;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.mapper.AlbumHasArtistMapper;
+import com.mediamanager.model.AlbumHasArtist;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.AlbumHasArtistMessages;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import com.mediamanager.service.albumhasartist.AlbumHasArtistService;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.List;
+
+
+@Action("albumhasartist.getAll")
+public class GetAlbumHasArtistHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(GetAlbumHasArtistHandler.class);
+
+    private final AlbumHasArtistService albumHasArtistService;
+
+    public GetAlbumHasArtistHandler(AlbumHasArtistService albumHasArtistService){this.albumHasArtistService = albumHasArtistService;}
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload) throws InvalidProtocolBufferException {
+        try{
+            List<AlbumHasArtist> albumHasArtists = albumHasArtistService.getAllAlbumHasArtists();
+            AlbumHasArtistMessages.GetAlbumHasArtistsResponse.Builder responseBuilder = AlbumHasArtistMessages.GetAlbumHasArtistsResponse.newBuilder();
+
+            for (AlbumHasArtist albumHasArtist : albumHasArtists) {
+                AlbumHasArtistMessages.AlbumHasArtist albumHasArtistProto = AlbumHasArtistMapper.toProtobuf(albumHasArtist);
+                responseBuilder.addAlbumhasartist(albumHasArtistProto);
+            }
+            AlbumHasArtistMessages.GetAlbumHasArtistsResponse getAlbumHasArtistsResponse = responseBuilder.build();
+
+            return TransportProtocol.Response.newBuilder()
+                    .setPayload(getAlbumHasArtistsResponse.toByteString());
+
+        }catch (Exception e){
+            logger.error("Error getting album has artists", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(ByteString.copyFromUtf8("Error: " + e.getMessage()));
+        }
+    }
+}

src/main/java/com/mediamanager/service/delegate/handler/albumhasgenre/CreateAlbumHasGenreHandler.java

@@ -0,0 +1,54 @@
+package com.mediamanager.service.delegate.handler.albumhasgenre;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.mapper.AlbumHasGenreMapper;
+import com.mediamanager.model.AlbumHasGenre;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.AlbumHasGenreMessages;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import com.mediamanager.service.albumhasgenre.AlbumHasGenreService;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+@Action("albumhasgenre.create")
+public class CreateAlbumHasGenreHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(CreateAlbumHasGenreHandler.class);
+    private final AlbumHasGenreService albumHasGenreService;
+
+    public CreateAlbumHasGenreHandler(AlbumHasGenreService albumHasGenreService) {
+        this.albumHasGenreService = albumHasGenreService;
+    }
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload) throws InvalidProtocolBufferException {
+        try{
+            AlbumHasGenreMessages.CreateAlbumHasGenreRequest createRequest =
+                    AlbumHasGenreMessages.CreateAlbumHasGenreRequest.parseFrom(requestPayload);
+
+            AlbumHasGenre albumHasGenre = albumHasGenreService.createAlbumHasGenre(
+                    createRequest.getFkAlbumId() > 0 ? createRequest.getFkAlbumId() : null,
+                    createRequest.getFkGenreId() > 0 ? createRequest.getFkGenreId() : null
+            );
+
+            AlbumHasGenreMessages.AlbumHasGenre albumHasGenreProto = AlbumHasGenreMapper.toProtobuf(albumHasGenre);
+            AlbumHasGenreMessages.CreateAlbumHasGenreResponse createAlbumHasGenreResponse = AlbumHasGenreMessages.CreateAlbumHasGenreResponse.newBuilder()
+                    .setAlbumhasgenre(albumHasGenreProto)
+                    .build();
+            return TransportProtocol.Response.newBuilder()
+                    .setPayload(createAlbumHasGenreResponse.toByteString());
+        } catch (IllegalArgumentException e) {
+            logger.error("Validation error", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(400)
+                    .setPayload(ByteString.copyFromUtf8("Validation error: " + e.getMessage()));
+
+        } catch (Exception e) {
+            logger.error("Error creating album has genre", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(ByteString.copyFromUtf8("Error: " + e.getMessage()));
+        }
+    }
+}

src/main/java/com/mediamanager/service/delegate/handler/albumhasgenre/DeleteAlbumHasGenreHandler.java

@@ -0,0 +1,62 @@
+package com.mediamanager.service.delegate.handler.albumhasgenre;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.AlbumHasGenreMessages;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import com.mediamanager.service.albumhasgenre.AlbumHasGenreService;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+@Action("albumhasgenre.delete")
+public class DeleteAlbumHasGenreHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(DeleteAlbumHasGenreHandler.class);
+
+    private final AlbumHasGenreService albumHasGenreService;
+
+    public DeleteAlbumHasGenreHandler(AlbumHasGenreService albumHasGenreService) {
+        this.albumHasGenreService = albumHasGenreService;
+    }
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload)
+            throws InvalidProtocolBufferException {
+
+        try {
+            AlbumHasGenreMessages.DeleteAlbumHasGenreRequest deleteRequest =
+                    AlbumHasGenreMessages.DeleteAlbumHasGenreRequest.parseFrom(requestPayload);
+            int id = deleteRequest.getId();
+            boolean success = albumHasGenreService.deleteAlbumHasGenre(id);
+            AlbumHasGenreMessages.DeleteAlbumHasGenreResponse deleteResponse;
+            if (success) {
+                deleteResponse = AlbumHasGenreMessages.DeleteAlbumHasGenreResponse.newBuilder()
+                        .setSuccess(true)
+                        .setMessage("Album has genre deleted successfully")
+                        .build();
+                return TransportProtocol.Response.newBuilder()
+                        .setPayload(deleteResponse.toByteString());
+            } else {
+                deleteResponse = AlbumHasGenreMessages.DeleteAlbumHasGenreResponse.newBuilder()
+                        .setSuccess(false)
+                        .setMessage("Album has genre not found")
+                        .build();
+
+                return TransportProtocol.Response.newBuilder()
+                        .setStatusCode(404)
+                        .setPayload(deleteResponse.toByteString());
+            }
+        } catch (Exception e) {
+            logger.error("Error deleting album has genre", e);
+            AlbumHasGenreMessages.DeleteAlbumHasGenreResponse deleteResponse =
+                    AlbumHasGenreMessages.DeleteAlbumHasGenreResponse.newBuilder()
+                            .setSuccess(false)
+                            .setMessage("Error: " + e.getMessage())
+                            .build();
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(deleteResponse.toByteString());
+        }
+    }
+    }

src/main/java/com/mediamanager/service/delegate/handler/albumhasgenre/GetAlbumHasGenreByIdHandler.java

@@ -0,0 +1,56 @@
+package com.mediamanager.service.delegate.handler.albumhasgenre;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.mapper.AlbumHasGenreMapper;
+import com.mediamanager.model.AlbumHasGenre;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.AlbumHasGenreMessages;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import com.mediamanager.service.albumhasgenre.AlbumHasGenreService;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.Optional;
+
+@Action(value = "albumhasgenre.getById")
+public class GetAlbumHasGenreByIdHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(GetAlbumHasGenreByIdHandler.class);
+    private final AlbumHasGenreService albumHasGenreService;
+
+    public GetAlbumHasGenreByIdHandler(AlbumHasGenreService albumHasGenreService) {
+        this.albumHasGenreService = albumHasGenreService;
+    }
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload)
+        throws InvalidProtocolBufferException{
+
+        try{
+            AlbumHasGenreMessages.GetAlbumHasGenreByIdRequest getByIdRequest =
+                    AlbumHasGenreMessages.GetAlbumHasGenreByIdRequest.parseFrom(requestPayload);
+            int id = getByIdRequest.getId();
+
+            Optional<AlbumHasGenre> albumHasGenreOpt = albumHasGenreService.getAlbumHasGenreById(id);
+
+            if (albumHasGenreOpt.isEmpty()){
+                logger.warn("AlbumHasGenre not found with ID: {}", id);
+                return TransportProtocol.Response.newBuilder()
+                        .setStatusCode(404)
+                        .setPayload(ByteString.copyFromUtf8("AlbumHasGenre not found"));
+            }
+            AlbumHasGenreMessages.AlbumHasGenre albumHasGenreProto = AlbumHasGenreMapper.toProtobuf(albumHasGenreOpt.get());
+            AlbumHasGenreMessages.GetAlbumHasGenreByIdResponse getByIdResponse = AlbumHasGenreMessages.GetAlbumHasGenreByIdResponse.newBuilder()
+                    .setAlbumhasgenre(albumHasGenreProto)
+                    .build();
+            return TransportProtocol.Response.newBuilder()
+                    .setPayload(getByIdResponse.toByteString());
+        } catch (Exception e) {
+            logger.error("Error getting album has genre by ID", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(ByteString.copyFromUtf8("Error: "+ e.getMessage()));
+        }
+    }
+}

src/main/java/com/mediamanager/service/delegate/handler/albumhasgenre/GetAlbumHasGenreHandler.java

@@ -0,0 +1,48 @@
+package com.mediamanager.service.delegate.handler.albumhasgenre;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.mapper.AlbumHasGenreMapper;
+import com.mediamanager.model.AlbumHasGenre;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.AlbumHasGenreMessages;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import com.mediamanager.service.albumhasgenre.AlbumHasGenreService;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.List;
+
+
+@Action("albumhasgenre.getAll")
+public class GetAlbumHasGenreHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(GetAlbumHasGenreHandler.class);
+
+    private final AlbumHasGenreService albumHasGenreService;
+
+    public GetAlbumHasGenreHandler(AlbumHasGenreService albumHasGenreService){this.albumHasGenreService = albumHasGenreService;}
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload) throws InvalidProtocolBufferException {
+        try{
+            List<AlbumHasGenre> albumHasGenres = albumHasGenreService.getAllAlbumHasGenres();
+            AlbumHasGenreMessages.GetAlbumHasGenresResponse.Builder responseBuilder = AlbumHasGenreMessages.GetAlbumHasGenresResponse.newBuilder();
+
+            for (AlbumHasGenre albumHasGenre : albumHasGenres) {
+                AlbumHasGenreMessages.AlbumHasGenre albumHasGenreProto = AlbumHasGenreMapper.toProtobuf(albumHasGenre);
+                responseBuilder.addAlbumhasgenre(albumHasGenreProto);
+            }
+            AlbumHasGenreMessages.GetAlbumHasGenresResponse getAlbumHasGenresResponse = responseBuilder.build();
+
+            return TransportProtocol.Response.newBuilder()
+                    .setPayload(getAlbumHasGenresResponse.toByteString());
+
+        }catch (Exception e){
+            logger.error("Error getting album has genres", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(ByteString.copyFromUtf8("Error: " + e.getMessage()));
+        }
+    }
+}

src/main/java/com/mediamanager/service/delegate/handler/albumtype/CreateAlbumTypeHandler.java

@@ -0,0 +1,49 @@
+package com.mediamanager.service.delegate.handler.albumtype;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.mapper.AlbumTypeMapper;
+import com.mediamanager.model.AlbumType;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.AlbumTypeMessages;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import com.mediamanager.service.albumtype.AlbumTypeService;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+@Action("albumtype.create")
+public class CreateAlbumTypeHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(CreateAlbumTypeHandler.class);
+    private final AlbumTypeService albumTypeService;
+
+    public CreateAlbumTypeHandler(AlbumTypeService albumTypeService) {
+        this.albumTypeService = albumTypeService;
+    }
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload) throws InvalidProtocolBufferException {
+        try{
+            AlbumTypeMessages.CreateAlbumTypeRequest createRequest =
+                    AlbumTypeMessages.CreateAlbumTypeRequest.parseFrom(requestPayload);
+            AlbumType albumType = albumTypeService.createAlbumType(createRequest.getValue());
+            AlbumTypeMessages.AlbumType albumTypeProto = AlbumTypeMapper.toProtobuf(albumType);
+            AlbumTypeMessages.CreateAlbumTypeResponse createAlbumTypeResponse = AlbumTypeMessages.CreateAlbumTypeResponse.newBuilder()
+                    .setAlbumtype(albumTypeProto)
+                    .build();
+            return TransportProtocol.Response.newBuilder()
+                    .setPayload(createAlbumTypeResponse.toByteString());
+        } catch (IllegalArgumentException e) {
+            logger.error("Validation error", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(400)
+                    .setPayload(ByteString.copyFromUtf8("Validation error: " + e.getMessage()));
+
+        } catch (Exception e) {
+            logger.error("Error creating album type", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(ByteString.copyFromUtf8("Error: " + e.getMessage()));
+        }
+    }
+}

src/main/java/com/mediamanager/service/delegate/handler/albumtype/DeleteAlbumTypeHandler.java

@@ -0,0 +1,62 @@
+package com.mediamanager.service.delegate.handler.albumtype;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.AlbumTypeMessages;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import com.mediamanager.service.albumtype.AlbumTypeService;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+@Action("albumtype.delete")
+public class DeleteAlbumTypeHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(DeleteAlbumTypeHandler.class);
+
+    private final AlbumTypeService albumTypeService;
+
+    public DeleteAlbumTypeHandler(AlbumTypeService albumTypeService) {
+        this.albumTypeService = albumTypeService;
+    }
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload)
+            throws InvalidProtocolBufferException {
+
+        try {
+            AlbumTypeMessages.DeleteAlbumTypeRequest deleteRequest =
+                    AlbumTypeMessages.DeleteAlbumTypeRequest.parseFrom(requestPayload);
+            int id = deleteRequest.getId();
+            boolean success = albumTypeService.deleteAlbumType(id);
+            AlbumTypeMessages.DeleteAlbumTypeResponse deleteResponse;
+            if (success) {
+                deleteResponse = AlbumTypeMessages.DeleteAlbumTypeResponse.newBuilder()
+                        .setSuccess(true)
+                        .setMessage("Album type deleted successfully")
+                        .build();
+                return TransportProtocol.Response.newBuilder()
+                        .setPayload(deleteResponse.toByteString());
+            } else {
+                deleteResponse = AlbumTypeMessages.DeleteAlbumTypeResponse.newBuilder()
+                        .setSuccess(false)
+                        .setMessage("Album type not found")
+                        .build();
+
+                return TransportProtocol.Response.newBuilder()
+                        .setStatusCode(404)
+                        .setPayload(deleteResponse.toByteString());
+            }
+        } catch (Exception e) {
+            logger.error("Error deleting album type", e);
+            AlbumTypeMessages.DeleteAlbumTypeResponse deleteResponse =
+                    AlbumTypeMessages.DeleteAlbumTypeResponse.newBuilder()
+                            .setSuccess(false)
+                            .setMessage("Error: " + e.getMessage())
+                            .build();
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(deleteResponse.toByteString());
+        }
+    }
+    }

src/main/java/com/mediamanager/service/delegate/handler/albumtype/GetAlbumTypeByIdHandler.java

@@ -0,0 +1,56 @@
+package com.mediamanager.service.delegate.handler.albumtype;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.mapper.AlbumTypeMapper;
+import com.mediamanager.model.AlbumType;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.AlbumTypeMessages;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import com.mediamanager.service.albumtype.AlbumTypeService;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.Optional;
+
+@Action(value = "albumtype.getById")
+public class GetAlbumTypeByIdHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(GetAlbumTypeByIdHandler.class);
+    private final AlbumTypeService albumTypeService;
+
+    public GetAlbumTypeByIdHandler(AlbumTypeService albumTypeService) {
+        this.albumTypeService = albumTypeService;
+    }
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload)
+        throws InvalidProtocolBufferException{
+
+        try{
+            AlbumTypeMessages.GetAlbumTypeByIdRequest getByIdRequest =
+                    AlbumTypeMessages.GetAlbumTypeByIdRequest.parseFrom(requestPayload);
+            int id = getByIdRequest.getId();
+
+            Optional<AlbumType> albumTypeOpt = albumTypeService.getAlbumTypeById(id);
+
+            if (albumTypeOpt.isEmpty()){
+                logger.warn("AlbumType not found with ID: {}", id);
+                return TransportProtocol.Response.newBuilder()
+                        .setStatusCode(404)
+                        .setPayload(ByteString.copyFromUtf8("AlbumType not found"));
+            }
+            AlbumTypeMessages.AlbumType albumTypeProto = AlbumTypeMapper.toProtobuf(albumTypeOpt.get());
+            AlbumTypeMessages.GetAlbumTypeByIdResponse getByIdResponse = AlbumTypeMessages.GetAlbumTypeByIdResponse.newBuilder()
+                    .setAlbumtype(albumTypeProto)
+                    .build();
+            return TransportProtocol.Response.newBuilder()
+                    .setPayload(getByIdResponse.toByteString());
+        } catch (Exception e) {
+            logger.error("Error getting album type by ID", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(ByteString.copyFromUtf8("Error: "+ e.getMessage()));
+        }
+    }
+}

src/main/java/com/mediamanager/service/delegate/handler/albumtype/GetAlbumTypeHandler.java

@@ -0,0 +1,48 @@
+package com.mediamanager.service.delegate.handler.albumtype;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.mapper.AlbumTypeMapper;
+import com.mediamanager.model.AlbumType;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.AlbumTypeMessages;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import com.mediamanager.service.albumtype.AlbumTypeService;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.List;
+
+
+@Action("albumtype.getAll")
+public class GetAlbumTypeHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(GetAlbumTypeHandler.class);
+
+    private final AlbumTypeService albumTypeService;
+
+    public GetAlbumTypeHandler(AlbumTypeService albumTypeService){this.albumTypeService = albumTypeService;}
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload) throws InvalidProtocolBufferException {
+        try{
+            List<AlbumType> albumTypes = albumTypeService.getAllAlbumTypes();
+            AlbumTypeMessages.GetAlbumTypesResponse.Builder responseBuilder = AlbumTypeMessages.GetAlbumTypesResponse.newBuilder();
+
+            for (AlbumType albumType : albumTypes) {
+                AlbumTypeMessages.AlbumType albumTypeProto = AlbumTypeMapper.toProtobuf(albumType);
+                responseBuilder.addAlbumtypes(albumTypeProto);
+            }
+            AlbumTypeMessages.GetAlbumTypesResponse getAlbumTypesResponse = responseBuilder.build();
+
+            return TransportProtocol.Response.newBuilder()
+                    .setPayload(getAlbumTypesResponse.toByteString());
+
+        }catch (Exception e){
+            logger.error("Error getting album types", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(ByteString.copyFromUtf8("Error: " + e.getMessage()));
+        }
+    }
+}

src/main/java/com/mediamanager/service/delegate/handler/albumtype/UpdateAlbumTypeHandler.java

@@ -0,0 +1,65 @@
+package com.mediamanager.service.delegate.handler.albumtype;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.mapper.AlbumTypeMapper;
+import com.mediamanager.model.AlbumType;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.AlbumTypeMessages;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import com.mediamanager.service.albumtype.AlbumTypeService;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.Optional;
+
+@Action("albumtype.update")
+public class UpdateAlbumTypeHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(UpdateAlbumTypeHandler.class);
+    private final AlbumTypeService albumTypeService;
+
+    public UpdateAlbumTypeHandler(AlbumTypeService albumTypeService) {
+        this.albumTypeService = albumTypeService;
+    }
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload) throws InvalidProtocolBufferException {
+        try{
+            AlbumTypeMessages.UpdateAlbumTypeRequest updateRequest =
+                    AlbumTypeMessages.UpdateAlbumTypeRequest.parseFrom(requestPayload);
+
+            int id = updateRequest.getId();
+            String newValue = updateRequest.getValue();
+
+            Optional<AlbumType> albumTypeOpt = albumTypeService.updateAlbumType(id, newValue);
+
+            if(albumTypeOpt.isEmpty()){
+                logger.warn("AlbumType not found with ID: {}", id);
+                return TransportProtocol.Response.newBuilder()
+                        .setStatusCode(404)
+                        .setPayload(ByteString.copyFromUtf8("AlbumType not found"));
+            }
+
+            AlbumTypeMessages.AlbumType albumTypeProto = AlbumTypeMapper.toProtobuf(albumTypeOpt.get());
+
+            AlbumTypeMessages.UpdateAlbumTypeResponse updateResponse = AlbumTypeMessages.UpdateAlbumTypeResponse.newBuilder()
+                    .setAlbumtype(albumTypeProto)
+                    .build();
+
+            return TransportProtocol.Response.newBuilder()
+                    .setPayload(updateResponse.toByteString());
+
+        } catch (IllegalArgumentException e){
+            logger.error("Validation error", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(400)
+                    .setPayload(ByteString.copyFromUtf8("Validation error: " + e.getMessage()));
+        } catch (Exception e) {
+            logger.error("Error updating album type", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(ByteString.copyFromUtf8("Error: " + e.getMessage()));
+        }
+    }
+}

src/main/java/com/mediamanager/service/delegate/handler/artist/CreateArtistHandler.java

@@ -0,0 +1,50 @@
+package com.mediamanager.service.delegate.handler.artist;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.mapper.ArtistMapper;
+import com.mediamanager.model.Artist;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.ArtistMessages;
+import com.mediamanager.service.artist.ArtistService;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+@Action("artist.create")
+public class CreateArtistHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(CreateArtistHandler.class);
+    private final ArtistService artistService;
+
+    public CreateArtistHandler(ArtistService artistService) {
+        this.artistService = artistService;
+    }
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload) throws InvalidProtocolBufferException {
+        try{
+            ArtistMessages.CreateArtistRequest createRequest =
+                    ArtistMessages.CreateArtistRequest.parseFrom(requestPayload);
+            Artist artist = artistService.createArtist(createRequest.getName());
+            ArtistMessages.Artist artistProto = ArtistMapper.toProtobuf(artist);
+            ArtistMessages.CreateArtistResponse createArtistResponse = ArtistMessages.CreateArtistResponse.newBuilder()
+                    .setArtist(artistProto)
+                    .build();
+            return TransportProtocol.Response.newBuilder()
+                    .setPayload(createArtistResponse.toByteString());
+        } catch (IllegalArgumentException e) {
+            logger.error("Validation error", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(400)
+                    .setPayload(ByteString.copyFromUtf8("Validation error: " + e.getMessage()));
+
+        } catch (Exception e) {
+            logger.error("Error creating artist", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(ByteString.copyFromUtf8("Error: " + e.getMessage()));
+        }
+    }
+}
+

src/main/java/com/mediamanager/service/delegate/handler/artist/DeleteArtistHandler.java

@@ -0,0 +1,62 @@
+package com.mediamanager.service.delegate.handler.artist;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.ArtistMessages;
+import com.mediamanager.service.artist.ArtistService;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+@Action("artist.delete")
+public class DeleteArtistHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(DeleteArtistHandler.class);
+
+    private final ArtistService artistService;
+
+    public DeleteArtistHandler(ArtistService artistService) {
+        this.artistService = artistService;
+    }
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload)
+            throws InvalidProtocolBufferException {
+
+        try {
+            ArtistMessages.DeleteArtistRequest deleteRequest =
+                    ArtistMessages.DeleteArtistRequest.parseFrom(requestPayload);
+            int id = deleteRequest.getId();
+            boolean success = artistService.deleteArtist(id);
+            ArtistMessages.DeleteArtistResponse deleteResponse;
+            if (success) {
+                deleteResponse = ArtistMessages.DeleteArtistResponse.newBuilder()
+                        .setSuccess(true)
+                        .setMessage("Artist deleted successfully")
+                        .build();
+                return TransportProtocol.Response.newBuilder()
+                        .setPayload(deleteResponse.toByteString());
+            } else {
+                deleteResponse = ArtistMessages.DeleteArtistResponse.newBuilder()
+                        .setSuccess(false)
+                        .setMessage("Artist not found")
+                        .build();
+
+                return TransportProtocol.Response.newBuilder()
+                        .setStatusCode(404)
+                        .setPayload(deleteResponse.toByteString());
+            }
+        } catch (Exception e) {
+            logger.error("Error deleting artist", e);
+            ArtistMessages.DeleteArtistResponse deleteResponse =
+                    ArtistMessages.DeleteArtistResponse.newBuilder()
+                            .setSuccess(false)
+                            .setMessage("Error: " + e.getMessage())
+                            .build();
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(deleteResponse.toByteString());
+        }
+    }
+    }

src/main/java/com/mediamanager/service/delegate/handler/artist/GetArtistByIdHandler.java

@@ -0,0 +1,56 @@
+package com.mediamanager.service.delegate.handler.artist;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.mapper.ArtistMapper;
+import com.mediamanager.model.Artist;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.ArtistMessages;
+import com.mediamanager.service.artist.ArtistService;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.Optional;
+
+@Action(value = "artist.getById")
+public class GetArtistByIdHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(GetArtistByIdHandler.class);
+    private final ArtistService artistService;
+
+    public GetArtistByIdHandler(ArtistService artistService) {
+        this.artistService = artistService;
+    }
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload)
+        throws InvalidProtocolBufferException{
+
+        try{
+            ArtistMessages.GetArtistByIdRequest getByIdRequest =
+                    ArtistMessages.GetArtistByIdRequest.parseFrom(requestPayload);
+            int id = getByIdRequest.getId();
+
+            Optional<Artist> artistOpt = artistService.getArtistById(id);
+
+            if (artistOpt.isEmpty()){
+                logger.warn("Artist not found with ID: {}", id);
+                return TransportProtocol.Response.newBuilder()
+                        .setStatusCode(404)
+                        .setPayload(ByteString.copyFromUtf8("Artist not found"));
+            }
+            ArtistMessages.Artist artistProto = ArtistMapper.toProtobuf(artistOpt.get());
+            ArtistMessages.GetArtistByIdResponse getByIdResponse = ArtistMessages.GetArtistByIdResponse.newBuilder()
+                    .setArtist(artistProto)
+                    .build();
+            return TransportProtocol.Response.newBuilder()
+                    .setPayload(getByIdResponse.toByteString());
+        } catch (Exception e) {
+            logger.error("Error getting artist by ID", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(ByteString.copyFromUtf8("Error: "+ e.getMessage()));
+        }
+    }
+}

src/main/java/com/mediamanager/service/delegate/handler/artist/GetArtistHandler.java

@@ -0,0 +1,48 @@
+package com.mediamanager.service.delegate.handler.artist;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.mapper.ArtistMapper;
+import com.mediamanager.model.Artist;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.ArtistMessages;
+import com.mediamanager.service.artist.ArtistService;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.List;
+
+
+@Action("artist.getAll")
+public class GetArtistHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(GetArtistHandler.class);
+
+    private final ArtistService artistService;
+
+    public GetArtistHandler(ArtistService artistService){this.artistService = artistService;}
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload) throws InvalidProtocolBufferException {
+        try{
+            List<Artist> artists = artistService.getAllArtists();
+            ArtistMessages.GetArtistsResponse.Builder responseBuilder = ArtistMessages.GetArtistsResponse.newBuilder();
+
+            for (Artist artist : artists) {
+                ArtistMessages.Artist artistProto = ArtistMapper.toProtobuf(artist);
+                responseBuilder.addArtists(artistProto);
+            }
+            ArtistMessages.GetArtistsResponse getArtistsResponse = responseBuilder.build();
+
+            return TransportProtocol.Response.newBuilder()
+                    .setPayload(getArtistsResponse.toByteString());
+
+        }catch (Exception e){
+            logger.error("Error getting artists", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(ByteString.copyFromUtf8("Error: " + e.getMessage()));
+        }
+    }
+}

src/main/java/com/mediamanager/service/delegate/handler/artist/UpdateArtistHandler.java

@@ -0,0 +1,65 @@
+package com.mediamanager.service.delegate.handler.artist;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.mapper.ArtistMapper;
+import com.mediamanager.model.Artist;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.ArtistMessages;
+import com.mediamanager.service.artist.ArtistService;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.Optional;
+
+@Action("artist.update")
+public class UpdateArtistHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(UpdateArtistHandler.class);
+    private final ArtistService artistService;
+
+    public UpdateArtistHandler(ArtistService artistService) {
+        this.artistService = artistService;
+    }
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload) throws InvalidProtocolBufferException {
+        try{
+            ArtistMessages.UpdateArtistRequest updateRequest =
+                    ArtistMessages.UpdateArtistRequest.parseFrom(requestPayload);
+
+            int id = updateRequest.getId();
+            String newName = updateRequest.getName();
+
+            Optional<Artist> artistOpt = artistService.updateArtist(id, newName);
+
+            if(artistOpt.isEmpty()){
+                logger.warn("Artist not found with ID: {}", id);
+                return TransportProtocol.Response.newBuilder()
+                        .setStatusCode(404)
+                        .setPayload(ByteString.copyFromUtf8("Artist not found"));
+            }
+
+            ArtistMessages.Artist artistProto = ArtistMapper.toProtobuf(artistOpt.get());
+
+            ArtistMessages.UpdateArtistResponse updateResponse = ArtistMessages.UpdateArtistResponse.newBuilder()
+                    .setArtist(artistProto)
+                    .build();
+
+            return TransportProtocol.Response.newBuilder()
+                    .setPayload(updateResponse.toByteString());
+
+        } catch (IllegalArgumentException e){
+            logger.error("Validation error", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(400)
+                    .setPayload(ByteString.copyFromUtf8("Validation error: " + e.getMessage()));
+        } catch (Exception e) {
+            logger.error("Error updating artist", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(ByteString.copyFromUtf8("Error: " + e.getMessage()));
+        }
+    }
+}

src/main/java/com/mediamanager/service/delegate/handler/bitdepth/CreateBitDepthHandler.java

@@ -0,0 +1,51 @@
+package com.mediamanager.service.delegate.handler.bitdepth;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.mapper.BitDepthMapper;
+import com.mediamanager.model.BitDepth;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.ArtistMessages;
+import com.mediamanager.protocol.messages.BitDepthMessages;
+import com.mediamanager.service.bitdepth.BitDepthService;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+@Action("bitdepth.create")
+public class CreateBitDepthHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(CreateBitDepthHandler.class);
+    private final BitDepthService bitDepthService;
+
+    public CreateBitDepthHandler(BitDepthService bitDepthService) {
+        this.bitDepthService = bitDepthService;
+    }
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload) throws InvalidProtocolBufferException {
+        try{
+            BitDepthMessages.CreateBitDepthRequest createRequest =
+                    BitDepthMessages.CreateBitDepthRequest.parseFrom(requestPayload);
+            BitDepth bitDepth = bitDepthService.createBitDepth(createRequest.getValue());
+            BitDepthMessages.BitDepth BitDepthProto = BitDepthMapper.toProtobuf(bitDepth);
+            BitDepthMessages.CreateBitDepthResponse createBitDepthResponse = BitDepthMessages.CreateBitDepthResponse.newBuilder()
+                    .setBitdepth(BitDepthProto)
+                    .build();
+            return TransportProtocol.Response.newBuilder()
+                    .setPayload(createBitDepthResponse.toByteString());
+        } catch (IllegalArgumentException e) {
+            logger.error("Validation error", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(400)
+                    .setPayload(ByteString.copyFromUtf8("Validation error: " + e.getMessage()));
+
+        } catch (Exception e) {
+            logger.error("Error creating bit-depth", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(ByteString.copyFromUtf8("Error: " + e.getMessage()));
+        }
+    }
+}
+