Update src/main/java/com/mediamanager/service/delegate/handler/bitdepth/UpdateBitDepthHandler.java

Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com>

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/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/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/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/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/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/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/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/delegate/DelegateActionManager.java

@@ -2,47 +2,76 @@ package com.mediamanager.service.delegate;
 
 import com.google.protobuf.ByteString;
 import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.repository.*;
+import com.mediamanager.service.bitdepth.BitDepthService;
+import com.mediamanager.service.composer.ComposerService;
 import com.mediamanager.repository.GenreRepository;
-import com.mediamanager.service.delegate.handler.CloseHandler;
+import com.mediamanager.service.artist.ArtistService;
-import com.mediamanager.service.delegate.handler.EchoHandler;
+import com.mediamanager.service.delegate.annotation.Action;
-import com.mediamanager.service.delegate.handler.HeartbeatHandler;
+
-import com.mediamanager.service.delegate.handler.genre.*;
 import com.mediamanager.service.genre.GenreService;
 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;
-    private final GenreService genreService;
+
 
     public DelegateActionManager(EntityManagerFactory entityManagerFactory) {
         this.entityManagerFactory = entityManagerFactory;
+        this.serviceLocator = new ServiceLocator();
+
+        initializeServices();
+
 
-        GenreRepository genreRepository = new GenreRepository(entityManagerFactory);
-        this.genreService = new GenreService(genreRepository);
         logger.debug("DelegateActionManager created");
         this.handlerRegistry = new HashMap<>();
-        registerHandlers();
+        autoRegisterHandlers();
+
     }
 
-    private void registerHandlers() {
+    private void initializeServices() {
-        handlerRegistry.put("echo",new EchoHandler());
+        logger.info("Initializing services...");
-        handlerRegistry.put("heartbeat",new HeartbeatHandler());
+
-        handlerRegistry.put("close", new CloseHandler());
+
-        handlerRegistry.put("create_genre", new CreateGenreHandler(genreService));
+        GenreRepository genreRepository = new GenreRepository(entityManagerFactory);
-        handlerRegistry.put("get_genres", new GetGenreHandler(genreService));
+        GenreService genreService = new GenreService(genreRepository);
-        handlerRegistry.put("get_genre_by_id", new GetGenreByIdHandler(genreService));
+
-        handlerRegistry.put("update_genre", new UpdateGenreHandler(genreService));
+
-        handlerRegistry.put("delete_genre", new DeleteGenreHandler(genreService));
+        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);
+
+        serviceLocator.logRegisteredServices();
+
+        logger.info("Services initialized successfully");
     }
 
+
+
     public void start(){
         logger.info("DelegateActionManager started");
     }
@@ -51,6 +80,117 @@ public class DelegateActionManager {
         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);

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

@@ -6,9 +6,11 @@ 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);
 

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

@@ -6,9 +6,11 @@ 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);
 

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

@@ -6,9 +6,11 @@ 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);
 

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,52 @@
+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()
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(ByteString.copyFromUtf8("Error: " + e.getMessage()));
+        }
+    }
+}
+

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

