mangamochi/backend
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: content service

Browse Source
This commit is contained in:
Rodrigo Verdiani 2026-03-18 11:11:24 -03:00
parent 7cb571939e
commit 2bc3f9897e
44 changed files with 420 additions and 248 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
src/main/java/com/magamochi/catalog/model/dto/MangaDTO.java
View File

@ -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.model.entity.MangaContentProvider;
import com.magamochi.content.model.entity.MangaContent;
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());
}
}
}

1
src/main/java/com/magamochi/catalog/model/entity/Manga.java
View File

@ -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;

6
src/main/java/com/magamochi/model/entity/MangaContentProvider.java → src/main/java/com/magamochi/catalog/model/entity/MangaContentProvider.java
View File

@ -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;

2
src/main/java/com/magamochi/catalog/model/repository/MangaContentProviderRepository.java
View File

@ -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;

2
src/main/java/com/magamochi/catalog/service/LanguageService.java
View File

@ -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"));

22
src/main/java/com/magamochi/catalog/service/MangaContentProviderService.java Normal file
View File

@ -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));
}
}

2
src/main/java/com/magamochi/catalog/service/MangaIngestService.java
View File

@ -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;

8
src/main/java/com/magamochi/common/config/RabbitConfig.java
View File

@ -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);

4
src/main/java/com/magamochi/common/model/enumeration/ContentType.java
View File

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

9
src/main/java/com/magamochi/common/queue/command/MangaContentIngestCommand.java Normal file
View File

@ -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) {}

31
src/main/java/com/magamochi/content/controller/ContentController.java Normal file
View File

@ -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));
}
}

2
src/main/java/com/magamochi/model/dto/LanguageDTO.java → src/main/java/com/magamochi/content/model/dto/LanguageDTO.java
View File

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

21
src/main/java/com/magamochi/content/model/dto/MangaContentDTO.java Normal file
View File

@ -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()));
}
}

18
src/main/java/com/magamochi/model/entity/MangaChapter.java → src/main/java/com/magamochi/content/model/entity/MangaContent.java
View File

@ -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")
private List<MangaChapterImage> mangaChapterImages;
private Integer chapterNumber;
@OneToMany(mappedBy = "mangaContent")
private List<MangaContentImage> mangaContentImages;
@ManyToOne
@JoinColumn(name = "language_id")

10
src/main/java/com/magamochi/model/entity/MangaChapterImage.java → src/main/java/com/magamochi/content/model/entity/MangaContentImage.java
View File

@ -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")
private MangaChapter mangaChapter;
@JoinColumn(name = "manga_content_id")
private MangaContent mangaContent;
@OneToOne
@JoinColumn(name = "image_id")

10
src/main/java/com/magamochi/content/model/repository/MangaChapterImageRepository.java Normal file
View File

@ -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);
}

8
src/main/java/com/magamochi/content/model/repository/MangaContentRepository.java Normal file
View File

@ -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);
}

22
src/main/java/com/magamochi/content/queue/consumer/MangaContentIngestConsumer.java Normal file
View File

@ -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());
}
}

56
src/main/java/com/magamochi/content/service/ContentIngestService.java Normal file
View File

@ -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());
}
}

25
src/main/java/com/magamochi/content/service/ContentService.java Normal file
View File

@ -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();
}
}

25
src/main/java/com/magamochi/controller/MangaController.java
View File

@ -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.",

14
src/main/java/com/magamochi/ingestion/controller/IngestionController.java
View File

@ -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();
}
}

6
src/main/java/com/magamochi/ingestion/model/dto/ContentInfoDTO.java Normal file
View File

@ -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) {}

4
src/main/java/com/magamochi/ingestion/model/entity/ContentProvider.java
View File

@ -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;

5
src/main/java/com/magamochi/ingestion/model/repository/ContentProviderRepository.java
View File

@ -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> {
Optional<ContentProvider> findByNameIgnoreCase(String name);
}
public interface ContentProviderRepository extends JpaRepository<ContentProvider, Long> {}

6
src/main/java/com/magamochi/ingestion/providers/ContentProvider.java
View File

@ -1,12 +1,12 @@
package com.magamochi.ingestion.providers;
import com.magamochi.model.dto.ContentProviderMangaChapterResponseDTO;
import com.magamochi.model.entity.MangaContentProvider;
import com.magamochi.catalog.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);
}

10
src/main/java/com/magamochi/ingestion/providers/impl/MangaDexProvider.java
View File

@ -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(
MangaContentProvider provider) {
public List<ContentInfoDTO> getAvailableChapters(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) {

11
src/main/java/com/magamochi/ingestion/providers/impl/MangaLivreBlogProvider.java
View File

@ -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(
MangaContentProvider mangaContentProvider) {
public List<ContentInfoDTO> getAvailableChapters(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(
chapterNumberElement.text(), linkElement.attr("href"), null, "pt-BR");
return new ContentInfoDTO(
chapterNumberElement.text(), linkElement.attr("href"), "pt-BR");
})
.toList();
} catch (IOException | NoSuchElementException e) {

10
src/main/java/com/magamochi/ingestion/providers/impl/MangaLivreProvider.java
View File

@ -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(
MangaContentProvider provider) {
public List<ContentInfoDTO> getAvailableChapters(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(
title.trim(), url.trim(), null, "pt-BR");
return new ContentInfoDTO(title.trim(), url.trim(), "pt-BR");
})
.toList();
} catch (NoSuchElementException e) {

14
src/main/java/com/magamochi/ingestion/providers/impl/PinkRosaScanProvider.java
View File

@ -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(
MangaContentProvider provider) {
public List<ContentInfoDTO> getAvailableChapters(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(
chapterTitleElement.text().trim(),
chapterItemElement.attr("href"),
null,
"pt-BR");
return new ContentInfoDTO(
chapterTitleElement.text().trim(), chapterItemElement.attr("href"), "pt-BR");
})
.toList();
} catch (NoSuchElementException e) {

23
src/main/java/com/magamochi/ingestion/queue/producer/MangaContentIngestProducer.java Normal file
View File

@ -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);
}
}

