133 lines
4.8 KiB
Java
133 lines
4.8 KiB
Java
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.UserMangaFollow;
|
|
import com.magamochi.model.repository.*;
|
|
import com.magamochi.queue.MangaChapterDownloadProducer;
|
|
import com.magamochi.user.service.UserService;
|
|
import java.util.stream.Collectors;
|
|
import lombok.RequiredArgsConstructor;
|
|
import lombok.extern.log4j.Log4j2;
|
|
import org.springframework.stereotype.Service;
|
|
import org.springframework.transaction.annotation.Transactional;
|
|
|
|
@Log4j2
|
|
@Service
|
|
@RequiredArgsConstructor
|
|
public class OldMangaService {
|
|
private final UserService userService;
|
|
private final MangaRepository mangaRepository;
|
|
private final MangaContentProviderRepository mangaContentProviderRepository;
|
|
|
|
private final ContentProviderFactory contentProviderFactory;
|
|
|
|
private final UserMangaFollowRepository userMangaFollowRepository;
|
|
|
|
private final MangaChapterDownloadProducer mangaChapterDownloadProducer;
|
|
private final MangaContentRepository mangaContentRepository;
|
|
|
|
private final NtfyClient ntfyClient;
|
|
|
|
public void fetchAllNotDownloadedChapters(Long mangaProviderId) {
|
|
var mangaProvider =
|
|
mangaContentProviderRepository
|
|
.findById(mangaProviderId)
|
|
.orElseThrow(
|
|
() -> new NotFoundException("Manga Provider not found for ID: " + mangaProviderId));
|
|
|
|
var chapterIds =
|
|
mangaProvider.getMangaContents().stream()
|
|
.filter(mangaChapter -> !mangaChapter.getDownloaded())
|
|
.map(MangaContent::getId)
|
|
.collect(Collectors.toSet());
|
|
|
|
chapterIds.forEach(
|
|
chapterId ->
|
|
mangaChapterDownloadProducer.sendMangaChapterDownloadCommand(
|
|
new MangaChapterDownloadCommand(chapterId)));
|
|
}
|
|
|
|
// 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
|
|
.findById(mangaId)
|
|
.orElseThrow(() -> new NotFoundException("Manga not found for ID: " + mangaId));
|
|
}
|
|
|
|
private MangaContentProvider getMangaProviderThrowIfNotFound(Long mangaProviderId) {
|
|
return mangaContentProviderRepository
|
|
.findById(mangaProviderId)
|
|
.orElseThrow(
|
|
() -> new NotFoundException("Manga Provider not found for ID: " + mangaProviderId));
|
|
}
|
|
|
|
@Transactional
|
|
public void follow(Long mangaId) {
|
|
var user = userService.getLoggedUserThrowIfNotFound();
|
|
|
|
var manga = findMangaByIdThrowIfNotFound(mangaId);
|
|
manga.setFollow(true);
|
|
|
|
if (userMangaFollowRepository.existsByUserAndManga(user, manga)) {
|
|
return;
|
|
}
|
|
|
|
userMangaFollowRepository.save(UserMangaFollow.builder().user(user).manga(manga).build());
|
|
}
|
|
|
|
@Transactional
|
|
public void unfollow(Long mangaId) {
|
|
var user = userService.getLoggedUserThrowIfNotFound();
|
|
var manga = findMangaByIdThrowIfNotFound(mangaId);
|
|
|
|
var userMangaFollow = userMangaFollowRepository.findByUserAndManga(user, manga);
|
|
userMangaFollow.ifPresent(userMangaFollowRepository::delete);
|
|
|
|
if (!userMangaFollowRepository.existsByManga(manga)) {
|
|
manga.setFollow(false);
|
|
}
|
|
}
|
|
}
|