@@ -0,0 +1,62 @@
+package com.mediamanager.service.delegate.handler.bitdepth;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.protocol.TransportProtocol;
+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.delete")
+public class DeleteBitDepthHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(DeleteBitDepthHandler.class);
+
+    private final BitDepthService bitDepthService;
+
+    public DeleteBitDepthHandler(BitDepthService bitDepthService) {
+        this.bitDepthService = bitDepthService;
+    }
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload)
+            throws InvalidProtocolBufferException {
+
+        try {
+            BitDepthMessages.DeleteBitDepthRequest deleteRequest =
+                    BitDepthMessages.DeleteBitDepthRequest.parseFrom(requestPayload);
+            int id = deleteRequest.getId();
+            boolean success = bitDepthService.deleteBitDepth(id);
+            BitDepthMessages.DeleteBitDepthResponse deleteResponse;
+            if (success) {
+                deleteResponse = BitDepthMessages.DeleteBitDepthResponse.newBuilder()
+                        .setSuccess(true)
+                        .setMessage("Bit-Depth deleted successfully")
+                        .build();
+                return TransportProtocol.Response.newBuilder()
+                        .setPayload(deleteResponse.toByteString());
+            } else {
+                deleteResponse = BitDepthMessages.DeleteBitDepthResponse.newBuilder()
+                        .setSuccess(false)
+                        .setMessage("Bit-Depth not found")
+                        .build();
+
+                return TransportProtocol.Response.newBuilder()
+                        .setStatusCode(404)
+                        .setPayload(deleteResponse.toByteString());
+            }
+        } catch (Exception e) {
+            logger.error("Error deleting bit-depth", e);
+            BitDepthMessages.DeleteBitDepthResponse deleteResponse =
+                    BitDepthMessages.DeleteBitDepthResponse.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/bitdepth/GetBitDepthByIdHandler.java

@@ -0,0 +1,56 @@
+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.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;
+
+import java.util.Optional;
+
+@Action(value = "bitdepth.getById")
+public class GetBitDepthByIdHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(GetBitDepthByIdHandler.class);
+    private final BitDepthService bitDepthServicee;
+
+    public GetBitDepthByIdHandler(BitDepthService bitDepthServicee) {
+        this.bitDepthServicee = bitDepthServicee;
+    }
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload)
+        throws InvalidProtocolBufferException{
+
+        try{
+            BitDepthMessages.GetBitDepthByIdRequest getByIdRequest =
+                    BitDepthMessages.GetBitDepthByIdRequest.parseFrom(requestPayload);
+            int id = getByIdRequest.getId();
+
+            Optional<BitDepth> bitDepthOpt = bitDepthServicee.getBitDepthById(id);
+
+            if (bitDepthOpt.isEmpty()){
+                logger.warn("BitDepth not found with ID: {}", id);
+                return TransportProtocol.Response.newBuilder()
+                        .setStatusCode(404)
+                        .setPayload(ByteString.copyFromUtf8("BitDepth not found"));
+            }
+            BitDepthMessages.BitDepth bitDepthProto = BitDepthMapper.toProtobuf(bitDepthOpt.get());
+            BitDepthMessages.GetBitDepthByIdResponse getByIdResponse = BitDepthMessages.GetBitDepthByIdResponse.newBuilder()
+                    .setBitdepth(bitDepthProto)
+                    .build();
+            return TransportProtocol.Response.newBuilder()
+                    .setPayload(getByIdResponse.toByteString());
+        } catch (Exception e) {
+            logger.error("Error getting bit-depth by ID", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(ByteString.copyFromUtf8("Error: "+ e.getMessage()));
+        }
+    }
+}

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

@@ -0,0 +1,48 @@
+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.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;
+
+import java.util.List;
+
+
+@Action("bitdepth.getAll")
+public class GetBitDepthHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(GetBitDepthHandler.class);
+
+    private final BitDepthService bitDepthService;
+
+    public GetBitDepthHandler(BitDepthService bitDepthService){this.bitDepthService = bitDepthService;}
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload) throws InvalidProtocolBufferException {
+        try{
+            List<BitDepth> bitDepths = bitDepthService.getAllBitDepths();
+            BitDepthMessages.GetBitDepthsResponse.Builder responseBuilder = BitDepthMessages.GetBitDepthsResponse.newBuilder();
+
+            for (BitDepth bitDepth : bitDepths) {
+                BitDepthMessages.BitDepth bitDepthProto = BitDepthMapper.toProtobuf(bitDepth);
+                responseBuilder.addBitdepths(bitDepthProto);
+            }
+            BitDepthMessages.GetBitDepthsResponse getBitDepthsResponse = responseBuilder.build();
+
+            return TransportProtocol.Response.newBuilder()
+                    .setPayload(getBitDepthsResponse.toByteString());
+
+        }catch (Exception e){
+            logger.error("Error getting bit-depths", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(ByteString.copyFromUtf8("Error: " + e.getMessage()));
+        }
+    }
+}

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

