GHMiranda
/
MediaManager-core
mirror of https://github.com/gmbrax/MediaManager-core.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #23 from gmbrax/feature/Implement-Album-Management 

Implement Album management with full CRUD operations
This commit is contained in:
Gustavo Henrique Miranda 2025-12-08 00:16:02 -03:00 committed by GitHub
parent dccbfcf546 9e3516aacb
commit d70fae0719
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
29 changed files with 2065 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

47
src/main/java/com/mediamanager/mapper/AlbumHasArtistMapper.java Normal file
View File

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

47
src/main/java/com/mediamanager/mapper/AlbumHasGenreMapper.java Normal file
View File

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

110
src/main/java/com/mediamanager/mapper/AlbumMapper.java Normal file
View File

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

224
src/main/java/com/mediamanager/model/Album.java Normal file
View File

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

56
src/main/java/com/mediamanager/model/AlbumHasArtist.java Normal file
View File

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

56
src/main/java/com/mediamanager/model/AlbumHasGenre.java Normal file
View File

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

85
src/main/java/com/mediamanager/repository/AlbumHasArtistRepository.java Normal file
View File

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

85
src/main/java/com/mediamanager/repository/AlbumHasGenreRepository.java Normal file
View File

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

103
src/main/java/com/mediamanager/repository/AlbumRepository.java Normal file
View File

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

153
src/main/java/com/mediamanager/service/album/AlbumService.java Normal file
View File

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

77
src/main/java/com/mediamanager/service/albumhasartist/AlbumHasArtistService.java Normal file
View File

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

77
src/main/java/com/mediamanager/service/albumhasgenre/AlbumHasGenreService.java Normal file
View File

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

15
src/main/java/com/mediamanager/service/delegate/DelegateActionManager.java
View File

