Merge pull request #29 from gmbrax/feature/Implement-track-management

Merge pull request #28 from gmbrax/develop

.gitignore

@@ -52,3 +52,5 @@ src/main/resources/application.properties
 
 # Allow example configuration files to be committed
 !src/main/resources/*.properties.example
+src/scripts/*
+local-repo/

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -2,15 +2,28 @@ package com.mediamanager.service.delegate;
 
 import com.google.protobuf.ByteString;
 import com.mediamanager.protocol.TransportProtocol;
-import com.mediamanager.repository.ComposerRepository;
-import com.mediamanager.repository.GenreRepository;
+import com.mediamanager.repository.*;
+import com.mediamanager.repository.DiscRepository;
+import com.mediamanager.service.album.AlbumService;
+import com.mediamanager.service.albumart.AlbumArtService;
+import com.mediamanager.service.albumhasartist.AlbumHasArtistService;
+import com.mediamanager.service.albumhasgenre.AlbumHasGenreService;
+import com.mediamanager.service.albumtype.AlbumTypeService;
+import com.mediamanager.service.bitdepth.BitDepthService;
+import com.mediamanager.service.bitrate.BitRateService;
 import com.mediamanager.service.composer.ComposerService;
-import com.mediamanager.repository.ArtistRepository;
+import com.mediamanager.service.trackhasgenre.TrackHasGenreService;
+import com.mediamanager.service.trackhasartist.TrackHasArtistService;
+import com.mediamanager.service.trackhascomposer.TrackHasComposerService;
+
 import com.mediamanager.repository.GenreRepository;
 import com.mediamanager.service.artist.ArtistService;
+import com.mediamanager.service.track.TrackService;
 import com.mediamanager.service.delegate.annotation.Action;
 
+import com.mediamanager.service.disc.DiscService;
 import com.mediamanager.service.genre.GenreService;
+import com.mediamanager.service.samplingrate.SamplingRateService;
 import jakarta.persistence.EntityManagerFactory;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
@@ -58,14 +71,61 @@ public class DelegateActionManager {
 
         serviceLocator.register(ArtistService.class, artistService);
 
-
-
-
-
         ComposerRepository composerRepository = new ComposerRepository(entityManagerFactory);
         ComposerService composerService = new ComposerService(composerRepository);
         serviceLocator.register(ComposerService.class, composerService);
 
+        BitDepthRepository bitDepthRepository = new BitDepthRepository(entityManagerFactory);
+        BitDepthService bitDepthService = new BitDepthService(bitDepthRepository);
+        serviceLocator.register(BitDepthService.class, bitDepthService);
+
+        BitRateRepository bitRateRepository = new BitRateRepository(entityManagerFactory);
+        BitRateService bitRateService = new BitRateService(bitRateRepository);
+        serviceLocator.register(BitRateService.class, bitRateService);
+
+        SamplingRateRepository samplingRateRepository = new SamplingRateRepository(entityManagerFactory);
+        SamplingRateService  samplingRateService = new SamplingRateService(samplingRateRepository);
+        serviceLocator.register(SamplingRateService.class, samplingRateService);
+
+        AlbumArtRepository albumArtRepository = new AlbumArtRepository(entityManagerFactory);
+        AlbumArtService albumArtService = new AlbumArtService(albumArtRepository);
+        serviceLocator.register(AlbumArtService.class, albumArtService);
+
+        AlbumTypeRepository albumTypeRepository = new AlbumTypeRepository(entityManagerFactory);
+        AlbumTypeService albumTypeService = new AlbumTypeService(albumTypeRepository);
+        serviceLocator.register(AlbumTypeService.class, albumTypeService);
+
+        AlbumRepository albumRepository = new AlbumRepository(entityManagerFactory);
+        AlbumService albumService = new AlbumService(albumRepository, albumTypeRepository, albumArtRepository);
+        serviceLocator.register(AlbumService.class, albumService);
+
+        AlbumHasArtistRepository albumHasArtistRepository = new AlbumHasArtistRepository(entityManagerFactory);
+        AlbumHasArtistService albumHasArtistService = new AlbumHasArtistService(albumHasArtistRepository, albumRepository, artistRepository);
+        serviceLocator.register(AlbumHasArtistService.class, albumHasArtistService);
+
+        AlbumHasGenreRepository albumHasGenreRepository = new AlbumHasGenreRepository(entityManagerFactory);
+        AlbumHasGenreService albumHasGenreService = new AlbumHasGenreService(albumHasGenreRepository, albumRepository, genreRepository);
+        serviceLocator.register(AlbumHasGenreService.class, albumHasGenreService);
+
+        DiscRepository discRepository = new DiscRepository(entityManagerFactory);
+        DiscService discService = new DiscService(discRepository, albumRepository);
+        serviceLocator.register(DiscService.class, discService);
+
+        TrackRepository trackRepository = new TrackRepository(entityManagerFactory);
+        TrackService trackService = new TrackService(trackRepository, discRepository, composerRepository, bitDepthRepository, bitRateRepository, samplingRateRepository);
+        serviceLocator.register(TrackService.class, trackService);
+
+        TrackHasGenreRepository trackHasGenreRepository = new TrackHasGenreRepository(entityManagerFactory);
+        TrackHasGenreService trackHasGenreService = new TrackHasGenreService(trackHasGenreRepository, trackRepository, genreRepository);
+        serviceLocator.register(TrackHasGenreService.class, trackHasGenreService);
+
+        TrackHasArtistRepository trackHasArtistRepository = new TrackHasArtistRepository(entityManagerFactory);
+        TrackHasArtistService trackHasArtistService = new TrackHasArtistService(trackHasArtistRepository, trackRepository, artistRepository);
+        serviceLocator.register(TrackHasArtistService.class, trackHasArtistService);
+
+        TrackHasComposerRepository trackHasComposerRepository = new TrackHasComposerRepository(entityManagerFactory);
+        TrackHasComposerService trackHasComposerService = new TrackHasComposerService(trackHasComposerRepository, trackRepository, composerRepository);
+        serviceLocator.register(TrackHasComposerService.class, trackHasComposerService);
 
         serviceLocator.logRegisteredServices();
 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,48 @@
+package com.mediamanager.service.delegate.handler.bitdepth;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.mapper.BitDepthMapper;
+import com.mediamanager.model.BitDepth;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.BitDepthMessages;
+import com.mediamanager.service.bitdepth.BitDepthService;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.List;
+
+
+@Action("bitdepth.getAll")
+public class GetBitDepthHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(GetBitDepthHandler.class);
+
+    private final BitDepthService bitDepthService;
+
+    public GetBitDepthHandler(BitDepthService bitDepthService){this.bitDepthService = bitDepthService;}
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload) throws InvalidProtocolBufferException {
+        try{
+            List<BitDepth> bitDepths = bitDepthService.getAllBitDepths();
+            BitDepthMessages.GetBitDepthsResponse.Builder responseBuilder = BitDepthMessages.GetBitDepthsResponse.newBuilder();
+
+            for (BitDepth bitDepth : bitDepths) {
+                BitDepthMessages.BitDepth bitDepthProto = BitDepthMapper.toProtobuf(bitDepth);
+                responseBuilder.addBitdepths(bitDepthProto);
+            }
+            BitDepthMessages.GetBitDepthsResponse getBitDepthsResponse = responseBuilder.build();
+
+            return TransportProtocol.Response.newBuilder()
+                    .setPayload(getBitDepthsResponse.toByteString());
+
+        }catch (Exception e){
+            logger.error("Error getting bit-depths", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(ByteString.copyFromUtf8("Error: " + e.getMessage()));
+        }
+    }
+}

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

@@ -0,0 +1,65 @@
+package com.mediamanager.service.delegate.handler.bitdepth;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.mapper.BitDepthMapper;
+import com.mediamanager.model.BitDepth;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.BitDepthMessages;
+import com.mediamanager.service.bitdepth.BitDepthService;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.Optional;
+
+@Action("bitdepth.update")
+public class UpdateBitDepthHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(UpdateBitDepthHandler.class);
+    private final BitDepthService bitDepthService;
+
+    public UpdateBitDepthHandler(BitDepthService bitDepthService) {
+        this.bitDepthService = bitDepthService;
+    }
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload) throws InvalidProtocolBufferException {
+        try{
+            BitDepthMessages.UpdateBitDepthRequest updateRequest =
+                    BitDepthMessages.UpdateBitDepthRequest.parseFrom(requestPayload);
+
+            int id = updateRequest.getId();
+            String newValue = updateRequest.getValue();
+
+            Optional<BitDepth> bitDepthOpt = bitDepthService.updateBitDepth(id, newValue);
+
+            if(bitDepthOpt.isEmpty()){
+                logger.warn("BitDepth not found with ID: {}", id);
+                return TransportProtocol.Response.newBuilder()
+                        .setStatusCode(404)
+                        .setPayload(ByteString.copyFromUtf8("BitDepth not found"));
+            }
+
+            BitDepthMessages.BitDepth bitDepthProto = BitDepthMapper.toProtobuf(bitDepthOpt.get());
+
+            BitDepthMessages.UpdateBitDepthResponse updateResponse = BitDepthMessages.UpdateBitDepthResponse.newBuilder()
+                    .setBitdepth(bitDepthProto)
+                    .build();
+
+            return TransportProtocol.Response.newBuilder()
+                    .setPayload(updateResponse.toByteString());
+
+        } catch (IllegalArgumentException e){
+            logger.error("Validation error", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(400)
+                    .setPayload(ByteString.copyFromUtf8("Validation error: " + e.getMessage()));
+        } catch (Exception e) {
+            logger.error("Error updating bit-depth", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(ByteString.copyFromUtf8("Error: " + e.getMessage()));
+        }
+    }
+}

src/main/java/com/mediamanager/service/delegate/handler/bitrate/CreateBitRateHandler.java

@@ -0,0 +1,50 @@
+package com.mediamanager.service.delegate.handler.bitrate;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.mapper.BitRateMapper;
+import com.mediamanager.model.BitRate;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.BitRateMessages;
+import com.mediamanager.service.bitrate.BitRateService;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+@Action("bitrate.create")
+public class CreateBitRateHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(CreateBitRateHandler.class);
+    private final BitRateService bitRateService;
+
+    public CreateBitRateHandler(BitRateService bitRateService) {
+        this.bitRateService = bitRateService;
+    }
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload) throws InvalidProtocolBufferException {
+        try{
+            BitRateMessages.CreateBitRateRequest createRequest =
+                    BitRateMessages.CreateBitRateRequest.parseFrom(requestPayload);
+            BitRate bitRate = bitRateService.createBitRate(createRequest.getValue());
+            BitRateMessages.BitRate BitRateProto = BitRateMapper.toProtobuf(bitRate);
+            BitRateMessages.CreateBitRateResponse createBitRateResponse = BitRateMessages.CreateBitRateResponse.newBuilder()
+                    .setBitrate(BitRateProto)
+                    .build();
+            return TransportProtocol.Response.newBuilder()
+                    .setPayload(createBitRateResponse.toByteString());
+        } catch (IllegalArgumentException e) {
+            logger.error("Validation error", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(400)
+                    .setPayload(ByteString.copyFromUtf8("Validation error: " + e.getMessage()));
+
+        } catch (Exception e) {
+            logger.error("Error creating bit-rate", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(ByteString.copyFromUtf8("Error: " + e.getMessage()));
+        }
+    }
+}
+

src/main/java/com/mediamanager/service/delegate/handler/bitrate/DeleteBitRateHandler.java

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

src/main/java/com/mediamanager/service/delegate/handler/bitrate/GetBitRateByIdHandler.java

@@ -0,0 +1,56 @@
+package com.mediamanager.service.delegate.handler.bitrate;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.mapper.BitRateMapper;
+import com.mediamanager.model.BitRate;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.BitRateMessages;
+import com.mediamanager.service.bitrate.BitRateService;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.Optional;
+
+@Action(value = "bitrate.getById")
+public class GetBitRateByIdHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(GetBitRateByIdHandler.class);
+    private final BitRateService bitRateService;
+
+    public GetBitRateByIdHandler(BitRateService bitRateService) {
+        this.bitRateService = bitRateService;
+    }
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload)
+        throws InvalidProtocolBufferException{
+
+        try{
+            BitRateMessages.GetBitRateByIdRequest getByIdRequest =
+                    BitRateMessages.GetBitRateByIdRequest.parseFrom(requestPayload);
+            int id = getByIdRequest.getId();
+
+            Optional<BitRate> bitRateOpt = bitRateService.getBitRateById(id);
+
+            if (bitRateOpt.isEmpty()){
+                logger.warn("BitRate not found with ID: {}", id);
+                return TransportProtocol.Response.newBuilder()
+                        .setStatusCode(404)
+                        .setPayload(ByteString.copyFromUtf8("BitRate not found"));
+            }
+            BitRateMessages.BitRate bitRateProto = BitRateMapper.toProtobuf(bitRateOpt.get());
+            BitRateMessages.GetBitRateByIdResponse getByIdResponse = BitRateMessages.GetBitRateByIdResponse.newBuilder()
+                    .setBitrate(bitRateProto)
+                    .build();
+            return TransportProtocol.Response.newBuilder()
+                    .setPayload(getByIdResponse.toByteString());
+        } catch (Exception e) {
+            logger.error("Error getting bit-rate by ID", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(ByteString.copyFromUtf8("Error: "+ e.getMessage()));
+        }
+    }
+}

src/main/java/com/mediamanager/service/delegate/handler/bitrate/GetBitRateHandler.java

@@ -0,0 +1,48 @@
+package com.mediamanager.service.delegate.handler.bitrate;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.mapper.BitRateMapper;
+import com.mediamanager.model.BitRate;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.BitRateMessages;
+import com.mediamanager.service.bitrate.BitRateService;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.List;
+
+
+@Action("bitrate.getAll")
+public class GetBitRateHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(GetBitRateHandler.class);
+
+    private final BitRateService bitRateService;
+
+    public GetBitRateHandler(BitRateService bitRateService){this.bitRateService = bitRateService;}
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload) throws InvalidProtocolBufferException {
+        try{
+            List<BitRate> bitRates = bitRateService.getAllBitRates();
+            BitRateMessages.GetBitRatesResponse.Builder responseBuilder = BitRateMessages.GetBitRatesResponse.newBuilder();
+
+            for (BitRate bitRate : bitRates) {
+                BitRateMessages.BitRate bitRateProto = BitRateMapper.toProtobuf(bitRate);
+                responseBuilder.addBitrates(bitRateProto);
+            }
+            BitRateMessages.GetBitRatesResponse getBitRatesResponse = responseBuilder.build();
+
+            return TransportProtocol.Response.newBuilder()
+                    .setPayload(getBitRatesResponse.toByteString());
+
+        }catch (Exception e){
+            logger.error("Error getting bit-rates", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(ByteString.copyFromUtf8("Error: " + e.getMessage()));
+        }
+    }
+}

src/main/java/com/mediamanager/service/delegate/handler/bitrate/UpdateBitRateHandler.java

@@ -0,0 +1,65 @@
+package com.mediamanager.service.delegate.handler.bitrate;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.mapper.BitRateMapper;
+import com.mediamanager.model.BitRate;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.BitRateMessages;
+import com.mediamanager.service.bitrate.BitRateService;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.Optional;
+
+@Action("bitrate.update")
+public class UpdateBitRateHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(UpdateBitRateHandler.class);
+    private final BitRateService bitRateService;
+
+    public UpdateBitRateHandler(BitRateService bitRateService) {
+        this.bitRateService = bitRateService;
+    }
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload) throws InvalidProtocolBufferException {
+        try{
+            BitRateMessages.UpdateBitRateRequest updateRequest =
+                    BitRateMessages.UpdateBitRateRequest.parseFrom(requestPayload);
+
+            int id = updateRequest.getId();
+            String newValue = updateRequest.getValue();
+
+            Optional<BitRate> bitRateOpt = bitRateService.updateBitRate(id, newValue);
+
+            if(bitRateOpt.isEmpty()){
+                logger.warn("BitRate not found with ID: {}", id);
+                return TransportProtocol.Response.newBuilder()
+                        .setStatusCode(404)
+                        .setPayload(ByteString.copyFromUtf8("BitRate not found"));
+            }
+
+            BitRateMessages.BitRate bitRateProto = BitRateMapper.toProtobuf(bitRateOpt.get());
+
+            BitRateMessages.UpdateBitRateResponse updateResponse = BitRateMessages.UpdateBitRateResponse.newBuilder()
+                    .setBitrate(bitRateProto)
+                    .build();
+
+            return TransportProtocol.Response.newBuilder()
+                    .setPayload(updateResponse.toByteString());
+
+        } catch (IllegalArgumentException e){
+            logger.error("Validation error", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(400)
+                    .setPayload(ByteString.copyFromUtf8("Validation error: " + e.getMessage()));
+        } catch (Exception e) {
+            logger.error("Error updating bit-rate", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(ByteString.copyFromUtf8("Error: " + e.getMessage()));
+        }
+    }
+}

src/main/java/com/mediamanager/service/delegate/handler/disc/CreateDiscHandler.java

@@ -0,0 +1,61 @@
+package com.mediamanager.service.delegate.handler.disc;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.mapper.DiscMapper;
+import com.mediamanager.model.Disc;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.DiscMessages;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import com.mediamanager.service.disc.DiscService;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+@Action("disc.create")
+public class CreateDiscHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(CreateDiscHandler.class);
+    private final DiscService discService;
+
+    public CreateDiscHandler(DiscService discService) {
+        this.discService = discService;
+    }
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload) throws InvalidProtocolBufferException {
+        try {
+            DiscMessages.CreateDiscRequest createRequest =
+                    DiscMessages.CreateDiscRequest.parseFrom(requestPayload);
+
+            Disc disc = discService.createDisc(
+                    createRequest.getDiscNumber(),
+                    createRequest.getFkAlbumId() > 0 ? createRequest.getFkAlbumId() : null
+            );
+
+            DiscMessages.Disc discProto = DiscMapper.toProtobuf(disc);
+            DiscMessages.CreateDiscResponse createDiscResponse = DiscMessages.CreateDiscResponse.newBuilder()
+                    .setDisc(discProto)
+                    .build();
+            return TransportProtocol.Response.newBuilder()
+                    .setPayload(createDiscResponse.toByteString());
+        } catch (IllegalArgumentException e) {
+            logger.error("Validation error", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(400)
+                    .setPayload(ByteString.copyFromUtf8("Invalid request"));
+
+        } catch (InvalidProtocolBufferException e) {
+            logger.error("Invalid CreateDiscRequest payload", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(400)
+                    .setPayload(ByteString.copyFromUtf8("Invalid request payload"));
+
+        } catch (Exception e) {
+            logger.error("Error creating disc", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(ByteString.copyFromUtf8("Internal server error"));
+        }
+    }
+    }
+

src/main/java/com/mediamanager/service/delegate/handler/disc/DeleteDiscHandler.java

@@ -0,0 +1,59 @@
+package com.mediamanager.service.delegate.handler.disc;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.DiscMessages;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import com.mediamanager.service.disc.DiscService;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+@Action("disc.delete")
+public class DeleteDiscHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(DeleteDiscHandler.class);
+
+    private final DiscService discService;
+
+    public DeleteDiscHandler(DiscService discService) {
+        this.discService = discService;
+    }
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload)
+            throws InvalidProtocolBufferException {
+
+        try {
+            DiscMessages.DeleteDiscRequest deleteRequest =
+                    DiscMessages.DeleteDiscRequest.parseFrom(requestPayload);
+            int id = deleteRequest.getId();
+            boolean success = discService.deleteDisc(id);
+            DiscMessages.DeleteDiscResponse deleteResponse;
+            if (success) {
+                deleteResponse = DiscMessages.DeleteDiscResponse.newBuilder()
+                        .setMessage("Disc deleted successfully")
+                        .build();
+                return TransportProtocol.Response.newBuilder()
+                        .setPayload(deleteResponse.toByteString());
+            } else {
+                deleteResponse = DiscMessages.DeleteDiscResponse.newBuilder()
+                        .setMessage("Disc not found")
+                        .build();
+
+                return TransportProtocol.Response.newBuilder()
+                        .setStatusCode(404)
+                        .setPayload(deleteResponse.toByteString());
+            }
+        } catch (Exception e) {
+            logger.error("Error deleting disc", e);
+            DiscMessages.DeleteDiscResponse deleteResponse =
+                    DiscMessages.DeleteDiscResponse.newBuilder()
+                            .setMessage("Error: " + e.getMessage())
+                            .build();
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(deleteResponse.toByteString());
+        }
+    }
+}

src/main/java/com/mediamanager/service/delegate/handler/disc/GetDiscByIdHandler.java

@@ -0,0 +1,56 @@
+package com.mediamanager.service.delegate.handler.disc;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.mapper.DiscMapper;
+import com.mediamanager.model.Disc;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.DiscMessages;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import com.mediamanager.service.disc.DiscService;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.Optional;
+
+@Action(value = "disc.getById")
+public class GetDiscByIdHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(GetDiscByIdHandler.class);
+    private final DiscService discService;
+
+    public GetDiscByIdHandler(DiscService discService) {
+        this.discService = discService;
+    }
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload)
+        throws InvalidProtocolBufferException{
+
+        try{
+            DiscMessages.GetDiscByIdRequest getByIdRequest =
+                    DiscMessages.GetDiscByIdRequest.parseFrom(requestPayload);
+            int id = getByIdRequest.getId();
+
+            Optional<Disc> discOpt = discService.getDiscById(id);
+
+            if (discOpt.isEmpty()){
+                logger.warn("Disc not found with ID: {}", id);
+                return TransportProtocol.Response.newBuilder()
+                        .setStatusCode(404)
+                        .setPayload(ByteString.copyFromUtf8("Disc not found"));
+            }
+            DiscMessages.Disc discProto = DiscMapper.toProtobuf(discOpt.get());
+            DiscMessages.GetDiscByIdResponse getByIdResponse = DiscMessages.GetDiscByIdResponse.newBuilder()
+                    .setDisc(discProto)
+                    .build();
+            return TransportProtocol.Response.newBuilder()
+                    .setPayload(getByIdResponse.toByteString());
+        } catch (Exception e) {
+            logger.error("Error getting disc by ID", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(ByteString.copyFromUtf8("Error: "+ e.getMessage()));
+        }
+    }
+}

src/main/java/com/mediamanager/service/delegate/handler/disc/GetDiscHandler.java

@@ -0,0 +1,47 @@
+package com.mediamanager.service.delegate.handler.disc;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.mapper.DiscMapper;
+import com.mediamanager.model.Disc;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.DiscMessages;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import com.mediamanager.service.disc.DiscService;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.List;
+
+@Action("disc.getAll")
+public class GetDiscHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(GetDiscHandler.class);
+
+    private final DiscService discService;
+
+    public GetDiscHandler(DiscService discService){this.discService = discService;}
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload) throws InvalidProtocolBufferException {
+        try{
+            List<Disc> discs = discService.getAllDiscs();
+            DiscMessages.GetDiscsResponse.Builder responseBuilder = DiscMessages.GetDiscsResponse.newBuilder();
+
+            for (Disc disc : discs) {
+                DiscMessages.Disc discProto = DiscMapper.toProtobuf(disc);
+                responseBuilder.addDiscs(discProto);
+            }
+            DiscMessages.GetDiscsResponse getDiscsResponse = responseBuilder.build();
+
+            return TransportProtocol.Response.newBuilder()
+                    .setPayload(getDiscsResponse.toByteString());
+
+        }catch (Exception e){
+            logger.error("Error getting discs", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(ByteString.copyFromUtf8("Error: " + e.getMessage()));
+        }
+    }
+}

src/main/java/com/mediamanager/service/delegate/handler/disc/UpdateDiscHandler.java

@@ -0,0 +1,72 @@
+package com.mediamanager.service.delegate.handler.disc;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.mapper.DiscMapper;
+import com.mediamanager.model.Disc;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.DiscMessages;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import com.mediamanager.service.disc.DiscService;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.Optional;
+
+@Action("disc.update")
+public class UpdateDiscHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(UpdateDiscHandler.class);
+    private final DiscService discService;
+
+    public UpdateDiscHandler(DiscService discService) {
+        this.discService = discService;
+    }
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload)
+            throws InvalidProtocolBufferException {
+        try {
+            DiscMessages.UpdateDiscRequest updateRequest =
+                    DiscMessages.UpdateDiscRequest.parseFrom(requestPayload);
+
+            int id = updateRequest.getId();
+            Integer discNumber = updateRequest.getDiscNumber();
+            Integer albumId = updateRequest.getFkAlbumId() > 0 ? updateRequest.getFkAlbumId() : null;
+
+            Optional<Disc> discOpt = discService.updateDisc(
+                    id,
+                    discNumber,
+                    albumId
+            );
+
+            if (discOpt.isEmpty()) {
+                logger.warn("Disc not found with ID: {}", id);
+                return TransportProtocol.Response.newBuilder()
+                        .setStatusCode(404)
+                        .setPayload(ByteString.copyFromUtf8("Disc not found"));
+            }
+
+            DiscMessages.Disc discProto = DiscMapper.toProtobuf(discOpt.get());
+
+            DiscMessages.UpdateDiscResponse updateResponse =
+                    DiscMessages.UpdateDiscResponse.newBuilder()
+                            .setDisc(discProto)
+                            .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 disc", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(ByteString.copyFromUtf8("Error: " + e.getMessage()));
+        }
+    }
+}

src/main/java/com/mediamanager/service/delegate/handler/samplingrate/CreateSamplingRateHandler.java

@@ -0,0 +1,50 @@
+package com.mediamanager.service.delegate.handler.samplingrate;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.mapper.SamplingRateMapper;
+import com.mediamanager.model.SamplingRate;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.SamplingRateMessages;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import com.mediamanager.service.samplingrate.SamplingRateService;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+@Action("samplingrate.create")
+public class CreateSamplingRateHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(CreateSamplingRateHandler.class);
+    private final SamplingRateService samplingRateService;
+
+    public CreateSamplingRateHandler(SamplingRateService samplingRateService) {
+        this.samplingRateService = samplingRateService;
+    }
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload) throws InvalidProtocolBufferException {
+        try{
+            SamplingRateMessages.CreateSamplingRateRequest createRequest =
+                    SamplingRateMessages.CreateSamplingRateRequest.parseFrom(requestPayload);
+            SamplingRate samplingRate = samplingRateService.createSamplingRate(createRequest.getValue());
+            SamplingRateMessages.SamplingRate samplingRateProto = SamplingRateMapper.toProtobuf(samplingRate);
+            SamplingRateMessages.CreateSamplingRateResponse createSamplingRateResponse = SamplingRateMessages.CreateSamplingRateResponse.newBuilder()
+                    .setSamplingrate(samplingRateProto)
+                    .build();
+            return TransportProtocol.Response.newBuilder()
+                    .setPayload(createSamplingRateResponse.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 sampling rate", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(ByteString.copyFromUtf8("Error: " + e.getMessage()));
+        }
+    }
+}
+

src/main/java/com/mediamanager/service/delegate/handler/samplingrate/DeleteSamplingRateHandler.java

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

src/main/java/com/mediamanager/service/delegate/handler/samplingrate/GetSamplingRateByIdHandler.java

@@ -0,0 +1,56 @@
+package com.mediamanager.service.delegate.handler.samplingrate;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.mapper.SamplingRateMapper;
+import com.mediamanager.model.SamplingRate;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.SamplingRateMessages;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import com.mediamanager.service.samplingrate.SamplingRateService;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.Optional;
+
+@Action(value = "samplingrate.getById")
+public class GetSamplingRateByIdHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(GetSamplingRateByIdHandler.class);
+    private final SamplingRateService samplingRateService;
+
+    public GetSamplingRateByIdHandler(SamplingRateService samplingRateService) {
+        this.samplingRateService = samplingRateService;
+    }
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload)
+        throws InvalidProtocolBufferException{
+
+        try{
+            SamplingRateMessages.GetSamplingRateByIdRequest getByIdRequest =
+                    SamplingRateMessages.GetSamplingRateByIdRequest.parseFrom(requestPayload);
+            int id = getByIdRequest.getId();
+
+            Optional<SamplingRate> samplingRateOpt = samplingRateService.getSamplingRateById(id);
+
+            if (samplingRateOpt.isEmpty()){
+                logger.warn("SamplingRate not found with ID: {}", id);
+                return TransportProtocol.Response.newBuilder()
+                        .setStatusCode(404)
+                        .setPayload(ByteString.copyFromUtf8("SamplingRate not found"));
+            }
+            SamplingRateMessages.SamplingRate samplingRateProto = SamplingRateMapper.toProtobuf(samplingRateOpt.get());
+            SamplingRateMessages.GetSamplingRateByIdResponse getByIdResponse = SamplingRateMessages.GetSamplingRateByIdResponse.newBuilder()
+                    .setSamplingrate(samplingRateProto)
+                    .build();
+            return TransportProtocol.Response.newBuilder()
+                    .setPayload(getByIdResponse.toByteString());
+        } catch (Exception e) {
+            logger.error("Error getting sampling rate by ID", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(ByteString.copyFromUtf8("Error: "+ e.getMessage()));
+        }
+    }
+}

src/main/java/com/mediamanager/service/delegate/handler/samplingrate/GetSamplingRateHandler.java

@@ -0,0 +1,48 @@
+package com.mediamanager.service.delegate.handler.samplingrate;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.mapper.SamplingRateMapper;
+import com.mediamanager.model.SamplingRate;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.SamplingRateMessages;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import com.mediamanager.service.samplingrate.SamplingRateService;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.List;
+
+
+@Action("samplingrate.getAll")
+public class GetSamplingRateHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(GetSamplingRateHandler.class);
+
+    private final SamplingRateService samplingRateService;
+
+    public GetSamplingRateHandler(SamplingRateService samplingRateService){this.samplingRateService = samplingRateService;}
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload) throws InvalidProtocolBufferException {
+        try{
+            List<SamplingRate> samplingRates = samplingRateService.getAllSamplingRates();
+            SamplingRateMessages.GetSamplingRatesResponse.Builder responseBuilder = SamplingRateMessages.GetSamplingRatesResponse.newBuilder();
+
+            for (SamplingRate samplingRate : samplingRates) {
+                SamplingRateMessages.SamplingRate samplingRateProto = SamplingRateMapper.toProtobuf(samplingRate);
+                responseBuilder.addSamplingrates(samplingRateProto);
+            }
+            SamplingRateMessages.GetSamplingRatesResponse getSamplingRatesResponse = responseBuilder.build();
+
+            return TransportProtocol.Response.newBuilder()
+                    .setPayload(getSamplingRatesResponse.toByteString());
+
+        }catch (Exception e){
+            logger.error("Error getting sampling rates", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(ByteString.copyFromUtf8("Error: " + e.getMessage()));
+        }
+    }
+}

src/main/java/com/mediamanager/service/delegate/handler/samplingrate/UpdateSamplingRateHandler.java

@@ -0,0 +1,65 @@
+package com.mediamanager.service.delegate.handler.samplingrate;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.mapper.SamplingRateMapper;
+import com.mediamanager.model.SamplingRate;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.SamplingRateMessages;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import com.mediamanager.service.samplingrate.SamplingRateService;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.Optional;
+
+@Action("samplingrate.update")
+public class UpdateSamplingRateHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(UpdateSamplingRateHandler.class);
+    private final SamplingRateService samplingRateService;
+
+    public UpdateSamplingRateHandler(SamplingRateService samplingRateService) {
+        this.samplingRateService = samplingRateService;
+    }
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload) throws InvalidProtocolBufferException {
+        try{
+            SamplingRateMessages.UpdateSamplingRateRequest updateRequest =
+                    SamplingRateMessages.UpdateSamplingRateRequest.parseFrom(requestPayload);
+
+            int id = updateRequest.getId();
+            String newValue = updateRequest.getValue();
+
+            Optional<SamplingRate> samplingRateOpt = samplingRateService.updateSamplingRate(id, newValue);
+
+            if(samplingRateOpt.isEmpty()){
+                logger.warn("SamplingRate not found with ID: {}", id);
+                return TransportProtocol.Response.newBuilder()
+                        .setStatusCode(404)
+                        .setPayload(ByteString.copyFromUtf8("SamplingRate not found"));
+            }
+
+            SamplingRateMessages.SamplingRate samplingRateProto = SamplingRateMapper.toProtobuf(samplingRateOpt.get());
+
+            SamplingRateMessages.UpdateSamplingRateResponse updateResponse = SamplingRateMessages.UpdateSamplingRateResponse.newBuilder()
+                    .setSamplingrate(samplingRateProto)
+                    .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 sampling rate", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(ByteString.copyFromUtf8("Error: " + e.getMessage()));
+        }
+    }
+}

src/main/java/com/mediamanager/service/delegate/handler/track/CreateTrackHandler.java

@@ -0,0 +1,61 @@
+package com.mediamanager.service.delegate.handler.track;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.mapper.TrackMapper;
+import com.mediamanager.model.Track;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.TrackMessages;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import com.mediamanager.service.track.TrackService;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+@Action("track.create")
+public class CreateTrackHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(CreateTrackHandler.class);
+    private final TrackService trackService;
+
+    public CreateTrackHandler(TrackService trackService) {
+        this.trackService = trackService;
+    }
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload) throws InvalidProtocolBufferException {
+        try{
+            TrackMessages.CreateTrackRequest createRequest =
+                    TrackMessages.CreateTrackRequest.parseFrom(requestPayload);
+
+            Track track = trackService.createTrack(
+                    createRequest.getTrackNumber(),
+                    createRequest.getTitle(),
+                    createRequest.hasDuration() ? createRequest.getDuration().getValue() : null,
+                    createRequest.getFilepath(),
+                    createRequest.getFkDiscId() > 0 ? createRequest.getFkDiscId() : null,
+                    createRequest.hasFkComposerId() ? createRequest.getFkComposerId().getValue() : null,
+                    createRequest.hasFkBitdepthId() ? createRequest.getFkBitdepthId().getValue() : null,
+                    createRequest.hasFkBitrateId() ? createRequest.getFkBitrateId().getValue() : null,
+                    createRequest.hasFkSamplingrateId() ? createRequest.getFkSamplingrateId().getValue() : null
+            );
+
+            TrackMessages.Track trackProto = TrackMapper.toProtobuf(track);
+            TrackMessages.CreateTrackResponse createTrackResponse = TrackMessages.CreateTrackResponse.newBuilder()
+                    .setTrack(trackProto)
+                    .build();
+            return TransportProtocol.Response.newBuilder()
+                    .setPayload(createTrackResponse.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 track", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(ByteString.copyFromUtf8("Error: " + e.getMessage()));
+        }
+    }
+}

src/main/java/com/mediamanager/service/delegate/handler/track/DeleteTrackHandler.java

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

src/main/java/com/mediamanager/service/delegate/handler/track/GetTrackByIdHandler.java

@@ -0,0 +1,56 @@
+package com.mediamanager.service.delegate.handler.track;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.mapper.TrackMapper;
+import com.mediamanager.model.Track;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.TrackMessages;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import com.mediamanager.service.track.TrackService;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.Optional;
+
+@Action(value = "track.getById")
+public class GetTrackByIdHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(GetTrackByIdHandler.class);
+    private final TrackService trackService;
+
+    public GetTrackByIdHandler(TrackService trackService) {
+        this.trackService = trackService;
+    }
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload)
+        throws InvalidProtocolBufferException{
+
+        try{
+            TrackMessages.GetTrackByIdRequest getByIdRequest =
+                    TrackMessages.GetTrackByIdRequest.parseFrom(requestPayload);
+            int id = getByIdRequest.getId();
+
+            Optional<Track> trackOpt = trackService.getTrackById(id);
+
+            if (trackOpt.isEmpty()){
+                logger.warn("Track not found with ID: {}", id);
+                return TransportProtocol.Response.newBuilder()
+                        .setStatusCode(404)
+                        .setPayload(ByteString.copyFromUtf8("Track not found"));
+            }
+            TrackMessages.Track trackProto = TrackMapper.toProtobuf(trackOpt.get());
+            TrackMessages.GetTrackByIdResponse getByIdResponse = TrackMessages.GetTrackByIdResponse.newBuilder()
+                    .setTrack(trackProto)
+                    .build();
+            return TransportProtocol.Response.newBuilder()
+                    .setPayload(getByIdResponse.toByteString());
+        } catch (Exception e) {
+            logger.error("Error getting track by ID", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(ByteString.copyFromUtf8("Error: "+ e.getMessage()));
+        }
+    }
+}

src/main/java/com/mediamanager/service/delegate/handler/track/GetTrackHandler.java

@@ -0,0 +1,47 @@
+package com.mediamanager.service.delegate.handler.track;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.mapper.TrackMapper;
+import com.mediamanager.model.Track;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.TrackMessages;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import com.mediamanager.service.track.TrackService;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.List;
+
+@Action("track.getAll")
+public class GetTrackHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(GetTrackHandler.class);
+
+    private final TrackService trackService;
+
+    public GetTrackHandler(TrackService trackService){this.trackService = trackService;}
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload) throws InvalidProtocolBufferException {
+        try{
+            List<Track> tracks = trackService.getAllTracks();
+            TrackMessages.GetTracksResponse.Builder responseBuilder = TrackMessages.GetTracksResponse.newBuilder();
+
+            for (Track track : tracks) {
+                TrackMessages.Track trackProto = TrackMapper.toProtobuf(track);
+                responseBuilder.addTracks(trackProto);
+            }
+            TrackMessages.GetTracksResponse getTracksResponse = responseBuilder.build();
+
+            return TransportProtocol.Response.newBuilder()
+                    .setPayload(getTracksResponse.toByteString());
+
+        }catch (Exception e){
+            logger.error("Error getting tracks", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(ByteString.copyFromUtf8("Error: " + e.getMessage()));
+        }
+    }
+}

src/main/java/com/mediamanager/service/delegate/handler/track/UpdateTrackHandler.java

@@ -0,0 +1,86 @@
+package com.mediamanager.service.delegate.handler.track;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.mapper.TrackMapper;
+import com.mediamanager.model.Track;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.TrackMessages;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import com.mediamanager.service.track.TrackService;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.Optional;
+
+@Action("track.update")
+public class UpdateTrackHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(UpdateTrackHandler.class);
+    private final TrackService trackService;
+
+    public UpdateTrackHandler(TrackService trackService) {
+        this.trackService = trackService;
+    }
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload)
+            throws InvalidProtocolBufferException {
+        try {
+            TrackMessages.UpdateTrackRequest updateRequest =
+                    TrackMessages.UpdateTrackRequest.parseFrom(requestPayload);
+
+            int id = updateRequest.getId();
+            Integer trackNumber = updateRequest.hasTrackNumber() ? updateRequest.getTrackNumber().getValue() : null;
+            String title = updateRequest.getTitle();
+            Integer duration = updateRequest.hasDuration() ? updateRequest.getDuration().getValue() : null;
+            String filepath = updateRequest.getFilepath();
+            Integer discId = updateRequest.hasFkDiscId() ? updateRequest.getFkDiscId().getValue() : null;
+            Integer composerId = updateRequest.hasFkComposerId() ? updateRequest.getFkComposerId().getValue() : null;
+            Integer bitDepthId = updateRequest.hasFkBitdepthId() ? updateRequest.getFkBitdepthId().getValue() : null;
+            Integer bitRateId = updateRequest.hasFkBitrateId() ? updateRequest.getFkBitrateId().getValue() : null;
+            Integer samplingRateId = updateRequest.hasFkSamplingrateId() ? updateRequest.getFkSamplingrateId().getValue() : null;
+
+            Optional<Track> trackOpt = trackService.updateTrack(
+                    id,
+                    trackNumber,
+                    title,
+                    duration,
+                    filepath,
+                    discId,
+                    composerId,
+                    bitDepthId,
+                    bitRateId,
+                    samplingRateId
+            );
+
+            if (trackOpt.isEmpty()) {
+                logger.warn("Track not found with ID: {}", id);
+                return TransportProtocol.Response.newBuilder()
+                        .setStatusCode(404)
+                        .setPayload(ByteString.copyFromUtf8("Track not found"));
+            }
+
+            TrackMessages.Track trackProto = TrackMapper.toProtobuf(trackOpt.get());
+
+            TrackMessages.UpdateTrackResponse updateResponse =
+                    TrackMessages.UpdateTrackResponse.newBuilder()
+                            .setTrack(trackProto)
+                            .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 track", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(ByteString.copyFromUtf8("Error: " + e.getMessage()));
+        }
+    }
+}

src/main/java/com/mediamanager/service/delegate/handler/trackhasartist/CreateTrackHasArtistHandler.java

@@ -0,0 +1,54 @@
+package com.mediamanager.service.delegate.handler.trackhasartist;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.mapper.TrackHasArtistMapper;
+import com.mediamanager.model.TrackHasArtist;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.TrackHasArtistMessages;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import com.mediamanager.service.trackhasartist.TrackHasArtistService;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+@Action("trackhasartist.create")
+public class CreateTrackHasArtistHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(CreateTrackHasArtistHandler.class);
+    private final TrackHasArtistService trackHasArtistService;
+
+    public CreateTrackHasArtistHandler(TrackHasArtistService trackHasArtistService) {
+        this.trackHasArtistService = trackHasArtistService;
+    }
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload) throws InvalidProtocolBufferException {
+        try{
+            TrackHasArtistMessages.CreateTrackHasArtistRequest createRequest =
+                    TrackHasArtistMessages.CreateTrackHasArtistRequest.parseFrom(requestPayload);
+
+            TrackHasArtist trackHasArtist = trackHasArtistService.createTrackHasArtist(
+                    createRequest.getFkTrackId() > 0 ? createRequest.getFkTrackId() : null,
+                    createRequest.getFkArtistId() > 0 ? createRequest.getFkArtistId() : null
+            );
+
+            TrackHasArtistMessages.TrackHasArtist trackHasArtistProto = TrackHasArtistMapper.toProtobuf(trackHasArtist);
+            TrackHasArtistMessages.CreateTrackHasArtistResponse createTrackHasArtistResponse = TrackHasArtistMessages.CreateTrackHasArtistResponse.newBuilder()
+                    .setTrackhasartist(trackHasArtistProto)
+                    .build();
+            return TransportProtocol.Response.newBuilder()
+                    .setPayload(createTrackHasArtistResponse.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 track has artist", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(ByteString.copyFromUtf8("Error: " + e.getMessage()));
+        }
+    }
+}

src/main/java/com/mediamanager/service/delegate/handler/trackhasartist/DeleteTrackHasArtistHandler.java

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

src/main/java/com/mediamanager/service/delegate/handler/trackhasartist/GetTrackHasArtistByIdHandler.java

@@ -0,0 +1,56 @@
+package com.mediamanager.service.delegate.handler.trackhasartist;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.mapper.TrackHasArtistMapper;
+import com.mediamanager.model.TrackHasArtist;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.TrackHasArtistMessages;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import com.mediamanager.service.trackhasartist.TrackHasArtistService;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.Optional;
+
+@Action(value = "trackhasartist.getById")
+public class GetTrackHasArtistByIdHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(GetTrackHasArtistByIdHandler.class);
+    private final TrackHasArtistService trackHasArtistService;
+
+    public GetTrackHasArtistByIdHandler(TrackHasArtistService trackHasArtistService) {
+        this.trackHasArtistService = trackHasArtistService;
+    }
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload)
+        throws InvalidProtocolBufferException{
+
+        try{
+            TrackHasArtistMessages.GetTrackHasArtistByIdRequest getByIdRequest =
+                    TrackHasArtistMessages.GetTrackHasArtistByIdRequest.parseFrom(requestPayload);
+            int id = getByIdRequest.getId();
+
+            Optional<TrackHasArtist> trackHasArtistOpt = trackHasArtistService.getTrackHasArtistById(id);
+
+            if (trackHasArtistOpt.isEmpty()){
+                logger.warn("TrackHasArtist not found with ID: {}", id);
+                return TransportProtocol.Response.newBuilder()
+                        .setStatusCode(404)
+                        .setPayload(ByteString.copyFromUtf8("TrackHasArtist not found"));
+            }
+            TrackHasArtistMessages.TrackHasArtist trackHasArtistProto = TrackHasArtistMapper.toProtobuf(trackHasArtistOpt.get());
+            TrackHasArtistMessages.GetTrackHasArtistByIdResponse getByIdResponse = TrackHasArtistMessages.GetTrackHasArtistByIdResponse.newBuilder()
+                    .setTrackhasartist(trackHasArtistProto)
+                    .build();
+            return TransportProtocol.Response.newBuilder()
+                    .setPayload(getByIdResponse.toByteString());
+        } catch (Exception e) {
+            logger.error("Error getting track has artist by ID", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(ByteString.copyFromUtf8("Error: "+ e.getMessage()));
+        }
+    }
+}

src/main/java/com/mediamanager/service/delegate/handler/trackhasartist/GetTrackHasArtistHandler.java

@@ -0,0 +1,48 @@
+package com.mediamanager.service.delegate.handler.trackhasartist;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.mapper.TrackHasArtistMapper;
+import com.mediamanager.model.TrackHasArtist;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.TrackHasArtistMessages;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import com.mediamanager.service.trackhasartist.TrackHasArtistService;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.List;
+
+
+@Action("trackhasartist.getAll")
+public class GetTrackHasArtistHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(GetTrackHasArtistHandler.class);
+
+    private final TrackHasArtistService trackHasArtistService;
+
+    public GetTrackHasArtistHandler(TrackHasArtistService trackHasArtistService){this.trackHasArtistService = trackHasArtistService;}
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload) throws InvalidProtocolBufferException {
+        try{
+            List<TrackHasArtist> trackHasArtists = trackHasArtistService.getAllTrackHasArtists();
+            TrackHasArtistMessages.GetTrackHasArtistsResponse.Builder responseBuilder = TrackHasArtistMessages.GetTrackHasArtistsResponse.newBuilder();
+
+            for (TrackHasArtist trackHasArtist : trackHasArtists) {
+                TrackHasArtistMessages.TrackHasArtist trackHasArtistProto = TrackHasArtistMapper.toProtobuf(trackHasArtist);
+                responseBuilder.addTrackhasartist(trackHasArtistProto);
+            }
+            TrackHasArtistMessages.GetTrackHasArtistsResponse getTrackHasArtistsResponse = responseBuilder.build();
+
+            return TransportProtocol.Response.newBuilder()
+                    .setPayload(getTrackHasArtistsResponse.toByteString());
+
+        }catch (Exception e){
+            logger.error("Error getting track has artists", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(ByteString.copyFromUtf8("Error: " + e.getMessage()));
+        }
+    }
+}