@@ -0,0 +1,65 @@
+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.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;
+
+import java.util.Optional;
+
+@Action("bitdepth.update")
+public class UpdateBitDepthHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(UpdateBitDepthHandler.class);
+    private final BitDepthService bitDepthService;
+
+    public UpdateBitDepthHandler(BitDepthService bitDepthService) {
+        this.bitDepthService = bitDepthService;
+    }
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload) throws InvalidProtocolBufferException {
+        try{
+            BitDepthMessages.UpdateBitDepthRequest updateRequest =
+                    BitDepthMessages.UpdateBitDepthRequest.parseFrom(requestPayload);
+
+            int id = updateRequest.getId();
+            String newValue = updateRequest.getValue();
+
+            Optional<BitDepth> bitDepthOpt = bitDepthService.updateBitDepth(id, newValue);
+
+            if(bitDepthOpt.isEmpty()){
+                logger.warn("BitDepth not found with ID: {}", id);
+                return TransportProtocol.Response.newBuilder()
+                        .setStatusCode(404)
+                        .setPayload(ByteString.copyFromUtf8("BitDepth not found"));
+            }
+
+            BitDepthMessages.BitDepth bitDepthProto = BitDepthMapper.toProtobuf(bitDepthOpt.get());
+
+            BitDepthMessages.UpdateBitDepthResponse updateResponse = BitDepthMessages.UpdateBitDepthResponse.newBuilder()
+                    .setBitdepth(bitDepthProto)
+                    .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 bit-depth", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(ByteString.copyFromUtf8("Error: " + e.getMessage()));
+        }
+    }
+}

src/main/java/com/mediamanager/service/delegate/handler/composer/CreateComposerHandler.java

@@ -0,0 +1,51 @@
+package com.mediamanager.service.delegate.handler.composer;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.mapper.ComposerMapper;
+import com.mediamanager.model.Composer;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.ComposerMessages;
+import com.mediamanager.service.composer.ComposerService;
+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("composer.create")
+public class CreateComposerHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(CreateComposerHandler.class);
+    private final ComposerService composerService;
+
+    public CreateComposerHandler(ComposerService composerService) {
+        this.composerService = composerService;
+    }
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload)
+            throws InvalidProtocolBufferException {
+        try{
+            ComposerMessages.CreateComposerRequest CreateRequest = ComposerMessages.CreateComposerRequest
+                    .parseFrom(requestPayload);
+            Composer composer = composerService.createComposer(CreateRequest.getName());
+            ComposerMessages.Composer composerProto = ComposerMapper.toProtobuf(composer);
+            ComposerMessages.CreateComposerResponse createResponse = ComposerMessages.CreateComposerResponse
+                    .newBuilder().setComposer(composerProto).build();
+            return TransportProtocol.Response.newBuilder().setPayload(createResponse.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 composer", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(ByteString.copyFromUtf8("Error: " + e.getMessage()));
+        }
+
+    }
+}

src/main/java/com/mediamanager/service/delegate/handler/composer/DeleteComposerHandler.java

