Merge 026a3aefa4 into 86da601ad6

Implement BitDepth Management with CRUD Operations

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

@@ -2,10 +2,9 @@ package com.mediamanager.service.delegate;
 
 import com.google.protobuf.ByteString;
 import com.mediamanager.protocol.TransportProtocol;
-import com.mediamanager.repository.ComposerRepository;
-import com.mediamanager.repository.GenreRepository;
+import com.mediamanager.repository.*;
+import com.mediamanager.service.bitdepth.BitDepthService;
 import com.mediamanager.service.composer.ComposerService;
-import com.mediamanager.repository.ArtistRepository;
 import com.mediamanager.repository.GenreRepository;
 import com.mediamanager.service.artist.ArtistService;
 import com.mediamanager.service.delegate.annotation.Action;
@@ -58,14 +57,13 @@ public class DelegateActionManager {
 
         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();
 

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/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;
+}