From 7446047b9ddb7b77687b8d066d02cce109004dcc Mon Sep 17 00:00:00 2001 From: Gustavo Henrique Santos Souza de Miranda Date: Sun, 7 Dec 2025 13:15:01 -0300 Subject: [PATCH] Implement AlbumType management with full CRUD operations MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This commit introduces comprehensive AlbumType entity management following the established repository pattern used for other entities like SamplingRate and AlbumArt. Key components implemented: Model Layer: - AlbumType entity with id and value fields - JPA annotations for database persistence - Complete getters and setters Repository Layer: - AlbumTypeRepository with EntityManager-based operations - Full transaction management with proper rollback handling - Methods: save, findAll, findById, update, deleteById Service Layer: - AlbumTypeService with business logic and validation - Input validation for null/empty value fields - ID validation for all operations requiring entity lookup - Comprehensive logging using Log4j2 Mapper Layer: - AlbumTypeMapper for bidirectional entity/protobuf conversion - Null safety checks and validation - Proper handling of optional ID field Action Handlers: - CreateAlbumTypeHandler (albumtype.create) - GetAlbumTypeHandler (albumtype.getAll) - GetAlbumTypeByIdHandler (albumtype.getById) - UpdateAlbumTypeHandler (albumtype.update) - DeleteAlbumTypeHandler (albumtype.delete) - HTTP status code handling: 200 (success), 400 (validation), 404 (not found), 500 (server error) Protocol Buffers: - Complete proto definition with AlbumTypeMessages - All CRUD message definitions (Create, Get, GetById, Update, Delete) Service Registration: - AlbumTypeRepository initialized with EntityManagerFactory - AlbumTypeService registered with ServiceLocator for dependency injection - Ensures all AlbumType action handlers can resolve dependencies The implementation follows best practices with proper error handling, logging, validation, and consistency with existing codebase patterns. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Sonnet 4.5 --- .../mediamanager/mapper/AlbumTypeMapper.java | 35 ++++++ .../com/mediamanager/model/AlbumType.java | 31 ++++++ .../repository/AlbumTypeRepository.java | 103 ++++++++++++++++++ .../service/albumtype/AlbumTypeService.java | 69 ++++++++++++ .../delegate/DelegateActionManager.java | 5 + .../albumtype/CreateAlbumTypeHandler.java | 49 +++++++++ .../albumtype/DeleteAlbumTypeHandler.java | 62 +++++++++++ .../albumtype/GetAlbumTypeByIdHandler.java | 56 ++++++++++ .../albumtype/GetAlbumTypeHandler.java | 48 ++++++++ .../albumtype/UpdateAlbumTypeHandler.java | 65 +++++++++++ src/main/proto/albumtype.proto | 53 +++++++++ 11 files changed, 576 insertions(+) create mode 100644 src/main/java/com/mediamanager/mapper/AlbumTypeMapper.java create mode 100644 src/main/java/com/mediamanager/model/AlbumType.java create mode 100644 src/main/java/com/mediamanager/repository/AlbumTypeRepository.java create mode 100644 src/main/java/com/mediamanager/service/albumtype/AlbumTypeService.java create mode 100644 src/main/java/com/mediamanager/service/delegate/handler/albumtype/CreateAlbumTypeHandler.java create mode 100644 src/main/java/com/mediamanager/service/delegate/handler/albumtype/DeleteAlbumTypeHandler.java create mode 100644 src/main/java/com/mediamanager/service/delegate/handler/albumtype/GetAlbumTypeByIdHandler.java create mode 100644 src/main/java/com/mediamanager/service/delegate/handler/albumtype/GetAlbumTypeHandler.java create mode 100644 src/main/java/com/mediamanager/service/delegate/handler/albumtype/UpdateAlbumTypeHandler.java create mode 100644 src/main/proto/albumtype.proto diff --git a/src/main/java/com/mediamanager/mapper/AlbumTypeMapper.java b/src/main/java/com/mediamanager/mapper/AlbumTypeMapper.java new file mode 100644 index 0000000..2bdfbe1 --- /dev/null +++ b/src/main/java/com/mediamanager/mapper/AlbumTypeMapper.java @@ -0,0 +1,35 @@ +package com.mediamanager.mapper; + +import com.mediamanager.model.AlbumType; +import com.mediamanager.protocol.messages.AlbumTypeMessages; + +public class AlbumTypeMapper { + public static AlbumTypeMessages.AlbumType toProtobuf(AlbumType entity) { + if (entity == null) { + return null; + } + String value = entity.getValue(); + if (value == null || value.isEmpty()) { + throw new IllegalArgumentException("Value cannot be null or empty"); + } + AlbumTypeMessages.AlbumType.Builder builder = AlbumTypeMessages.AlbumType.newBuilder() + .setValue(value); + Integer id = entity.getId(); + if (id != null) { + builder.setId(id); + } + return builder.build(); + } + + public static AlbumType toEntity(AlbumTypeMessages.AlbumType protobuf) { + if (protobuf == null) { + return null; + } + AlbumType entity = new AlbumType(); + if (protobuf.getId() >0) { + entity.setId(protobuf.getId()); + } + entity.setValue(protobuf.getValue()); + return entity; + } +} diff --git a/src/main/java/com/mediamanager/model/AlbumType.java b/src/main/java/com/mediamanager/model/AlbumType.java new file mode 100644 index 0000000..ac5fad7 --- /dev/null +++ b/src/main/java/com/mediamanager/model/AlbumType.java @@ -0,0 +1,31 @@ +package com.mediamanager.model; + +import jakarta.persistence.*; + +@Entity +@Table(name = "albumtype") +public class AlbumType { + + @Id + @GeneratedValue(strategy = GenerationType.IDENTITY) + private Integer id; + + @Column(nullable = false) + private String value; + + public Integer getId() { + return id; + } + + public void setId(Integer id) { + this.id = id; + } + + public String getValue() { + return value; + } + + public void setValue(String value) { + this.value = value; + } +} diff --git a/src/main/java/com/mediamanager/repository/AlbumTypeRepository.java b/src/main/java/com/mediamanager/repository/AlbumTypeRepository.java new file mode 100644 index 0000000..f359e38 --- /dev/null +++ b/src/main/java/com/mediamanager/repository/AlbumTypeRepository.java @@ -0,0 +1,103 @@ +package com.mediamanager.repository; + + +import com.mediamanager.model.AlbumType; +import jakarta.persistence.EntityManager; +import jakarta.persistence.EntityManagerFactory; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; + + +import java.util.List; +import java.util.Optional; + +public class AlbumTypeRepository { + private static final Logger logger = LogManager.getLogger(AlbumTypeRepository.class); + + private final EntityManagerFactory entityManagerFactory; + + public AlbumTypeRepository(EntityManagerFactory entityManagerFactory) { + this.entityManagerFactory = entityManagerFactory; + } + + public AlbumType save(AlbumType albumType) { + logger.debug("Saving AlbumType: {}", albumType.getValue()); + EntityManager em = entityManagerFactory.createEntityManager(); + em.getTransaction().begin(); + try { + em.persist(albumType); + em.getTransaction().commit(); + logger.debug("AlbumType has been saved successfully"); + return albumType; + } catch (Exception e) { + em.getTransaction().rollback(); + logger.error("Error while saving AlbumType: {}", e.getMessage()); + throw e; + } finally { + if (em.isOpen()) em.close(); + } + } + + public List findAll() { + logger.debug("Finding All AlbumType"); + EntityManager em = entityManagerFactory.createEntityManager(); + try{ + return em.createQuery("select a from AlbumType a", AlbumType.class).getResultList(); + }finally { + if (em.isOpen()) em.close(); + } + } + + public Optional findById(Integer id) { + logger.debug("Finding AlbumType with id: {}", id); + EntityManager em = entityManagerFactory.createEntityManager(); + try{ + AlbumType albumType = em.find(AlbumType.class, id); + return Optional.ofNullable(albumType); + }finally { + if (em.isOpen()) em.close(); + } + } + + public AlbumType update(AlbumType albumType) { + logger.debug("Updating AlbumType: {}", albumType.getValue()); + EntityManager em = entityManagerFactory.createEntityManager(); + em.getTransaction().begin(); + try { + AlbumType updated = em.merge(albumType); + em.getTransaction().commit(); + logger.debug("AlbumType has been updated successfully"); + return updated; + } catch (Exception e) { + em.getTransaction().rollback(); + logger.error("Error while updating AlbumType: {}", e.getMessage()); + throw e; + } finally { + if (em.isOpen()) em.close(); + } + } + + public boolean deleteById(Integer id){ + logger.debug("Deleting AlbumType with id: {}", id); + EntityManager em = entityManagerFactory.createEntityManager(); + em.getTransaction().begin(); + try{ + AlbumType albumType = em.find(AlbumType.class, id); + if (albumType == null) { + em.getTransaction().rollback(); + return false; + } + em.remove(albumType); + em.getTransaction().commit(); + logger.debug("AlbumType has been deleted successfully"); + return true; + } catch (Exception e) { + em.getTransaction().rollback(); + logger.error("Error while deleting AlbumType: {}", e.getMessage()); + throw e; + } finally { + if (em.isOpen()) em.close(); + } + } + +} diff --git a/src/main/java/com/mediamanager/service/albumtype/AlbumTypeService.java b/src/main/java/com/mediamanager/service/albumtype/AlbumTypeService.java new file mode 100644 index 0000000..3caf669 --- /dev/null +++ b/src/main/java/com/mediamanager/service/albumtype/AlbumTypeService.java @@ -0,0 +1,69 @@ +package com.mediamanager.service.albumtype; + +import com.mediamanager.model.AlbumType; +import com.mediamanager.repository.AlbumTypeRepository; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; + +import java.util.List; +import java.util.Optional; + +public class AlbumTypeService { + private static final Logger logger = LogManager.getLogger(AlbumTypeService.class); + private final AlbumTypeRepository repository; + + public AlbumTypeService(AlbumTypeRepository repository) { + this.repository = repository; + } + + public AlbumType createAlbumType(String value) { + logger.debug("Creating album type:{}", value); + if (value == null || value.trim().isEmpty()) { + throw new IllegalArgumentException("AlbumType value cannot be null or empty"); + } + AlbumType albumType = new AlbumType(); + albumType.setValue(value); + return repository.save(albumType); + } + + public List getAllAlbumTypes() { + logger.info("Getting all album types"); + return repository.findAll(); + } + + public Optional getAlbumTypeById(Integer id) { + if (id == null) { + throw new IllegalArgumentException("ID cannot be null"); + } + logger.info("Getting album type by id:{}", id); + return repository.findById(id); + } + + public Optional updateAlbumType(Integer id, String value) { + if (id == null) { + throw new IllegalArgumentException("ID cannot be null"); + } + logger.info("Updating album type:{}", value); + if (value == null || value.trim().isEmpty()) { + throw new IllegalArgumentException("AlbumType value cannot be null or empty"); + } + Optional existingAlbumType = repository.findById(id); + if(existingAlbumType.isEmpty()) { + logger.warn("Album type not found with id:{}", id); + return Optional.empty(); + } + AlbumType albumType = existingAlbumType.get(); + albumType.setValue(value); + AlbumType updatedAlbumType = repository.update(albumType); + return Optional.of(updatedAlbumType); + } + + public boolean deleteAlbumType(Integer id) { + if (id == null) { + throw new IllegalArgumentException("Album type id cannot be null"); + } + logger.info("Deleting album type:{}", id); + return repository.deleteById(id); + } + +} diff --git a/src/main/java/com/mediamanager/service/delegate/DelegateActionManager.java b/src/main/java/com/mediamanager/service/delegate/DelegateActionManager.java index 5e2aa8a..a001eaa 100644 --- a/src/main/java/com/mediamanager/service/delegate/DelegateActionManager.java +++ b/src/main/java/com/mediamanager/service/delegate/DelegateActionManager.java @@ -4,6 +4,7 @@ import com.google.protobuf.ByteString; import com.mediamanager.protocol.TransportProtocol; import com.mediamanager.repository.*; import com.mediamanager.service.albumart.AlbumArtService; +import com.mediamanager.service.albumtype.AlbumTypeService; import com.mediamanager.service.bitdepth.BitDepthService; import com.mediamanager.service.bitrate.BitRateService; import com.mediamanager.service.composer.ComposerService; @@ -80,6 +81,10 @@ public class DelegateActionManager { AlbumArtService albumArtService = new AlbumArtService(albumArtRepository); serviceLocator.register(AlbumArtService.class, albumArtService); + AlbumTypeRepository albumTypeRepository = new AlbumTypeRepository(entityManagerFactory); + AlbumTypeService albumTypeService = new AlbumTypeService(albumTypeRepository); + serviceLocator.register(AlbumTypeService.class, albumTypeService); + serviceLocator.logRegisteredServices(); logger.info("Services initialized successfully"); diff --git a/src/main/java/com/mediamanager/service/delegate/handler/albumtype/CreateAlbumTypeHandler.java b/src/main/java/com/mediamanager/service/delegate/handler/albumtype/CreateAlbumTypeHandler.java new file mode 100644 index 0000000..774f559 --- /dev/null +++ b/src/main/java/com/mediamanager/service/delegate/handler/albumtype/CreateAlbumTypeHandler.java @@ -0,0 +1,49 @@ +package com.mediamanager.service.delegate.handler.albumtype; + +import com.google.protobuf.ByteString; +import com.google.protobuf.InvalidProtocolBufferException; +import com.mediamanager.mapper.AlbumTypeMapper; +import com.mediamanager.model.AlbumType; +import com.mediamanager.protocol.TransportProtocol; +import com.mediamanager.protocol.messages.AlbumTypeMessages; +import com.mediamanager.service.delegate.ActionHandler; +import com.mediamanager.service.delegate.annotation.Action; +import com.mediamanager.service.albumtype.AlbumTypeService; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; + +@Action("albumtype.create") +public class CreateAlbumTypeHandler implements ActionHandler { + private static final Logger logger = LogManager.getLogger(CreateAlbumTypeHandler.class); + private final AlbumTypeService albumTypeService; + + public CreateAlbumTypeHandler(AlbumTypeService albumTypeService) { + this.albumTypeService = albumTypeService; + } + + @Override + public TransportProtocol.Response.Builder handle(ByteString requestPayload) throws InvalidProtocolBufferException { + try{ + AlbumTypeMessages.CreateAlbumTypeRequest createRequest = + AlbumTypeMessages.CreateAlbumTypeRequest.parseFrom(requestPayload); + AlbumType albumType = albumTypeService.createAlbumType(createRequest.getValue()); + AlbumTypeMessages.AlbumType albumTypeProto = AlbumTypeMapper.toProtobuf(albumType); + AlbumTypeMessages.CreateAlbumTypeResponse createAlbumTypeResponse = AlbumTypeMessages.CreateAlbumTypeResponse.newBuilder() + .setAlbumtype(albumTypeProto) + .build(); + return TransportProtocol.Response.newBuilder() + .setPayload(createAlbumTypeResponse.toByteString()); + } catch (IllegalArgumentException e) { + logger.error("Validation error", e); + return TransportProtocol.Response.newBuilder() + .setStatusCode(400) + .setPayload(ByteString.copyFromUtf8("Validation error: " + e.getMessage())); + + } catch (Exception e) { + logger.error("Error creating album type", e); + return TransportProtocol.Response.newBuilder() + .setStatusCode(500) + .setPayload(ByteString.copyFromUtf8("Error: " + e.getMessage())); + } + } +} diff --git a/src/main/java/com/mediamanager/service/delegate/handler/albumtype/DeleteAlbumTypeHandler.java b/src/main/java/com/mediamanager/service/delegate/handler/albumtype/DeleteAlbumTypeHandler.java new file mode 100644 index 0000000..9ce400d --- /dev/null +++ b/src/main/java/com/mediamanager/service/delegate/handler/albumtype/DeleteAlbumTypeHandler.java @@ -0,0 +1,62 @@ +package com.mediamanager.service.delegate.handler.albumtype; + +import com.google.protobuf.ByteString; +import com.google.protobuf.InvalidProtocolBufferException; +import com.mediamanager.protocol.TransportProtocol; +import com.mediamanager.protocol.messages.AlbumTypeMessages; +import com.mediamanager.service.delegate.ActionHandler; +import com.mediamanager.service.delegate.annotation.Action; +import com.mediamanager.service.albumtype.AlbumTypeService; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; + +@Action("albumtype.delete") +public class DeleteAlbumTypeHandler implements ActionHandler { + private static final Logger logger = LogManager.getLogger(DeleteAlbumTypeHandler.class); + + private final AlbumTypeService albumTypeService; + + public DeleteAlbumTypeHandler(AlbumTypeService albumTypeService) { + this.albumTypeService = albumTypeService; + } + + @Override + public TransportProtocol.Response.Builder handle(ByteString requestPayload) + throws InvalidProtocolBufferException { + + try { + AlbumTypeMessages.DeleteAlbumTypeRequest deleteRequest = + AlbumTypeMessages.DeleteAlbumTypeRequest.parseFrom(requestPayload); + int id = deleteRequest.getId(); + boolean success = albumTypeService.deleteAlbumType(id); + AlbumTypeMessages.DeleteAlbumTypeResponse deleteResponse; + if (success) { + deleteResponse = AlbumTypeMessages.DeleteAlbumTypeResponse.newBuilder() + .setSuccess(true) + .setMessage("Album type deleted successfully") + .build(); + return TransportProtocol.Response.newBuilder() + .setPayload(deleteResponse.toByteString()); + } else { + deleteResponse = AlbumTypeMessages.DeleteAlbumTypeResponse.newBuilder() + .setSuccess(false) + .setMessage("Album type not found") + .build(); + + return TransportProtocol.Response.newBuilder() + .setStatusCode(404) + .setPayload(deleteResponse.toByteString()); + } + } catch (Exception e) { + logger.error("Error deleting album type", e); + AlbumTypeMessages.DeleteAlbumTypeResponse deleteResponse = + AlbumTypeMessages.DeleteAlbumTypeResponse.newBuilder() + .setSuccess(false) + .setMessage("Error: " + e.getMessage()) + .build(); + return TransportProtocol.Response.newBuilder() + .setStatusCode(500) + .setPayload(deleteResponse.toByteString()); + } + } + } diff --git a/src/main/java/com/mediamanager/service/delegate/handler/albumtype/GetAlbumTypeByIdHandler.java b/src/main/java/com/mediamanager/service/delegate/handler/albumtype/GetAlbumTypeByIdHandler.java new file mode 100644 index 0000000..85a0775 --- /dev/null +++ b/src/main/java/com/mediamanager/service/delegate/handler/albumtype/GetAlbumTypeByIdHandler.java @@ -0,0 +1,56 @@ +package com.mediamanager.service.delegate.handler.albumtype; + +import com.google.protobuf.ByteString; +import com.google.protobuf.InvalidProtocolBufferException; +import com.mediamanager.mapper.AlbumTypeMapper; +import com.mediamanager.model.AlbumType; +import com.mediamanager.protocol.TransportProtocol; +import com.mediamanager.protocol.messages.AlbumTypeMessages; +import com.mediamanager.service.delegate.ActionHandler; +import com.mediamanager.service.delegate.annotation.Action; +import com.mediamanager.service.albumtype.AlbumTypeService; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; + +import java.util.Optional; + +@Action(value = "albumtype.getById") +public class GetAlbumTypeByIdHandler implements ActionHandler { + private static final Logger logger = LogManager.getLogger(GetAlbumTypeByIdHandler.class); + private final AlbumTypeService albumTypeService; + + public GetAlbumTypeByIdHandler(AlbumTypeService albumTypeService) { + this.albumTypeService = albumTypeService; + } + + @Override + public TransportProtocol.Response.Builder handle(ByteString requestPayload) + throws InvalidProtocolBufferException{ + + try{ + AlbumTypeMessages.GetAlbumTypeByIdRequest getByIdRequest = + AlbumTypeMessages.GetAlbumTypeByIdRequest.parseFrom(requestPayload); + int id = getByIdRequest.getId(); + + Optional albumTypeOpt = albumTypeService.getAlbumTypeById(id); + + if (albumTypeOpt.isEmpty()){ + logger.warn("AlbumType not found with ID: {}", id); + return TransportProtocol.Response.newBuilder() + .setStatusCode(404) + .setPayload(ByteString.copyFromUtf8("AlbumType not found")); + } + AlbumTypeMessages.AlbumType albumTypeProto = AlbumTypeMapper.toProtobuf(albumTypeOpt.get()); + AlbumTypeMessages.GetAlbumTypeByIdResponse getByIdResponse = AlbumTypeMessages.GetAlbumTypeByIdResponse.newBuilder() + .setAlbumtype(albumTypeProto) + .build(); + return TransportProtocol.Response.newBuilder() + .setPayload(getByIdResponse.toByteString()); + } catch (Exception e) { + logger.error("Error getting album type by ID", e); + return TransportProtocol.Response.newBuilder() + .setStatusCode(500) + .setPayload(ByteString.copyFromUtf8("Error: "+ e.getMessage())); + } + } +} diff --git a/src/main/java/com/mediamanager/service/delegate/handler/albumtype/GetAlbumTypeHandler.java b/src/main/java/com/mediamanager/service/delegate/handler/albumtype/GetAlbumTypeHandler.java new file mode 100644 index 0000000..b886107 --- /dev/null +++ b/src/main/java/com/mediamanager/service/delegate/handler/albumtype/GetAlbumTypeHandler.java @@ -0,0 +1,48 @@ +package com.mediamanager.service.delegate.handler.albumtype; + +import com.google.protobuf.ByteString; +import com.google.protobuf.InvalidProtocolBufferException; +import com.mediamanager.mapper.AlbumTypeMapper; +import com.mediamanager.model.AlbumType; +import com.mediamanager.protocol.TransportProtocol; +import com.mediamanager.protocol.messages.AlbumTypeMessages; +import com.mediamanager.service.delegate.ActionHandler; +import com.mediamanager.service.delegate.annotation.Action; +import com.mediamanager.service.albumtype.AlbumTypeService; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; + +import java.util.List; + + +@Action("albumtype.getAll") +public class GetAlbumTypeHandler implements ActionHandler { + private static final Logger logger = LogManager.getLogger(GetAlbumTypeHandler.class); + + private final AlbumTypeService albumTypeService; + + public GetAlbumTypeHandler(AlbumTypeService albumTypeService){this.albumTypeService = albumTypeService;} + + @Override + public TransportProtocol.Response.Builder handle(ByteString requestPayload) throws InvalidProtocolBufferException { + try{ + List albumTypes = albumTypeService.getAllAlbumTypes(); + AlbumTypeMessages.GetAlbumTypesResponse.Builder responseBuilder = AlbumTypeMessages.GetAlbumTypesResponse.newBuilder(); + + for (AlbumType albumType : albumTypes) { + AlbumTypeMessages.AlbumType albumTypeProto = AlbumTypeMapper.toProtobuf(albumType); + responseBuilder.addAlbumtypes(albumTypeProto); + } + AlbumTypeMessages.GetAlbumTypesResponse getAlbumTypesResponse = responseBuilder.build(); + + return TransportProtocol.Response.newBuilder() + .setPayload(getAlbumTypesResponse.toByteString()); + + }catch (Exception e){ + logger.error("Error getting album types", e); + return TransportProtocol.Response.newBuilder() + .setStatusCode(500) + .setPayload(ByteString.copyFromUtf8("Error: " + e.getMessage())); + } + } +} diff --git a/src/main/java/com/mediamanager/service/delegate/handler/albumtype/UpdateAlbumTypeHandler.java b/src/main/java/com/mediamanager/service/delegate/handler/albumtype/UpdateAlbumTypeHandler.java new file mode 100644 index 0000000..50f70ed --- /dev/null +++ b/src/main/java/com/mediamanager/service/delegate/handler/albumtype/UpdateAlbumTypeHandler.java @@ -0,0 +1,65 @@ +package com.mediamanager.service.delegate.handler.albumtype; + +import com.google.protobuf.ByteString; +import com.google.protobuf.InvalidProtocolBufferException; +import com.mediamanager.mapper.AlbumTypeMapper; +import com.mediamanager.model.AlbumType; +import com.mediamanager.protocol.TransportProtocol; +import com.mediamanager.protocol.messages.AlbumTypeMessages; +import com.mediamanager.service.delegate.ActionHandler; +import com.mediamanager.service.delegate.annotation.Action; +import com.mediamanager.service.albumtype.AlbumTypeService; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; + +import java.util.Optional; + +@Action("albumtype.update") +public class UpdateAlbumTypeHandler implements ActionHandler { + private static final Logger logger = LogManager.getLogger(UpdateAlbumTypeHandler.class); + private final AlbumTypeService albumTypeService; + + public UpdateAlbumTypeHandler(AlbumTypeService albumTypeService) { + this.albumTypeService = albumTypeService; + } + + @Override + public TransportProtocol.Response.Builder handle(ByteString requestPayload) throws InvalidProtocolBufferException { + try{ + AlbumTypeMessages.UpdateAlbumTypeRequest updateRequest = + AlbumTypeMessages.UpdateAlbumTypeRequest.parseFrom(requestPayload); + + int id = updateRequest.getId(); + String newValue = updateRequest.getValue(); + + Optional albumTypeOpt = albumTypeService.updateAlbumType(id, newValue); + + if(albumTypeOpt.isEmpty()){ + logger.warn("AlbumType not found with ID: {}", id); + return TransportProtocol.Response.newBuilder() + .setStatusCode(404) + .setPayload(ByteString.copyFromUtf8("AlbumType not found")); + } + + AlbumTypeMessages.AlbumType albumTypeProto = AlbumTypeMapper.toProtobuf(albumTypeOpt.get()); + + AlbumTypeMessages.UpdateAlbumTypeResponse updateResponse = AlbumTypeMessages.UpdateAlbumTypeResponse.newBuilder() + .setAlbumtype(albumTypeProto) + .build(); + + return TransportProtocol.Response.newBuilder() + .setPayload(updateResponse.toByteString()); + + } catch (IllegalArgumentException e){ + logger.error("Validation error", e); + return TransportProtocol.Response.newBuilder() + .setStatusCode(400) + .setPayload(ByteString.copyFromUtf8("Validation error: " + e.getMessage())); + } catch (Exception e) { + logger.error("Error updating album type", e); + return TransportProtocol.Response.newBuilder() + .setStatusCode(500) + .setPayload(ByteString.copyFromUtf8("Error: " + e.getMessage())); + } + } +} diff --git a/src/main/proto/albumtype.proto b/src/main/proto/albumtype.proto new file mode 100644 index 0000000..fba52b2 --- /dev/null +++ b/src/main/proto/albumtype.proto @@ -0,0 +1,53 @@ +syntax = "proto3"; + +option java_package = "com.mediamanager.protocol.messages"; +option java_outer_classname = "AlbumTypeMessages"; + +package mediamanager.messages; + +message AlbumType { + int32 id = 1; + string value = 2; +} + +message CreateAlbumTypeRequest { + string value = 1; +} + +message CreateAlbumTypeResponse { + AlbumType albumtype = 1; +} + +message GetAlbumTypesRequest { + +} + +message GetAlbumTypesResponse { + repeated AlbumType albumtypes = 1; +} + +message GetAlbumTypeByIdRequest { + int32 id = 1; +} + +message GetAlbumTypeByIdResponse { + AlbumType albumtype = 1; +} + +message UpdateAlbumTypeRequest { + int32 id = 1; + string value = 2; // Novo nome +} + +message UpdateAlbumTypeResponse { + AlbumType albumtype = 1; +} + +message DeleteAlbumTypeRequest { + int32 id = 1; +} + +message DeleteAlbumTypeResponse { + bool success = 1; + string message = 2; +}