@ -3,7 +3,10 @@ package com.mediamanager.service.delegate;
import com.google.protobuf.ByteString; import com.google.protobuf.ByteString;
import com.mediamanager.protocol.TransportProtocol; import com.mediamanager.protocol.TransportProtocol;
import com.mediamanager.repository.*; import com.mediamanager.repository.*;
import com.mediamanager.service.album.AlbumService;
import com.mediamanager.service.albumart.AlbumArtService; import com.mediamanager.service.albumart.AlbumArtService;
import com.mediamanager.service.albumhasartist.AlbumHasArtistService;
import com.mediamanager.service.albumhasgenre.AlbumHasGenreService;
import com.mediamanager.service.albumtype.AlbumTypeService; import com.mediamanager.service.albumtype.AlbumTypeService;
import com.mediamanager.service.bitdepth.BitDepthService; import com.mediamanager.service.bitdepth.BitDepthService;
import com.mediamanager.service.bitrate.BitRateService; import com.mediamanager.service.bitrate.BitRateService;
@ -85,6 +88,18 @@ public class DelegateActionManager {
AlbumTypeService albumTypeService = new AlbumTypeService(albumTypeRepository); AlbumTypeService albumTypeService = new AlbumTypeService(albumTypeRepository);
serviceLocator.register(AlbumTypeService.class, albumTypeService); serviceLocator.register(AlbumTypeService.class, albumTypeService);
AlbumRepository albumRepository = new AlbumRepository(entityManagerFactory);
AlbumService albumService = new AlbumService(albumRepository, albumTypeRepository, albumArtRepository);
serviceLocator.register(AlbumService.class, albumService);
AlbumHasArtistRepository albumHasArtistRepository = new AlbumHasArtistRepository(entityManagerFactory);
AlbumHasArtistService albumHasArtistService = new AlbumHasArtistService(albumHasArtistRepository, albumRepository, artistRepository);
serviceLocator.register(AlbumHasArtistService.class, albumHasArtistService);
AlbumHasGenreRepository albumHasGenreRepository = new AlbumHasGenreRepository(entityManagerFactory);
AlbumHasGenreService albumHasGenreService = new AlbumHasGenreService(albumHasGenreRepository, albumRepository, genreRepository);
serviceLocator.register(AlbumHasGenreService.class, albumHasGenreService);
serviceLocator.logRegisteredServices(); serviceLocator.logRegisteredServices();
logger.info("Services initialized successfully"); logger.info("Services initialized successfully");

59
src/main/java/com/mediamanager/service/delegate/handler/album/CreateAlbumHandler.java Normal file
View File

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

62
src/main/java/com/mediamanager/service/delegate/handler/album/DeleteAlbumHandler.java Normal file
View File

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

56
src/main/java/com/mediamanager/service/delegate/handler/album/GetAlbumByIdHandler.java Normal file
View File

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

48
src/main/java/com/mediamanager/service/delegate/handler/album/GetAlbumHandler.java Normal file
View File

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

96
src/main/java/com/mediamanager/service/delegate/handler/album/UpdateAlbumHandler.java Normal file
View File

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

54
src/main/java/com/mediamanager/service/delegate/handler/albumhasartist/CreateAlbumHasArtistHandler.java Normal file
View File

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

62
src/main/java/com/mediamanager/service/delegate/handler/albumhasartist/DeleteAlbumHasArtistHandler.java Normal file
View File

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

56
src/main/java/com/mediamanager/service/delegate/handler/albumhasartist/GetAlbumHasArtistByIdHandler.java Normal file
View File

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

48
src/main/java/com/mediamanager/service/delegate/handler/albumhasartist/GetAlbumHasArtistHandler.java Normal file
View File

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

54
src/main/java/com/mediamanager/service/delegate/handler/albumhasgenre/CreateAlbumHasGenreHandler.java Normal file
View File

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

62
src/main/java/com/mediamanager/service/delegate/handler/albumhasgenre/DeleteAlbumHasGenreHandler.java Normal file
View File

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

56
src/main/java/com/mediamanager/service/delegate/handler/albumhasgenre/GetAlbumHasGenreByIdHandler.java Normal file
View File

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

48
src/main/java/com/mediamanager/service/delegate/handler/albumhasgenre/GetAlbumHasGenreHandler.java Normal file
View File

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

77
src/main/proto/album.proto Normal file
View File

@ -0,0 +1,77 @@
syntax = "proto3";
import "google/protobuf/wrappers.proto"; // ← Adicione esse import!
option java_package = "com.mediamanager.protocol.messages";
option java_outer_classname = "AlbumMessages";
package mediamanager.messages;
message Album {
int32 id = 1;
string name = 2;
int32 year = 3;
int32 number_of_discs = 4;
string code = 5;
bool is_compilation = 6;
int32 fk_albumtype_id = 7;
int32 fk_albumart_id = 8;
int64 created_at = 9;
int64 updated_at = 10;
}
message CreateAlbumRequest {
string name = 1;
int32 year = 2;
int32 number_of_discs = 3;
string code = 4;
bool is_compilation = 5;
int32 fk_albumtype_id = 6;
int32 fk_albumart_id = 7;
}
message CreateAlbumResponse {
Album album = 1;
}
message GetAlbumsRequest {
}
message GetAlbumsResponse {
repeated Album albums = 1;
}
message GetAlbumByIdRequest {
int32 id = 1;
}
message GetAlbumByIdResponse {
Album album = 1;
}
message UpdateAlbumRequest {
int32 id = 1;
string name = 2;
google.protobuf.Int32Value year = 3; // ← Mudou!
google.protobuf.Int32Value number_of_discs = 4; // ← Mudou!
string code = 5;
bool is_compilation = 6;
google.protobuf.Int32Value fk_albumtype_id = 7; // ← Mudou!
google.protobuf.Int32Value fk_albumart_id = 8; // ← Mudou!
}
message UpdateAlbumResponse {
Album album = 1;
}
message DeleteAlbumRequest {
int32 id = 1;
}
message DeleteAlbumResponse {
bool success = 1;
string message = 2;
}

46
src/main/proto/albumhasartist.proto Normal file
View File

@ -0,0 +1,46 @@
syntax = "proto3";
option java_package = "com.mediamanager.protocol.messages";
option java_outer_classname = "AlbumHasArtistMessages";
package mediamanager.messages;
message AlbumHasArtist {
int32 id = 1;
int32 fk_album_id = 2;
int32 fk_artist_id = 3;
}
message CreateAlbumHasArtistRequest {
int32 fk_album_id = 1;
int32 fk_artist_id = 2;
}
message CreateAlbumHasArtistResponse {
AlbumHasArtist albumhasartist = 1;
}
message GetAlbumHasArtistsRequest {
}
message GetAlbumHasArtistsResponse {
repeated AlbumHasArtist albumhasartist = 1;
}
message GetAlbumHasArtistByIdRequest {
int32 id = 1;
}
message GetAlbumHasArtistByIdResponse {
AlbumHasArtist albumhasartist = 1;
}
message DeleteAlbumHasArtistRequest {
int32 id = 1;
}
message DeleteAlbumHasArtistResponse {
bool success = 1;
string message = 2;
}

46
src/main/proto/albumhasgenre.proto Normal file
View File

@ -0,0 +1,46 @@
syntax = "proto3";
option java_package = "com.mediamanager.protocol.messages";
option java_outer_classname = "AlbumHasGenreMessages";
package mediamanager.messages;
message AlbumHasGenre {
int32 id = 1;
int32 fk_album_id = 2;
int32 fk_genre_id = 3;
}
message CreateAlbumHasGenreRequest {
int32 fk_album_id = 1;
int32 fk_genre_id = 2;
}
message CreateAlbumHasGenreResponse {
AlbumHasGenre albumhasgenre = 1;
}
message GetAlbumHasGenresRequest {
}
message GetAlbumHasGenresResponse {
repeated AlbumHasGenre albumhasgenre = 1;
}
message GetAlbumHasGenreByIdRequest {
int32 id = 1;
}
message GetAlbumHasGenreByIdResponse {
AlbumHasGenre albumhasgenre = 1;
}
message DeleteAlbumHasGenreRequest {
int32 id = 1;
}
message DeleteAlbumHasGenreResponse {
bool success = 1;
string message = 2;
}