feat: content service

src/main/java/com/magamochi/catalog/model/dto/MangaDTO.java

@@ -4,9 +4,9 @@ import static java.util.Objects.isNull;
 
 import com.magamochi.catalog.model.entity.Manga;
 import com.magamochi.catalog.model.entity.MangaAlternativeTitle;
+import com.magamochi.catalog.model.entity.MangaContentProvider;
 import com.magamochi.catalog.model.enumeration.MangaStatus;
-import com.magamochi.model.entity.MangaChapter;
+import com.magamochi.content.model.entity.MangaContent;
-import com.magamochi.model.entity.MangaContentProvider;
 import jakarta.validation.constraints.NotBlank;
 import jakarta.validation.constraints.NotNull;
 import java.time.OffsetDateTime;
@@ -59,9 +59,9 @@ public record MangaDTO(
       @NotNull Integer chaptersDownloaded,
       @NotNull Boolean supportsChapterFetch) {
     public static MangaProviderDTO from(MangaContentProvider mangaContentProvider) {
-      var chapters = mangaContentProvider.getMangaChapters();
+      var chapters = mangaContentProvider.getMangaContents();
       var chaptersAvailable = chapters.size();
-      var chaptersDownloaded = (int) chapters.stream().filter(MangaChapter::getDownloaded).count();
+      var chaptersDownloaded = (int) chapters.stream().filter(MangaContent::getDownloaded).count();
 
       return new MangaProviderDTO(
           mangaContentProvider.getId(),
@@ -69,7 +69,7 @@ public record MangaDTO(
           mangaContentProvider.getContentProvider().isActive(),
           chaptersAvailable,
           chaptersDownloaded,
-          mangaContentProvider.getContentProvider().getSupportsChapterFetch());
+          mangaContentProvider.getContentProvider().getSupportsContentFetch());
     }
   }
 }

src/main/java/com/magamochi/catalog/model/entity/Manga.java

@@ -3,7 +3,6 @@ package com.magamochi.catalog.model.entity;
 import com.magamochi.catalog.model.enumeration.MangaState;
 import com.magamochi.catalog.model.enumeration.MangaStatus;
 import com.magamochi.image.model.entity.Image;
-import com.magamochi.model.entity.MangaContentProvider;
 import com.magamochi.model.entity.UserFavoriteManga;
 import jakarta.persistence.*;
 import java.time.Instant;

src/main/java/com/magamochi/catalog/model/entity/MangaContentProvider.java

@@ -1,6 +1,6 @@
-package com.magamochi.model.entity;
+package com.magamochi.catalog.model.entity;
 
-import com.magamochi.catalog.model.entity.Manga;
+import com.magamochi.content.model.entity.MangaContent;
 import com.magamochi.ingestion.model.entity.ContentProvider;
 import jakarta.persistence.*;
 import java.time.Instant;