27
src/main/java/com/magamochi/ingestion/service/IngestionService.java
View File

@ -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())));
}
}

9
src/main/java/com/magamochi/model/dto/ContentProviderMangaChapterResponseDTO.java
View File

@ -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) {}

21
src/main/java/com/magamochi/model/dto/MangaChapterDTO.java
View File

@ -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()));
}
}

14
src/main/java/com/magamochi/model/dto/MangaChapterImagesDTO.java
View File

@ -1,7 +1,7 @@
package com.magamochi.model.dto;
import com.magamochi.model.entity.MangaChapter;
import com.magamochi.model.entity.MangaChapterImage;
import com.magamochi.content.model.entity.MangaContent;
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(),
mangaChapter.getTitle(),
mangaContent.getId(),
mangaContent.getTitle(),
prevId,
nextId,
mangaChapter.getMangaChapterImages().stream()
.sorted(Comparator.comparing(MangaChapterImage::getPosition))
mangaContent.getMangaContentImages().stream()
.sorted(Comparator.comparing(MangaContentImage::getPosition))
.map(mangaChapterImage -> mangaChapterImage.getImage().getObjectKey())
.toList());
}

10
src/main/java/com/magamochi/model/repository/MangaChapterImageRepository.java
View File

@ -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);
}

15
src/main/java/com/magamochi/model/repository/MangaChapterRepository.java
View File

@ -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);
}

2
src/main/java/com/magamochi/queue/UpdateMangaFollowChapterListConsumer.java
View File

@ -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());
}
}

37
src/main/java/com/magamochi/service/MangaChapterService.java
View File

@ -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()
.mangaChapter(chapter)
return MangaContentImage.builder()
.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()
.sorted(Comparator.comparing(MangaChapter::getId))
chapter.getMangaContentProvider().getMangaContents().stream()
.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);
chapter.setRead(true);
mangaChapterRepository.save(chapter);
// TODO: implement this
// var chapter = getMangaChapterThrowIfNotFound(chapterId);
// chapter.setRead(true);
//
// 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) {
return mangaChapterRepository
private MangaContent getMangaChapterThrowIfNotFound(Long chapterId) {
return mangaContentRepository
.findById(chapterId)
.orElseThrow(() -> new RuntimeException("Manga Chapter not found for ID: " + chapterId));
}

6
src/main/java/com/magamochi/service/MangaImportService.java
View File

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

98
src/main/java/com/magamochi/service/OldMangaService.java
View File

@ -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) {
var mangaProvider = getMangaProviderThrowIfNotFound(mangaProviderId);
return mangaProvider.getMangaChapters().stream()
.sorted(Comparator.comparing(MangaChapter::getId))
.map(MangaChapterDTO::from)
.toList();
}
public void fetchFollowedMangaChapters(Long mangaProviderId) {
var mangaProvider =
mangaContentProviderRepository
.findById(mangaProviderId)
.orElseThrow(
() -> new NotFoundException("Manga Provider not found for ID: " + mangaProviderId));
var currentAvailableChapterCount =
mangaChapterRepository.findByMangaContentProviderId(mangaProviderId).size();
fetchMangaChapters(mangaProviderId);
mangaChapterRepository.flush();
var availableChapterCount =
mangaChapterRepository.findByMangaContentProviderId(mangaProviderId).size();
if (availableChapterCount <= currentAvailableChapterCount) {
return;
}
log.info("New chapters found for Manga Provider {}", mangaProviderId);
var userMangaFollows = userMangaFollowRepository.findByManga(mangaProvider.getManga());
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 void fetchFollowedMangaChapters(Long mangaProviderId) {
// var mangaProvider =
// mangaContentProviderRepository
// .findById(mangaProviderId)
// .orElseThrow(
// () -> new NotFoundException("Manga Provider not found for ID: " +
// mangaProviderId));
//
// var currentAvailableChapterCount =
// mangaChapterRepository.findByMangaContentProviderId(mangaProviderId).size();
//
// fetchMangaChapters(mangaProviderId);
// mangaChapterRepository.flush();
//
// var availableChapterCount =
// mangaChapterRepository.findByMangaContentProviderId(mangaProviderId).size();
//
// if (availableChapterCount <= currentAvailableChapterCount) {
// return;
// }
//
// log.info("New chapters found for Manga Provider {}", mangaProviderId);
//
// var userMangaFollows = userMangaFollowRepository.findByManga(mangaProvider.getManga());
// userMangaFollows.forEach(
// umf ->
// ntfyClient.notify(
// new NtfyClient.Request(
// "mangamochi-" + umf.getUser().getId().toString(),
// umf.getManga().getTitle(),
// "New chapter available on " +
// mangaProvider.getContentProvider().getName())));
// }
public Manga findMangaByIdThrowIfNotFound(Long mangaId) {
return mangaRepository

1
src/main/resources/application.yml
View File

@ -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}

11
src/main/resources/db/migration/V0001__CREATE_TABLES.sql
View File

@ -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,

2
src/main/resources/db/migration/V0002__CONTENT_PROVIDERS.sql
View File

@ -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);