@@ -0,0 +1,53 @@
+package com.mediamanager.service.delegate.handler.composer;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.ComposerMessages;
+import com.mediamanager.service.composer.ComposerService;
+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( "composer.delete")
+public class DeleteComposerHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(DeleteComposerHandler.class);
+    private final ComposerService composerService;
+
+
+    public DeleteComposerHandler(ComposerService composerService){
+        this.composerService = composerService;
+    }
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload)
+            throws InvalidProtocolBufferException {
+        try {
+            ComposerMessages.DeleteComposerRequest deleteRequest =
+                    ComposerMessages.DeleteComposerRequest.parseFrom(requestPayload);
+            int id = deleteRequest.getId();
+            boolean success = composerService.deleteComposer(id);
+            ComposerMessages.DeleteComposerResponse deleteResponse;
+            if(success){
+                deleteResponse = ComposerMessages.DeleteComposerResponse.newBuilder().setSuccess(true)
+                        .setMessage("Composer deleted successfully").build();
+
+
+                return TransportProtocol.Response.newBuilder()
+                        .setPayload(deleteResponse.toByteString());
+            }else {
+                deleteResponse = ComposerMessages.DeleteComposerResponse.newBuilder().setSuccess(false)
+                        .setMessage("Composer not found").build();
+                return TransportProtocol.Response.newBuilder().setStatusCode(404)
+                        .setPayload(deleteResponse.toByteString());
+            }
+
+        } catch (Exception e) {
+            logger.error("Error deleting composer", e);
+            ComposerMessages.DeleteComposerResponse deleteResponse = ComposerMessages.DeleteComposerResponse
+                    .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/composer/GetComposerByIdHandler.java

@@ -0,0 +1,57 @@
+package com.mediamanager.service.delegate.handler.composer;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.mapper.ComposerMapper;
+import com.mediamanager.model.Composer;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.ComposerMessages;
+import com.mediamanager.service.composer.ComposerService;
+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( "composer.getById")
+public class GetComposerByIdHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(GetComposerByIdHandler.class);
+    private final ComposerService composerService;
+
+    public GetComposerByIdHandler(ComposerService composerService){
+        this.composerService = composerService;
+    }
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload)
+            throws InvalidProtocolBufferException {
+        try{
+
+            ComposerMessages.GetComposerByIdRequest getByIdRequest = ComposerMessages.GetComposerByIdRequest
+                    .parseFrom(requestPayload);
+            int id = getByIdRequest.getId();
+
+            Optional<Composer> composerOpt = composerService.getComposerById(id);
+
+            if (composerOpt.isEmpty()) {
+              logger.warn("Composer not found with ID: {}", id);
+              return TransportProtocol.Response.newBuilder()
+                      .setStatusCode(404)
+                      .setPayload(ByteString.copyFromUtf8("Composer not found"));
+            }
+
+            ComposerMessages.Composer composerProto = ComposerMapper.toProtobuf(composerOpt.get());
+
+            ComposerMessages.GetComposerByIdResponse getByIdResponse = ComposerMessages.GetComposerByIdResponse
+                    .newBuilder().setComposer(composerProto).build();
+
+            return TransportProtocol.Response.newBuilder().setPayload(getByIdResponse.toByteString());
+        } catch (Exception e) {
+            logger.error("Error getting composer by ID", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(ByteString.copyFromUtf8("Error: " + e.getMessage()));
+        }
+    }
+}

src/main/java/com/mediamanager/service/delegate/handler/composer/GetComposerHandler.java

@@ -0,0 +1,50 @@
+package com.mediamanager.service.delegate.handler.composer;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.mapper.ComposerMapper;
+import com.mediamanager.model.Composer;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.ComposerMessages;
+import com.mediamanager.protocol.messages.GenreMessages;
+import com.mediamanager.service.composer.ComposerService;
+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( "composer.getAll")
+public class GetComposerHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(GetComposerHandler.class);
+    private final ComposerService composerService;
+
+    public GetComposerHandler(ComposerService composerService){
+        this.composerService = composerService;
+    }
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload)
+            throws InvalidProtocolBufferException {
+
+        try{
+            List<Composer> composers = composerService.getAllComposers();
+
+            ComposerMessages.GetComposersResponse.Builder responseBuilder = ComposerMessages.GetComposersResponse.newBuilder();
+            for(Composer composer : composers){
+                ComposerMessages.Composer composerProto = ComposerMapper.toProtobuf(composer);
+                responseBuilder.addComposers(composerProto);
+            }
+            ComposerMessages.GetComposersResponse getGenresResponse = responseBuilder.build();
+            return TransportProtocol.Response.newBuilder().setPayload(getGenresResponse.toByteString());
+        } catch (Exception e) {
+            logger.error("Error getting composers", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(ByteString.copyFromUtf8("Error: " + e.getMessage()));
+        }
+
+    }
+
+}