@@ -34,7 +34,7 @@ public class MangaContentProvider {
   private String url;
 
   @OneToMany(mappedBy = "mangaContentProvider")
-  List<MangaChapter> mangaChapters;
+  List<MangaContent> mangaContents;
 
   @CreationTimestamp private Instant createdAt;
 

src/main/java/com/magamochi/catalog/model/repository/MangaContentProviderRepository.java

@@ -1,6 +1,6 @@
 package com.magamochi.catalog.model.repository;
 
-import com.magamochi.model.entity.MangaContentProvider;
+import com.magamochi.catalog.model.entity.MangaContentProvider;
 import jakarta.validation.constraints.NotBlank;
 import org.springframework.data.jpa.repository.JpaRepository;
 

src/main/java/com/magamochi/catalog/service/LanguageService.java

@@ -11,7 +11,7 @@ import org.springframework.stereotype.Service;
 public class LanguageService {
   public final LanguageRepository languageRepository;
 
-  public Language getOrThrow(String code) {
+  public Language find(String code) {
     return languageRepository
         .findByCodeIgnoreCase(code)
         .orElseThrow(() -> new NotFoundException("Language with code " + code + " not found"));

src/main/java/com/magamochi/catalog/service/MangaContentProviderService.java

@@ -0,0 +1,22 @@
+package com.magamochi.catalog.service;
+
+import com.magamochi.catalog.model.entity.MangaContentProvider;
+import com.magamochi.catalog.model.repository.MangaContentProviderRepository;
+import com.magamochi.common.exception.NotFoundException;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+
+@Service
+@RequiredArgsConstructor
+public class MangaContentProviderService {
+  private final MangaContentProviderRepository mangaContentProviderRepository;
+
+  public MangaContentProvider find(long mangaContentProviderId) {
+    return mangaContentProviderRepository
+        .findById(mangaContentProviderId)
+        .orElseThrow(
+            () ->
+                new NotFoundException(
+                    "MangaContentProvider not found - ID: " + mangaContentProviderId));
+  }
+}

src/main/java/com/magamochi/catalog/service/MangaIngestService.java

@@ -2,11 +2,11 @@ package com.magamochi.catalog.service;
 
 import static java.util.Objects.isNull;
 
+import com.magamochi.catalog.model.entity.MangaContentProvider;
 import com.magamochi.catalog.model.entity.MangaIngestReview;
 import com.magamochi.catalog.model.repository.MangaContentProviderRepository;
 import com.magamochi.catalog.model.repository.MangaIngestReviewRepository;
 import com.magamochi.ingestion.service.ContentProviderService;
-import com.magamochi.model.entity.MangaContentProvider;
 import jakarta.validation.constraints.NotBlank;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.log4j.Log4j2;

src/main/java/com/magamochi/common/config/RabbitConfig.java

@@ -16,6 +16,9 @@ public class RabbitConfig {
   @Value("${queues.manga-ingest}")
   private String mangaIngestQueue;
 
+  @Value("${queues.manga-content-ingest}")
+  private String mangaContentIngestQueue;
+
   @Value("${queues.provider-page-ingest}")
   private String providerPageIngestQueue;
 
@@ -62,6 +65,11 @@ public class RabbitConfig {
         null);
   }
 
+  @Bean
+  public Queue mangaContentIngestQueue() {
+    return new Queue(mangaContentIngestQueue, false);
+  }
+
   @Bean
   public Queue mangaIngestQueue() {
     return new Queue(mangaIngestQueue, false);

src/main/java/com/magamochi/common/model/enumeration/ContentType.java

@@ -1,5 +1,7 @@
 package com.magamochi.common.model.enumeration;
 
 public enum ContentType {
-  MANGA_COVER
+  MANGA_COVER,
+  CHAPTER,
+  VOLUME
 }

src/main/java/com/magamochi/common/queue/command/MangaContentIngestCommand.java

@@ -0,0 +1,9 @@
+package com.magamochi.common.queue.command;
+
+import jakarta.validation.constraints.NotBlank;
+
+public record MangaContentIngestCommand(
+    long mangaContentProviderId,
+    @NotBlank String title,
+    @NotBlank String url,
+    @NotBlank String languageCode) {}

src/main/java/com/magamochi/content/controller/ContentController.java

@@ -0,0 +1,31 @@
+package com.magamochi.content.controller;
+
+import com.magamochi.common.model.dto.DefaultResponseDTO;
+import com.magamochi.content.model.dto.MangaContentDTO;
+import com.magamochi.content.service.ContentService;
+import io.swagger.v3.oas.annotations.Operation;
+import jakarta.validation.constraints.NotNull;
+import java.util.List;
+import lombok.RequiredArgsConstructor;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@RequestMapping("/content")
+@RequiredArgsConstructor
+public class ContentController {
+  private final ContentService contentService;
+
+  @Operation(
+      summary = "Get the content for a specific manga/content provider combination",
+      description = "Retrieve the content for a specific manga/content provider combination.",
+      tags = {"Content"},
+      operationId = "getMangaProviderContent")
+  @GetMapping("/{mangaContentProviderId}")
+  public DefaultResponseDTO<List<MangaContentDTO>> getMangaProviderContent(
+      @PathVariable @NotNull Long mangaContentProviderId) {
+    return DefaultResponseDTO.ok(contentService.getContent(mangaContentProviderId));
+  }
+}

src/main/java/com/magamochi/content/model/dto/LanguageDTO.java

@@ -1,4 +1,4 @@
-package com.magamochi.model.dto;
+package com.magamochi.content.model.dto;
 
 import static java.util.Objects.isNull;
 

src/main/java/com/magamochi/content/model/dto/MangaContentDTO.java

@@ -0,0 +1,21 @@
+package com.magamochi.content.model.dto;
+
+import com.magamochi.content.model.entity.MangaContent;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+
+public record MangaContentDTO(
+    @NotNull Long id,
+    @NotBlank String title,
+    @NotNull Boolean downloaded,
+    @NotNull Boolean isRead,
+    LanguageDTO language) {
+  public static MangaContentDTO from(MangaContent mangaContent) {
+    return new MangaContentDTO(
+        mangaContent.getId(),
+        mangaContent.getTitle(),
+        mangaContent.getDownloaded(),
+        false,
+        LanguageDTO.from(mangaContent.getLanguage()));
+  }
+}

src/main/java/com/magamochi/content/model/entity/MangaContent.java

@@ -1,6 +1,8 @@
-package com.magamochi.model.entity;
+package com.magamochi.content.model.entity;
 
 import com.magamochi.catalog.model.entity.Language;
+import com.magamochi.catalog.model.entity.MangaContentProvider;
+import com.magamochi.common.model.enumeration.ContentType;
 import jakarta.persistence.*;
 import java.time.Instant;
 import java.util.List;
@@ -9,13 +11,13 @@ import org.hibernate.annotations.CreationTimestamp;
 import org.hibernate.annotations.UpdateTimestamp;
 
 @Entity
-@Table(name = "manga_chapters")
+@Table(name = "manga_contents")
 @Builder
 @NoArgsConstructor
 @AllArgsConstructor
 @Getter
 @Setter
-public class MangaChapter {
+public class MangaContent {
   @Id
   @GeneratedValue(strategy = GenerationType.IDENTITY)
   private Long id;
@@ -24,22 +26,20 @@ public class MangaChapter {
   @JoinColumn(name = "manga_content_provider_id")
   private MangaContentProvider mangaContentProvider;
 
+  @Builder.Default private ContentType type = ContentType.CHAPTER;
+
   private String title;
 
   private String url;
 
   @Builder.Default private Boolean downloaded = false;
 
-  @Builder.Default private Boolean read = false;
-
   @CreationTimestamp private Instant createdAt;
 
   @UpdateTimestamp private Instant updatedAt;
 
-  @OneToMany(mappedBy = "mangaChapter")
+  @OneToMany(mappedBy = "mangaContent")
-  private List<MangaChapterImage> mangaChapterImages;
+  private List<MangaContentImage> mangaContentImages;
-
-  private Integer chapterNumber;
 
   @ManyToOne
   @JoinColumn(name = "language_id")

src/main/java/com/magamochi/content/model/entity/MangaContentImage.java

@@ -1,4 +1,4 @@
-package com.magamochi.model.entity;
+package com.magamochi.content.model.entity;
 
 import com.magamochi.image.model.entity.Image;
 import jakarta.persistence.*;
@@ -8,20 +8,20 @@ import org.hibernate.annotations.CreationTimestamp;
 import org.hibernate.annotations.UpdateTimestamp;
 
 @Entity
-@Table(name = "manga_chapter_images")
+@Table(name = "manga_content_images")
 @Builder
 @NoArgsConstructor
 @AllArgsConstructor
 @Getter
 @Setter
-public class MangaChapterImage {
+public class MangaContentImage {
   @Id
   @GeneratedValue(strategy = GenerationType.IDENTITY)
   private Long id;
 
   @ManyToOne
-  @JoinColumn(name = "manga_chapter_id")
+  @JoinColumn(name = "manga_content_id")
-  private MangaChapter mangaChapter;
+  private MangaContent mangaContent;
 
   @OneToOne
   @JoinColumn(name = "image_id")

src/main/java/com/magamochi/content/model/repository/MangaChapterImageRepository.java

@@ -0,0 +1,10 @@
+package com.magamochi.content.model.repository;
+
+import com.magamochi.content.model.entity.MangaContent;
+import com.magamochi.content.model.entity.MangaContentImage;
+import java.util.List;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+public interface MangaChapterImageRepository extends JpaRepository<MangaContentImage, Long> {
+  List<MangaContentImage> findAllByMangaContent(MangaContent mangaContent);
+}

src/main/java/com/magamochi/content/model/repository/MangaContentRepository.java

@@ -0,0 +1,8 @@
+package com.magamochi.content.model.repository;
+
+import com.magamochi.content.model.entity.MangaContent;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+public interface MangaContentRepository extends JpaRepository<MangaContent, Long> {
+  boolean existsByMangaContentProvider_IdAndUrlIgnoreCase(Long mangaContentProviderId, String url);
+}

src/main/java/com/magamochi/content/queue/consumer/MangaContentIngestConsumer.java

@@ -0,0 +1,22 @@
+package com.magamochi.content.queue.consumer;
+
+import com.magamochi.common.queue.command.MangaContentIngestCommand;
+import com.magamochi.content.service.ContentIngestService;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.log4j.Log4j2;
+import org.springframework.amqp.rabbit.annotation.RabbitListener;
+import org.springframework.stereotype.Service;
+
+@Log4j2
+@Service
+@RequiredArgsConstructor
+public class MangaContentIngestConsumer {
+  private final ContentIngestService contentIngestService;
+
+  @RabbitListener(queues = "${queues.manga-content-ingest}")
+  public void receiveMangaContentIngestCommand(MangaContentIngestCommand command) {
+    log.info("Received manga content ingest command: {}", command);
+    contentIngestService.ingest(
+        command.mangaContentProviderId(), command.title(), command.url(), command.languageCode());
+  }
+}

src/main/java/com/magamochi/content/service/ContentIngestService.java

@@ -0,0 +1,56 @@
+package com.magamochi.content.service;
+
+import com.magamochi.catalog.service.LanguageService;
+import com.magamochi.catalog.service.MangaContentProviderService;
+import com.magamochi.content.model.entity.MangaContent;
+import com.magamochi.content.model.repository.MangaContentRepository;
+import jakarta.validation.constraints.NotBlank;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.log4j.Log4j2;
+import org.springframework.stereotype.Service;
+
+@Log4j2
+@Service
+@RequiredArgsConstructor
+public class ContentIngestService {
+  private final MangaContentProviderService mangaContentProviderService;
+  private final LanguageService languageService;
+
+  private final MangaContentRepository mangaContentRepository;
+
+  public void ingest(
+      long mangaContentProviderId,
+      @NotBlank String title,
+      @NotBlank String url,
+      @NotBlank String languageCode) {
+    log.info("Ingesting Manga Content ({}) for provider {}", title, mangaContentProviderId);
+
+    var mangaContentProvider = mangaContentProviderService.find(mangaContentProviderId);
+
+    if (mangaContentRepository.existsByMangaContentProvider_IdAndUrlIgnoreCase(
+        mangaContentProvider.getId(), url)) {
+      log.info(
+          "Manga Content ({}) for provider {} already exists. Skipped.",
+          title,
+          mangaContentProviderId);
+      return;
+    }
+
+    var language = languageService.find(languageCode);
+
+    var mangaContent =
+        mangaContentRepository.save(
+            MangaContent.builder()
+                .mangaContentProvider(mangaContentProvider)
+                .title(title)
+                .url(url)
+                .language(language)
+                .build());
+
+    log.info(
+        "Ingested Manga Content ({}) for provider {}: {}",
+        title,
+        mangaContentProviderId,
+        mangaContent.getId());
+  }
+}

src/main/java/com/magamochi/content/service/ContentService.java

@@ -0,0 +1,25 @@
+package com.magamochi.content.service;
+
+import com.magamochi.catalog.service.MangaContentProviderService;
+import com.magamochi.content.model.dto.MangaContentDTO;
+import com.magamochi.content.model.entity.MangaContent;
+import jakarta.validation.constraints.NotNull;
+import java.util.Comparator;
+import java.util.List;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+
+@Service
+@RequiredArgsConstructor
+public class ContentService {
+  private final MangaContentProviderService mangaContentProviderService;
+
+  public List<MangaContentDTO> getContent(@NotNull Long mangaContentProviderId) {
+    var mangaContentProvider = mangaContentProviderService.find(mangaContentProviderId);
+
+    return mangaContentProvider.getMangaContents().stream()
+        .sorted(Comparator.comparing(MangaContent::getId))
+        .map(MangaContentDTO::from)
+        .toList();
+  }
+}

src/main/java/com/magamochi/controller/MangaController.java

@@ -1,10 +1,8 @@
 package com.magamochi.controller;
 
 import com.magamochi.common.model.dto.DefaultResponseDTO;
-import com.magamochi.model.dto.MangaChapterDTO;
 import com.magamochi.service.OldMangaService;
 import io.swagger.v3.oas.annotations.Operation;
-import java.util.List;
 import lombok.RequiredArgsConstructor;
 import org.springframework.web.bind.annotation.*;
 
@@ -14,17 +12,6 @@ import org.springframework.web.bind.annotation.*;
 public class MangaController {
   private final OldMangaService oldMangaService;
 
-  @Operation(
-      summary = "Get the available chapters for a specific manga/provider combination",
-      description = "Retrieve a list of manga chapters for a specific manga/provider combination.",
-      tags = {"Manga"},
-      operationId = "getMangaChapters")
-  @GetMapping("/{mangaProviderId}/chapters")
-  public DefaultResponseDTO<List<MangaChapterDTO>> getMangaChapters(
-      @PathVariable Long mangaProviderId) {
-    return DefaultResponseDTO.ok(oldMangaService.getMangaChapters(mangaProviderId));
-  }
-
   @Operation(
       summary = "Fetch all chapters",
       description = "Fetch all not yet downloaded chapters from the provider",
@@ -37,18 +24,6 @@ public class MangaController {
     return DefaultResponseDTO.ok().build();
   }
 
-  @Operation(
-      summary = "Fetch the available chapters for a specific manga/provider combination",
-      description = "Fetch a list of manga chapters for a specific manga/provider combination.",
-      tags = {"Manga"},
-      operationId = "fetchMangaChapters")
-  @PostMapping("/{mangaProviderId}/fetch-chapters")
-  public DefaultResponseDTO<Void> fetchMangaChapters(@PathVariable Long mangaProviderId) {
-    oldMangaService.fetchMangaChapters(mangaProviderId);
-
-    return DefaultResponseDTO.ok().build();
-  }
-
   @Operation(
       summary = "Follow the manga specified by its ID",
       description = "Follow the manga specified by its ID.",

src/main/java/com/magamochi/ingestion/controller/IngestionController.java

@@ -51,4 +51,18 @@ public class IngestionController {
 
     return DefaultResponseDTO.ok().build();
   }
+
+  @Operation(
+      summary = "Fetch content list from a content provider",
+      description =
+          "Triggers the ingestion process for a specific content provider, fetching content list and queuing it for processing.",
+      tags = {"Ingestion"},
+      operationId = "fetchContentProviderContentList")
+  @PostMapping("/manga-content-providers/{mangaContentProviderId}/fetch")
+  public DefaultResponseDTO<Void> fetchContentProviderContentList(
+      @PathVariable Long mangaContentProviderId) {
+    ingestionService.fetchMangaContentProviderContentList(mangaContentProviderId);
+
+    return DefaultResponseDTO.ok().build();
+  }
 }

src/main/java/com/magamochi/ingestion/model/dto/ContentInfoDTO.java

@@ -0,0 +1,6 @@
+package com.magamochi.ingestion.model.dto;
+
+import jakarta.validation.constraints.NotBlank;
+
+public record ContentInfoDTO(
+    @NotBlank String title, @NotBlank String url, @NotBlank String languageCode) {}

src/main/java/com/magamochi/ingestion/model/entity/ContentProvider.java

@@ -1,6 +1,6 @@
 package com.magamochi.ingestion.model.entity;
 
-import com.magamochi.model.entity.MangaContentProvider;
+import com.magamochi.catalog.model.entity.MangaContentProvider;
 import jakarta.persistence.*;
 import java.time.Instant;
 import java.util.List;
@@ -24,7 +24,7 @@ public class ContentProvider {
 
   private boolean active;
 
-  private Boolean supportsChapterFetch;
+  private Boolean supportsContentFetch;
 
   private Boolean manualImport;
 

src/main/java/com/magamochi/ingestion/model/repository/ContentProviderRepository.java

@@ -1,9 +1,6 @@
 package com.magamochi.ingestion.model.repository;
 
 import com.magamochi.ingestion.model.entity.ContentProvider;
-import java.util.Optional;
 import org.springframework.data.jpa.repository.JpaRepository;
 
-public interface ContentProviderRepository extends JpaRepository<ContentProvider, Long> {
+public interface ContentProviderRepository extends JpaRepository<ContentProvider, Long> {}
-  Optional<ContentProvider> findByNameIgnoreCase(String name);
-}

src/main/java/com/magamochi/ingestion/providers/ContentProvider.java

@@ -1,12 +1,12 @@
 package com.magamochi.ingestion.providers;
 
-import com.magamochi.model.dto.ContentProviderMangaChapterResponseDTO;
+import com.magamochi.catalog.model.entity.MangaContentProvider;
-import com.magamochi.model.entity.MangaContentProvider;
+import com.magamochi.ingestion.model.dto.ContentInfoDTO;
 import java.util.List;
 import java.util.Map;
 
 public interface ContentProvider {
-  List<ContentProviderMangaChapterResponseDTO> getAvailableChapters(MangaContentProvider provider);
+  List<ContentInfoDTO> getAvailableChapters(MangaContentProvider provider);
 
   Map<Integer, String> getChapterImagesUrls(String chapterUrl);
 }

src/main/java/com/magamochi/ingestion/providers/impl/MangaDexProvider.java

@@ -3,13 +3,13 @@ package com.magamochi.ingestion.providers.impl;
 import static java.util.Objects.isNull;
 
 import com.google.common.util.concurrent.RateLimiter;
+import com.magamochi.catalog.model.entity.MangaContentProvider;
 import com.magamochi.client.MangaDexClient;
 import com.magamochi.common.exception.UnprocessableException;
+import com.magamochi.ingestion.model.dto.ContentInfoDTO;
 import com.magamochi.ingestion.providers.ContentProvider;
 import com.magamochi.ingestion.providers.ContentProviders;
 import com.magamochi.ingestion.providers.ManualImportContentProvider;
-import com.magamochi.model.dto.ContentProviderMangaChapterResponseDTO;
-import com.magamochi.model.entity.MangaContentProvider;
 import java.util.*;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
@@ -26,8 +26,7 @@ public class MangaDexProvider implements ContentProvider, ManualImportContentPro
   private final RateLimiter mangaDexRateLimiter;
 
   @Override
-  public List<ContentProviderMangaChapterResponseDTO> getAvailableChapters(
+  public List<ContentInfoDTO> getAvailableChapters(MangaContentProvider provider) {
-      MangaContentProvider provider) {
     try {
       mangaDexRateLimiter.acquire();
       var response =
@@ -85,10 +84,9 @@ public class MangaDexProvider implements ContentProvider, ManualImportContentPro
               })
           .map(
               c ->
-                  new ContentProviderMangaChapterResponseDTO(
+                  new ContentInfoDTO(
                       c.attributes().chapter() + " - " + c.attributes().title(),
                       c.id().toString(),
-                      c.attributes().chapter(),
                       languagesToImport.get(c.attributes().translatedLanguage())))
           .toList();
     } catch (Exception e) {

src/main/java/com/magamochi/ingestion/providers/impl/MangaLivreBlogProvider.java

@@ -1,11 +1,11 @@
 package com.magamochi.ingestion.providers.impl;
 
+import com.magamochi.catalog.model.entity.MangaContentProvider;
+import com.magamochi.ingestion.model.dto.ContentInfoDTO;
 import com.magamochi.ingestion.model.dto.MangaInfoDTO;
 import com.magamochi.ingestion.providers.ContentProvider;
 import com.magamochi.ingestion.providers.ContentProviders;
 import com.magamochi.ingestion.providers.PagedContentProvider;
-import com.magamochi.model.dto.ContentProviderMangaChapterResponseDTO;
-import com.magamochi.model.entity.MangaContentProvider;
 import java.io.IOException;
 import java.util.*;
 import java.util.regex.Pattern;
@@ -27,8 +27,7 @@ public class MangaLivreBlogProvider implements ContentProvider, PagedContentProv
   private final String url = "https://mangalivre.blog/manga/";
 
   @Override
-  public List<ContentProviderMangaChapterResponseDTO> getAvailableChapters(
+  public List<ContentInfoDTO> getAvailableChapters(MangaContentProvider mangaContentProvider) {
-      MangaContentProvider mangaContentProvider) {
     log.info(
         "Getting available chapters from {}, manga {}",
         ContentProviders.MANGA_LIVRE_BLOG,
@@ -49,8 +48,8 @@ public class MangaLivreBlogProvider implements ContentProvider, PagedContentProv
                 var chapterNumberElement =
                     linkElement.getElementsByClass("chapter-number").getFirst();
 
-                return new ContentProviderMangaChapterResponseDTO(
+                return new ContentInfoDTO(
-                    chapterNumberElement.text(), linkElement.attr("href"), null, "pt-BR");
+                    chapterNumberElement.text(), linkElement.attr("href"), "pt-BR");
               })
           .toList();
     } catch (IOException | NoSuchElementException e) {

src/main/java/com/magamochi/ingestion/providers/impl/MangaLivreProvider.java

@@ -2,13 +2,13 @@ package com.magamochi.ingestion.providers.impl;
 
 import static java.util.Objects.nonNull;
 
+import com.magamochi.catalog.model.entity.MangaContentProvider;
+import com.magamochi.ingestion.model.dto.ContentInfoDTO;
 import com.magamochi.ingestion.model.dto.MangaInfoDTO;
 import com.magamochi.ingestion.providers.ContentProvider;
 import com.magamochi.ingestion.providers.ContentProviders;
 import com.magamochi.ingestion.providers.PagedContentProvider;
 import com.magamochi.ingestion.service.FlareService;
-import com.magamochi.model.dto.ContentProviderMangaChapterResponseDTO;
-import com.magamochi.model.entity.MangaContentProvider;
 import java.util.*;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
@@ -26,8 +26,7 @@ public class MangaLivreProvider implements ContentProvider, PagedContentProvider
   private final FlareService flareService;
 
   @Override
-  public List<ContentProviderMangaChapterResponseDTO> getAvailableChapters(
+  public List<ContentInfoDTO> getAvailableChapters(MangaContentProvider provider) {
-      MangaContentProvider provider) {
     log.info(
         "Getting available chapters from {}, manga {}",
         ContentProviders.MANGA_LIVRE_TO,
@@ -49,8 +48,7 @@ public class MangaLivreProvider implements ContentProvider, PagedContentProvider
                 var url = linkElement.attr("href");
                 var title = linkElement.text();
 
-                return new ContentProviderMangaChapterResponseDTO(
+                return new ContentInfoDTO(title.trim(), url.trim(), "pt-BR");
-                    title.trim(), url.trim(), null, "pt-BR");
               })
           .toList();
     } catch (NoSuchElementException e) {

src/main/java/com/magamochi/ingestion/providers/impl/PinkRosaScanProvider.java

@@ -3,13 +3,13 @@ package com.magamochi.ingestion.providers.impl;
 import static java.util.Objects.isNull;
 import static org.apache.commons.lang3.StringUtils.isBlank;
 
+import com.magamochi.catalog.model.entity.MangaContentProvider;
+import com.magamochi.ingestion.model.dto.ContentInfoDTO;
 import com.magamochi.ingestion.model.dto.MangaInfoDTO;
 import com.magamochi.ingestion.providers.ContentProvider;
 import com.magamochi.ingestion.providers.ContentProviders;
 import com.magamochi.ingestion.providers.PagedContentProvider;
 import com.magamochi.ingestion.service.FlareService;
-import com.magamochi.model.dto.ContentProviderMangaChapterResponseDTO;
-import com.magamochi.model.entity.MangaContentProvider;
 import java.util.*;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
@@ -27,8 +27,7 @@ public class PinkRosaScanProvider implements ContentProvider, PagedContentProvid
   private final FlareService flareService;
 
   @Override
-  public List<ContentProviderMangaChapterResponseDTO> getAvailableChapters(
+  public List<ContentInfoDTO> getAvailableChapters(MangaContentProvider provider) {
-      MangaContentProvider provider) {
     log.info(
         "Getting available chapters from {}, manga {}",
         ContentProviders.PINK_ROSA_SCAN,
@@ -57,11 +56,8 @@ public class PinkRosaScanProvider implements ContentProvider, PagedContentProvid
                         .getFirst()
                         .getElementsByClass("text-sm truncate")
                         .getFirst();
-                return new ContentProviderMangaChapterResponseDTO(
+                return new ContentInfoDTO(
-                    chapterTitleElement.text().trim(),
+                    chapterTitleElement.text().trim(), chapterItemElement.attr("href"), "pt-BR");
-                    chapterItemElement.attr("href"),
-                    null,
-                    "pt-BR");
               })
           .toList();
     } catch (NoSuchElementException e) {

src/main/java/com/magamochi/ingestion/queue/producer/MangaContentIngestProducer.java

@@ -0,0 +1,23 @@
+package com.magamochi.ingestion.queue.producer;
+
+import com.magamochi.common.queue.command.MangaContentIngestCommand;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.log4j.Log4j2;
+import org.springframework.amqp.rabbit.core.RabbitTemplate;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Service;
+
+@Log4j2
+@Service
+@RequiredArgsConstructor
+public class MangaContentIngestProducer {
+  private final RabbitTemplate rabbitTemplate;
+
+  @Value("${queues.manga-content-ingest}")
+  private String mangaContentIngestQueue;
+
+  public void sendMangaContentIngestCommand(MangaContentIngestCommand command) {
+    rabbitTemplate.convertAndSend(mangaContentIngestQueue, command);
+    log.info("Sent manga content ingest command: {}", command);
+  }
+}

src/main/java/com/magamochi/ingestion/service/IngestionService.java

@@ -1,8 +1,12 @@
 package com.magamochi.ingestion.service;
 
+import com.magamochi.catalog.service.MangaContentProviderService;
+import com.magamochi.common.queue.command.MangaContentIngestCommand;
 import com.magamochi.common.queue.command.MangaIngestCommand;
+import com.magamochi.ingestion.providers.ContentProviderFactory;
 import com.magamochi.ingestion.providers.PagedContentProviderFactory;
 import com.magamochi.ingestion.queue.command.ProviderPageIngestCommand;
+import com.magamochi.ingestion.queue.producer.MangaContentIngestProducer;
 import com.magamochi.ingestion.queue.producer.MangaIngestProducer;
 import com.magamochi.ingestion.queue.producer.ProviderPageIngestProducer;
 import java.util.stream.IntStream;
@@ -13,10 +17,14 @@ import org.springframework.stereotype.Service;
 @RequiredArgsConstructor
 public class IngestionService {
   private final ContentProviderService contentProviderService;
+  private final MangaContentProviderService mangaContentProviderService;
+
+  private final ContentProviderFactory contentProviderFactory;
   private final PagedContentProviderFactory pagedContentProviderFactory;
 
   private final ProviderPageIngestProducer providerPageIngestProducer;
   private final MangaIngestProducer mangaIngestProducer;
+  private final MangaContentIngestProducer mangaContentIngestProducer;
 
   public void fetchContentProviderMangas(long contentProviderId) {
     var contentProvider = contentProviderService.find(contentProviderId);
@@ -48,4 +56,23 @@ public class IngestionService {
     var contentProviders = contentProviderService.getProviders(null);
     contentProviders.providers().forEach(dto -> fetchContentProviderMangas(dto.id()));
   }
+
+  public void fetchMangaContentProviderContentList(Long mangaContentProviderId) {
+    var mangaContentProvider = mangaContentProviderService.find(mangaContentProviderId);
+
+    var contentProvider =
+        contentProviderFactory.getContentProvider(
+            mangaContentProvider.getContentProvider().getName());
+
+    var availableChapters = contentProvider.getAvailableChapters(mangaContentProvider);
+
+    availableChapters.forEach(
+        content ->
+            mangaContentIngestProducer.sendMangaContentIngestCommand(
+                new MangaContentIngestCommand(
+                    mangaContentProvider.getId(),
+                    content.title(),
+                    content.url(),
+                    content.languageCode())));
+  }
 }

src/main/java/com/magamochi/model/dto/ContentProviderMangaChapterResponseDTO.java

@@ -1,9 +0,0 @@
-package com.magamochi.model.dto;
-
-import jakarta.validation.constraints.NotBlank;
-
-public record ContentProviderMangaChapterResponseDTO(
-    @NotBlank String chapterTitle,
-    @NotBlank String chapterUrl,
-    String chapter,
-    String languageCode) {}

src/main/java/com/magamochi/model/dto/MangaChapterDTO.java

@@ -1,21 +0,0 @@
-package com.magamochi.model.dto;
-
-import com.magamochi.model.entity.MangaChapter;
-import jakarta.validation.constraints.NotBlank;
-import jakarta.validation.constraints.NotNull;
-
-public record MangaChapterDTO(
-    @NotNull Long id,
-    @NotBlank String title,
-    @NotNull Boolean downloaded,
-    @NotNull Boolean isRead,
-    LanguageDTO language) {
-  public static MangaChapterDTO from(MangaChapter mangaChapter) {
-    return new MangaChapterDTO(
-        mangaChapter.getId(),
-        mangaChapter.getTitle(),
-        mangaChapter.getDownloaded(),
-        mangaChapter.getRead(),
-        LanguageDTO.from(mangaChapter.getLanguage()));
-  }
-}

src/main/java/com/magamochi/model/dto/MangaChapterImagesDTO.java

@@ -1,7 +1,7 @@
 package com.magamochi.model.dto;
 
-import com.magamochi.model.entity.MangaChapter;
+import com.magamochi.content.model.entity.MangaContent;
-import com.magamochi.model.entity.MangaChapterImage;
+import com.magamochi.content.model.entity.MangaContentImage;
 import jakarta.validation.constraints.NotBlank;
 import jakarta.validation.constraints.NotNull;
 import java.util.Comparator;
@@ -13,14 +13,14 @@ public record MangaChapterImagesDTO(
     Long previousChapterId,
     Long nextChapterId,
     @NotNull List<@NotBlank String> chapterImageKeys) {
-  public static MangaChapterImagesDTO from(MangaChapter mangaChapter, Long prevId, Long nextId) {
+  public static MangaChapterImagesDTO from(MangaContent mangaContent, Long prevId, Long nextId) {
     return new MangaChapterImagesDTO(
-        mangaChapter.getId(),
+        mangaContent.getId(),
-        mangaChapter.getTitle(),
+        mangaContent.getTitle(),
         prevId,
         nextId,
-        mangaChapter.getMangaChapterImages().stream()
+        mangaContent.getMangaContentImages().stream()
-            .sorted(Comparator.comparing(MangaChapterImage::getPosition))
+            .sorted(Comparator.comparing(MangaContentImage::getPosition))
             .map(mangaChapterImage -> mangaChapterImage.getImage().getObjectKey())
             .toList());
   }

src/main/java/com/magamochi/model/repository/MangaChapterImageRepository.java

@@ -1,10 +0,0 @@
-package com.magamochi.model.repository;
-
-import com.magamochi.model.entity.MangaChapter;
-import com.magamochi.model.entity.MangaChapterImage;
-import java.util.List;
-import org.springframework.data.jpa.repository.JpaRepository;
-
-public interface MangaChapterImageRepository extends JpaRepository<MangaChapterImage, Long> {
-  List<MangaChapterImage> findAllByMangaChapter(MangaChapter mangaChapter);
-}

src/main/java/com/magamochi/model/repository/MangaChapterRepository.java

@@ -1,15 +0,0 @@
-package com.magamochi.model.repository;
-
-import com.magamochi.model.entity.MangaChapter;
-import com.magamochi.model.entity.MangaContentProvider;
-import jakarta.validation.constraints.NotBlank;
-import java.util.List;
-import java.util.Optional;
-import org.springframework.data.jpa.repository.JpaRepository;
-
-public interface MangaChapterRepository extends JpaRepository<MangaChapter, Long> {
-  Optional<MangaChapter> findByMangaContentProviderAndUrlIgnoreCase(
-      MangaContentProvider mangaContentProvider, @NotBlank String url);
-
-  List<MangaChapter> findByMangaContentProviderId(Long mangaProvider_id);
-}

src/main/java/com/magamochi/queue/UpdateMangaFollowChapterListConsumer.java

@@ -16,6 +16,6 @@ public class UpdateMangaFollowChapterListConsumer {
   @RabbitListener(queues = "${rabbit-mq.queues.manga-follow-update-chapter}")
   public void receiveMangaFollowUpdateChapterCommand(UpdateMangaFollowChapterListCommand command) {
     log.info("Received update followed manga chapter list command: {}", command);
-    oldMangaService.fetchFollowedMangaChapters(command.mangaProviderId());
+    //    oldMangaService.fetchFollowedMangaChapters(command.mangaProviderId());
   }
 }

src/main/java/com/magamochi/service/MangaChapterService.java

@@ -2,14 +2,14 @@ package com.magamochi.service;
 
 import com.google.common.util.concurrent.RateLimiter;
 import com.magamochi.common.exception.UnprocessableException;
+import com.magamochi.content.model.entity.MangaContent;
+import com.magamochi.content.model.entity.MangaContentImage;
+import com.magamochi.content.model.repository.MangaChapterImageRepository;
+import com.magamochi.content.model.repository.MangaContentRepository;
 import com.magamochi.ingestion.providers.ContentProviderFactory;
 import com.magamochi.model.dto.MangaChapterArchiveDTO;
 import com.magamochi.model.dto.MangaChapterImagesDTO;
-import com.magamochi.model.entity.MangaChapter;
-import com.magamochi.model.entity.MangaChapterImage;
 import com.magamochi.model.enumeration.ArchiveFileType;
-import com.magamochi.model.repository.MangaChapterImageRepository;
-import com.magamochi.model.repository.MangaChapterRepository;
 import io.github.resilience4j.retry.Retry;
 import io.github.resilience4j.retry.RetryRegistry;
 import java.io.BufferedInputStream;
@@ -32,7 +32,7 @@ import org.springframework.transaction.annotation.Transactional;
 @Service
 @RequiredArgsConstructor
 public class MangaChapterService {
-  private final MangaChapterRepository mangaChapterRepository;
+  private final MangaContentRepository mangaContentRepository;
   private final MangaChapterImageRepository mangaChapterImageRepository;
 
   private final OldImageService oldImageService;
@@ -104,8 +104,8 @@ public class MangaChapterService {
                                 chapterId,
                                 entry.getValue());
 
-                            return MangaChapterImage.builder()
+                            return MangaContentImage.builder()
-                                .mangaChapter(chapter)
+                                .mangaContent(chapter)
                                 .position(entry.getKey())
                                 .image(image)
                                 .build();
@@ -121,15 +121,15 @@ public class MangaChapterService {
     mangaChapterImageRepository.saveAll(chapterImages);
 
     chapter.setDownloaded(true);
-    mangaChapterRepository.save(chapter);
+    mangaContentRepository.save(chapter);
   }
 
   public MangaChapterImagesDTO getMangaChapterImages(Long chapterId) {
     var chapter = getMangaChapterThrowIfNotFound(chapterId);
 
     var chapters =
-        chapter.getMangaContentProvider().getMangaChapters().stream()
+        chapter.getMangaContentProvider().getMangaContents().stream()
-            .sorted(Comparator.comparing(MangaChapter::getId))
+            .sorted(Comparator.comparing(MangaContent::getId))
             .toList();
     Long prevId = null;
     Long nextId = null;
@@ -153,17 +153,18 @@ public class MangaChapterService {
   }
 
   public void markAsRead(Long chapterId) {
-    var chapter = getMangaChapterThrowIfNotFound(chapterId);
+    // TODO: implement this
-    chapter.setRead(true);
+    //    var chapter = getMangaChapterThrowIfNotFound(chapterId);
-
+    //    chapter.setRead(true);
-    mangaChapterRepository.save(chapter);
+    //
+    //    mangaChapterRepository.save(chapter);
   }
 
   public MangaChapterArchiveDTO downloadChapter(Long chapterId, ArchiveFileType archiveFileType)
       throws IOException {
     var chapter = getMangaChapterThrowIfNotFound(chapterId);
 
-    var chapterImages = mangaChapterImageRepository.findAllByMangaChapter(chapter);
+    var chapterImages = mangaChapterImageRepository.findAllByMangaContent(chapter);
 
     var byteArrayOutputStream =
         switch (archiveFileType) {
@@ -177,7 +178,7 @@ public class MangaChapterService {
         chapter.getTitle() + ".cbz", byteArrayOutputStream.toByteArray());
   }
 
-  private ByteArrayOutputStream getChapterCbzArchive(List<MangaChapterImage> chapterImages)
+  private ByteArrayOutputStream getChapterCbzArchive(List<MangaContentImage> chapterImages)
       throws IOException {
     var byteArrayOutputStream = new ByteArrayOutputStream();
     var bufferedOutputStream = new BufferedOutputStream(byteArrayOutputStream);
@@ -202,8 +203,8 @@ public class MangaChapterService {
     return byteArrayOutputStream;
   }
 
-  private MangaChapter getMangaChapterThrowIfNotFound(Long chapterId) {
+  private MangaContent getMangaChapterThrowIfNotFound(Long chapterId) {
-    return mangaChapterRepository
+    return mangaContentRepository
         .findById(chapterId)
         .orElseThrow(() -> new RuntimeException("Manga Chapter not found for ID: " + chapterId));
   }

src/main/java/com/magamochi/service/MangaImportService.java

@@ -378,12 +378,12 @@
 //    var mangaChapter =
 //        mangaChapterRepository
 //            .findByMangaContentProviderAndUrlIgnoreCase(mangaContentProvider,
-// chapter.chapterUrl())
+// chapter.url())
 //            .orElseGet(MangaChapter::new);
 //
 //    mangaChapter.setMangaContentProvider(mangaContentProvider);
-//    mangaChapter.setTitle(chapter.chapterTitle());
+//    mangaChapter.setTitle(chapter.title());
-//    mangaChapter.setUrl(chapter.chapterUrl());
+//    mangaChapter.setUrl(chapter.url());
 //
 //    var language = languageService.getOrThrow(chapter.languageCode());
 //    mangaChapter.setLanguage(language);

src/main/java/com/magamochi/service/OldMangaService.java

@@ -1,20 +1,19 @@
 package com.magamochi.service;
 
 import com.magamochi.catalog.model.entity.Manga;
+import com.magamochi.catalog.model.entity.MangaContentProvider;
 import com.magamochi.catalog.model.repository.MangaContentProviderRepository;
 import com.magamochi.catalog.model.repository.MangaRepository;
 import com.magamochi.client.NtfyClient;
 import com.magamochi.common.exception.NotFoundException;
+import com.magamochi.content.model.entity.MangaContent;
+import com.magamochi.content.model.repository.MangaContentRepository;
 import com.magamochi.ingestion.providers.ContentProviderFactory;
 import com.magamochi.model.dto.*;
-import com.magamochi.model.entity.MangaChapter;
-import com.magamochi.model.entity.MangaContentProvider;
 import com.magamochi.model.entity.UserMangaFollow;
 import com.magamochi.model.repository.*;
 import com.magamochi.queue.MangaChapterDownloadProducer;
 import com.magamochi.user.service.UserService;
-import java.util.Comparator;
-import java.util.List;
 import java.util.stream.Collectors;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.log4j.Log4j2;
@@ -25,7 +24,6 @@ import org.springframework.transaction.annotation.Transactional;
 @Service
 @RequiredArgsConstructor
 public class OldMangaService {
-  //  private final MangaImportService mangaImportService;
   private final UserService userService;
   private final MangaRepository mangaRepository;
   private final MangaContentProviderRepository mangaContentProviderRepository;
@@ -35,7 +33,7 @@ public class OldMangaService {
   private final UserMangaFollowRepository userMangaFollowRepository;
 
   private final MangaChapterDownloadProducer mangaChapterDownloadProducer;
-  private final MangaChapterRepository mangaChapterRepository;
+  private final MangaContentRepository mangaContentRepository;
 
   private final NtfyClient ntfyClient;
 
@@ -47,9 +45,9 @@ public class OldMangaService {
                 () -> new NotFoundException("Manga Provider not found for ID: " + mangaProviderId));
 
     var chapterIds =
-        mangaProvider.getMangaChapters().stream()
+        mangaProvider.getMangaContents().stream()
             .filter(mangaChapter -> !mangaChapter.getDownloaded())
-            .map(MangaChapter::getId)
+            .map(MangaContent::getId)
             .collect(Collectors.toSet());
 
     chapterIds.forEach(
@@ -58,57 +56,39 @@ public class OldMangaService {
                 new MangaChapterDownloadCommand(chapterId)));
   }
 
-  public List<MangaChapterDTO> getMangaChapters(Long mangaProviderId) {
+  //  public void fetchFollowedMangaChapters(Long mangaProviderId) {
-    var mangaProvider = getMangaProviderThrowIfNotFound(mangaProviderId);
+  //    var mangaProvider =
-
+  //        mangaContentProviderRepository
-    return mangaProvider.getMangaChapters().stream()
+  //            .findById(mangaProviderId)
-        .sorted(Comparator.comparing(MangaChapter::getId))
+  //            .orElseThrow(
-        .map(MangaChapterDTO::from)
+  //                () -> new NotFoundException("Manga Provider not found for ID: " +
-        .toList();
+  // mangaProviderId));
-  }
+  //
-
+  //    var currentAvailableChapterCount =
-  public void fetchFollowedMangaChapters(Long mangaProviderId) {
+  //        mangaChapterRepository.findByMangaContentProviderId(mangaProviderId).size();
-    var mangaProvider =
+  //
-        mangaContentProviderRepository
+  //    fetchMangaChapters(mangaProviderId);
-            .findById(mangaProviderId)
+  //    mangaChapterRepository.flush();
-            .orElseThrow(
+  //
-                () -> new NotFoundException("Manga Provider not found for ID: " + mangaProviderId));
+  //    var availableChapterCount =
-
+  //        mangaChapterRepository.findByMangaContentProviderId(mangaProviderId).size();
-    var currentAvailableChapterCount =
+  //
-        mangaChapterRepository.findByMangaContentProviderId(mangaProviderId).size();
+  //    if (availableChapterCount <= currentAvailableChapterCount) {
-
+  //      return;
-    fetchMangaChapters(mangaProviderId);
+  //    }
-    mangaChapterRepository.flush();
+  //
-
+  //    log.info("New chapters found for Manga Provider {}", mangaProviderId);
-    var availableChapterCount =
+  //
-        mangaChapterRepository.findByMangaContentProviderId(mangaProviderId).size();
+  //    var userMangaFollows = userMangaFollowRepository.findByManga(mangaProvider.getManga());
-
+  //    userMangaFollows.forEach(
-    if (availableChapterCount <= currentAvailableChapterCount) {
+  //        umf ->
-      return;
+  //            ntfyClient.notify(
-    }
+  //                new NtfyClient.Request(
-
+  //                    "mangamochi-" + umf.getUser().getId().toString(),
-    log.info("New chapters found for Manga Provider {}", mangaProviderId);
+  //                    umf.getManga().getTitle(),
-
+  //                    "New chapter available on " +
-    var userMangaFollows = userMangaFollowRepository.findByManga(mangaProvider.getManga());
+  // mangaProvider.getContentProvider().getName())));
-    userMangaFollows.forEach(
+  //  }
-        umf ->
-            ntfyClient.notify(
-                new NtfyClient.Request(
-                    "mangamochi-" + umf.getUser().getId().toString(),
-                    umf.getManga().getTitle(),
-                    "New chapter available on " + mangaProvider.getContentProvider().getName())));
-  }
-
-  public void fetchMangaChapters(Long mangaProviderId) {
-    var mangaProvider = getMangaProviderThrowIfNotFound(mangaProviderId);
-
-    var contentProvider =
-        contentProviderFactory.getContentProvider(mangaProvider.getContentProvider().getName());
-    var availableChapters = contentProvider.getAvailableChapters(mangaProvider);
-
-    //    availableChapters.forEach(
-    //        chapter -> mangaImportService.persistMangaChapter(mangaProvider, chapter));
-  }
 
   public Manga findMangaByIdThrowIfNotFound(Long mangaId) {
     return mangaRepository

src/main/resources/application.yml

@@ -96,6 +96,7 @@ topics:
 
 queues:
   manga-ingest: ${MANGA_INGEST_QUEUE:mangaIngest}
+  manga-content-ingest: ${MANGA_CONTENT_INGEST_QUEUE:mangaContentIngest}
   provider-page-ingest: ${PROVIDER_PAGE_INGEST_QUEUE:providerPageIngest}
   manga-update: ${MANGA_UPDATE_QUEUE:mangaUpdate}
   image-fetch: ${IMAGE_FETCH_QUEUE:imageFetch}

src/main/resources/db/migration/V0001__CREATE_TABLES.sql

@@ -46,7 +46,7 @@ CREATE TABLE content_providers
     name                   VARCHAR   NOT NULL,
     url                    VARCHAR   NOT NULL,
     active                 BOOLEAN   NOT NULL DEFAULT TRUE,
-    supports_chapter_fetch BOOLEAN   NOT NULL DEFAULT TRUE,
+    supports_content_fetch BOOLEAN   NOT NULL DEFAULT TRUE,
     manual_import          BOOLEAN   NOT NULL DEFAULT FALSE,
     created_at             TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
     updated_at             TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
@@ -64,24 +64,23 @@ CREATE TABLE manga_content_provider
     UNIQUE (manga_id, content_provider_id)
 );
 
-CREATE TABLE manga_chapters
+CREATE TABLE manga_contents
 (
     id                        BIGSERIAL   NOT NULL PRIMARY KEY,
     manga_content_provider_id BIGINT      NOT NULL REFERENCES manga_content_provider (id) ON DELETE CASCADE,
+    type                      VARCHAR(50) NOT NULL,
     title                     VARCHAR     NOT NULL,
     url                       VARCHAR     NOT NULL,
-    chapter_number            INTEGER,
     language_id               BIGINT REFERENCES languages (id),
     downloaded                BOOLEAN              DEFAULT FALSE,
-    read                      BOOLEAN            DEFAULT FALSE,
     created_at                TIMESTAMP   NOT NULL DEFAULT CURRENT_TIMESTAMP,
     updated_at                TIMESTAMP   NOT NULL DEFAULT CURRENT_TIMESTAMP
 );
 
-CREATE TABLE manga_chapter_images
+CREATE TABLE manga_content_images
 (
     id               BIGSERIAL NOT NULL PRIMARY KEY,
-    manga_chapter_id BIGINT    NOT NULL REFERENCES manga_chapters (id) ON DELETE CASCADE,
+    manga_content_id BIGINT    NOT NULL REFERENCES manga_contents (id) ON DELETE CASCADE,
     image_id         UUID REFERENCES images (id) ON DELETE CASCADE,
     position         INT       NOT NULL,
     created_at       TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,

src/main/resources/db/migration/V0002__CONTENT_PROVIDERS.sql

@@ -1,4 +1,4 @@
-INSERT INTO content_providers(name, url, active, supports_chapter_fetch, manual_import)
+INSERT INTO content_providers(name, url, active, supports_content_fetch, manual_import)
 VALUES ('Manga Livre Blog', 'https://mangalivre.blog', TRUE, TRUE, FALSE),
        ('Manga Livre.to', 'https://mangalivre.to', TRUE, TRUE, FALSE),
        ('Pink Rosa Scan', 'https://scanpinkrosa.blogspot.com', TRUE, TRUE, FALSE);