src/main/java/com/mediamanager/service/delegate/handler/composer/UpdateComposerHandler.java

@@ -0,0 +1,56 @@
+package com.mediamanager.service.delegate.handler.composer;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.mapper.ComposerMapper;
+import com.mediamanager.model.Composer;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.ComposerMessages;
+import com.mediamanager.service.composer.ComposerService;
+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("composer.update")
+public class UpdateComposerHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(UpdateComposerHandler.class);
+    private final ComposerService composerService;
+    public UpdateComposerHandler(ComposerService composerService){
+        this.composerService = composerService;
+    }
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload)
+            throws InvalidProtocolBufferException {
+        try{
+            ComposerMessages.UpdateComposerRequest updateRequest = ComposerMessages.UpdateComposerRequest
+                    .parseFrom(requestPayload);
+            int id = updateRequest.getId();
+            String newName = updateRequest.getName();
+            Optional<Composer> composerOpt = composerService.updateComposer(id, newName);
+            if (composerOpt.isEmpty()) {
+                logger.warn("Composer not found with ID: {}", id);
+                return TransportProtocol.Response.newBuilder()
+                        .setStatusCode(404)
+                        .setPayload(ByteString.copyFromUtf8("Composer not found"));
+            }
+            ComposerMessages.Composer composerProto = ComposerMapper.toProtobuf(composerOpt.get());
+            ComposerMessages.UpdateComposerResponse updateResponse = ComposerMessages.UpdateComposerResponse
+                    .newBuilder().setComposer(composerProto).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 composer", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(ByteString.copyFromUtf8("Error: " + e.getMessage()));
+        }
+    }
+}

src/main/java/com/mediamanager/service/delegate/handler/genre/CreateGenreHandler.java

@@ -7,10 +7,12 @@ import com.mediamanager.model.Genre;
 import com.mediamanager.protocol.TransportProtocol;
 import com.mediamanager.protocol.messages.GenreMessages;
 import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
 import com.mediamanager.service.genre.GenreService;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
+@Action("genre.create")
 public class CreateGenreHandler implements ActionHandler {
     private static final Logger logger = LogManager.getLogger(CreateGenreHandler.class);
 

src/main/java/com/mediamanager/service/delegate/handler/genre/DeleteGenreHandler.java

@@ -5,10 +5,12 @@ import com.google.protobuf.InvalidProtocolBufferException;
 import com.mediamanager.protocol.TransportProtocol;
 import com.mediamanager.protocol.messages.GenreMessages;
 import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
 import com.mediamanager.service.genre.GenreService;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
+@Action("genre.delete")
 public class DeleteGenreHandler implements ActionHandler {
     private static final Logger logger = LogManager.getLogger(DeleteGenreHandler.class);
 

src/main/java/com/mediamanager/service/delegate/handler/genre/GetGenreByIdHandler.java

@@ -7,12 +7,14 @@ import com.mediamanager.model.Genre;
 import com.mediamanager.protocol.TransportProtocol;
 import com.mediamanager.protocol.messages.GenreMessages;
 import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
 import com.mediamanager.service.genre.GenreService;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
 import java.util.Optional;
 
+@Action("genre.getById")
 public class GetGenreByIdHandler implements ActionHandler {
     private static final Logger logger = LogManager.getLogger(GetGenreByIdHandler.class);
 

src/main/java/com/mediamanager/service/delegate/handler/genre/GetGenreHandler.java

@@ -7,12 +7,14 @@ import com.mediamanager.model.Genre;
 import com.mediamanager.protocol.TransportProtocol;
 import com.mediamanager.protocol.messages.GenreMessages;
 import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
 import com.mediamanager.service.genre.GenreService;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
 import java.util.List;
 
+@Action("genre.getAll")
 public class GetGenreHandler implements ActionHandler {
     private static final Logger logger = LogManager.getLogger(GetGenreHandler.class);
 

src/main/java/com/mediamanager/service/delegate/handler/genre/UpdateGenreHandler.java

@@ -7,12 +7,14 @@ import com.mediamanager.model.Genre;
 import com.mediamanager.protocol.TransportProtocol;
 import com.mediamanager.protocol.messages.GenreMessages;
 import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
 import com.mediamanager.service.genre.GenreService;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
 import java.util.Optional;
 
+@Action("genre.update")
 public class UpdateGenreHandler implements ActionHandler {
     private static final Logger logger = LogManager.getLogger(UpdateGenreHandler.class);
 

src/main/proto/artist.proto

@@ -0,0 +1,53 @@
+syntax = "proto3";
+
+option java_package = "com.mediamanager.protocol.messages";
+option java_outer_classname = "ArtistMessages";
+
+package mediamanager.messages;
+
+message Artist {
+  int32 id = 1;
+  string name = 2;
+}
+
+message CreateArtistRequest {
+  string name = 1;
+}
+
+message CreateArtistResponse {
+  Artist artist = 1;
+}
+
+message GetArtistsRequest {
+
+}
+
+message GetArtistsResponse {
+  repeated Artist artists = 1;
+}
+
+message GetArtistByIdRequest {
+  int32 id = 1;
+}
+
+message GetArtistByIdResponse {
+  Artist artist = 1;
+}
+
+message UpdateArtistRequest {
+  int32 id = 1;
+  string name = 2;  // Novo nome
+}
+
+message UpdateArtistResponse {
+  Artist Artist = 1;
+}
+
+message DeleteArtistRequest {
+  int32 id = 1;
+}
+
+message DeleteArtistResponse {
+  bool success = 1;
+  string message = 2;
+}

src/main/proto/bitdepth.proto

@@ -0,0 +1,53 @@
+syntax = "proto3";
+
+option java_package = "com.mediamanager.protocol.messages";
+option java_outer_classname = "BitDepthMessages";
+
+package mediamanager.messages;
+
+message BitDepth {
+  int32 id = 1;
+  string value = 2;
+}
+
+message CreateBitDepthRequest {
+  string value = 1;
+}
+
+message CreateBitDepthResponse {
+  BitDepth bitdepth = 1;
+}
+
+message GetBitDepthsRequest {
+
+}
+
+message GetBitDepthsResponse {
+  repeated BitDepth bitdepths = 1;
+}
+
+message GetBitDepthByIdRequest {
+  int32 id = 1;
+}
+
+message GetBitDepthByIdResponse {
+  BitDepth bitdepth = 1;
+}
+
+message UpdateBitDepthRequest {
+  int32 id = 1;
+  string value = 2;  // Novo nome
+}
+
+message UpdateBitDepthResponse {
+  BitDepth bitdepth = 1;
+}
+
+message DeleteBitDepthRequest {
+  int32 id = 1;
+}
+
+message DeleteBitDepthResponse {
+  bool success = 1;
+  string message = 2;
+}

src/main/proto/composer.proto

@@ -0,0 +1,51 @@
+syntax = "proto3";
+
+option java_package = "com.mediamanager.protocol.messages";
+option java_outer_classname = "ComposerMessages";
+
+package mediamanager.messages;
+
+message Composer {
+  int32 id =1;
+  string name =2;
+}
+
+message CreateComposerRequest{
+  string name =1;
+}
+
+message CreateComposerResponse{
+  Composer composer = 1;
+}
+
+message GetComposersRequest{}
+
+message GetComposersResponse{
+  repeated Composer composers = 1;
+}
+
+message GetComposerByIdRequest{
+  int32 id =1;
+}
+
+message GetComposerByIdResponse{
+  Composer composer =1;
+}
+
+message UpdateComposerRequest{
+  int32 id = 1;
+  string name=2;
+}
+
+message UpdateComposerResponse{
+  Composer composer = 1;
+}
+
+message DeleteComposerRequest{
+  int32 id = 1;
+}
+
+message DeleteComposerResponse{
+  bool success = 1;
+  string message = 2;
+}