colgora/Mangarr
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge pull request 'feat/chapter-entity-image-storage' (#1) from feat/chapter-entity-image-storage into main
All checks were successful
Build and Deploy / deploy (push) Successful in 1m7s
Details

Browse Source 
Reviewed-on: #1
This commit was merged in pull request #1.
This commit is contained in:
colgora
2026-03-09 19:25:22 +01:00
parent dae215dd3d b52b27189d
commit 02760effe6
33 changed files with 550 additions and 558 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
.claude/skills/testing-strategy/SKILL.md
View File

@@ -178,7 +178,6 @@ class InMemoryMangaRepository implements MangaRepositoryInterface
| Adapter | Interface implémentée |
|----------------------------------|------------------------------------------|
| `InMemoryMangaRepository` | `MangaRepositoryInterface` |
| `InMemoryChapterRepository` | `ChapterRepositoryInterface` |
| `InMemoryImageProcessor` | `ImageProcessorInterface` |
| `InMemoryMangadexClient` | `MangadexClientInterface` |
| `InMemoryMangaProvider` | `MangaProviderInterface` |

4
config/services.yaml
View File

@@ -148,10 +148,6 @@ services:
$publicDir: '%kernel.project_dir%/public'
$httpClient: '@GuzzleHttp\Client'
# Chapter Repository
App\Domain\Manga\Domain\Contract\Repository\ChapterRepositoryInterface:
alias: App\Domain\Manga\Infrastructure\Persistence\Repository\LegacyChapterRepository
# File Service
App\Domain\Manga\Domain\Contract\Service\FileServiceInterface:
alias: App\Domain\Manga\Infrastructure\Service\FileService

42
migrations/Version20260309165048.php Normal file
View File

@@ -0,0 +1,42 @@
<?php
declare(strict_types=1);
namespace DoctrineMigrations;
use Doctrine\DBAL\Schema\Schema;
use Doctrine\Migrations\AbstractMigration;
/**
* Auto-generated Migration: Please modify to your needs!
*/
final class Version20260309165048 extends AbstractMigration
{
public function getDescription(): string
{
return '';
}
public function up(Schema $schema): void
{
// this up() migration is auto-generated, please modify it to your needs
$this->addSql('ALTER TABLE chapter ADD pages_directory VARCHAR(255) DEFAULT NULL');
$this->addSql('ALTER TABLE chapter ADD page_count INT DEFAULT 0 NOT NULL');
$this->addSql('DROP INDEX idx_available_at');
$this->addSql('DROP INDEX idx_delivered_at');
$this->addSql('DROP INDEX idx_queue_available');
$this->addSql('DROP INDEX idx_queue_name');
}
public function down(Schema $schema): void
{
// this down() migration is auto-generated, please modify it to your needs
$this->addSql('CREATE SCHEMA public');
$this->addSql('CREATE INDEX idx_available_at ON messenger_messages (available_at)');
$this->addSql('CREATE INDEX idx_delivered_at ON messenger_messages (delivered_at)');
$this->addSql('CREATE INDEX idx_queue_available ON messenger_messages (queue_name, available_at)');
$this->addSql('CREATE INDEX idx_queue_name ON messenger_messages (queue_name)');
$this->addSql('ALTER TABLE chapter DROP pages_directory');
$this->addSql('ALTER TABLE chapter DROP page_count');
}
}

1
phparkitect.php
View File

@@ -23,6 +23,7 @@ return static function (Config $config): void {
'Symfony\Component\HttpKernel\Exception',
'Throwable',
'InvalidArgumentException',
'App\Domain\Shared\Domain\Model\AggregateRoot',
];
// Dépendances externes autorisées

29
src/Domain/Manga/Application/CommandHandler/DeleteCbzHandler.php
View File

@@ -3,19 +3,17 @@
namespace App\Domain\Manga\Application\CommandHandler;
use App\Domain\Manga\Application\Command\DeleteCbz;
use App\Domain\Manga\Domain\Contract\Repository\ChapterRepositoryInterface;
use App\Domain\Manga\Domain\Contract\Repository\MangaRepositoryInterface;
use App\Domain\Manga\Domain\Contract\Service\FileServiceInterface;
use App\Domain\Manga\Domain\Exception\ChapterNotFoundException;
use App\Domain\Manga\Domain\Exception\CbzFileNotFoundException;
use App\Domain\Manga\Domain\Model\Chapter;
use App\Domain\Manga\Domain\Model\ValueObject\ChapterId;
use App\Domain\Shared\Domain\Contract\CommandHandlerInterface;
use App\Domain\Shared\Domain\Contract\CommandInterface;
readonly class DeleteCbzHandler implements CommandHandlerInterface
{
public function __construct(
private ChapterRepositoryInterface $chapterRepository,
private MangaRepositoryInterface $mangaRepository,
private FileServiceInterface $fileService
) {}
@@ -23,33 +21,18 @@ readonly class DeleteCbzHandler implements CommandHandlerInterface
{
assert($command instanceof DeleteCbz);
$chapter = $this->chapterRepository->findVisibleById($command->chapterId);
$chapter = $this->mangaRepository->findVisibleChapterById($command->chapterId);
if (!$chapter) {
throw new ChapterNotFoundException($command->chapterId);
}
// Check if chapter has a CBZ file
if (!$chapter->isAvailable()) {
throw new CbzFileNotFoundException($command->chapterId);
}
// Delete the physical CBZ file
// Note: We'll need to get the CBZ path from somewhere, likely from a legacy repository
// For now, we'll just mark the chapter as not available
// Update chapter to mark CBZ as not available
$updatedChapter = new Chapter(
new ChapterId($chapter->getId()),
$chapter->getMangaId(),
$chapter->getNumber(),
$chapter->getTitle(),
$chapter->getVolume(),
$chapter->isVisible(),
null,
$chapter->getCreatedAt()
);
$this->chapterRepository->save($updatedChapter);
$manga = $this->mangaRepository->findById($chapter->getMangaId()->getValue());
$manga->removeChapterPages($chapter);
$this->mangaRepository->save($manga);
}
}

23
src/Domain/Manga/Application/CommandHandler/DeleteChapterHandler.php
View File

@@ -3,40 +3,29 @@
namespace App\Domain\Manga\Application\CommandHandler;
use App\Domain\Manga\Application\Command\DeleteChapter;
use App\Domain\Manga\Domain\Contract\Repository\ChapterRepositoryInterface;
use App\Domain\Manga\Domain\Contract\Repository\MangaRepositoryInterface;
use App\Domain\Manga\Domain\Exception\ChapterNotFoundException;
use App\Domain\Manga\Domain\Model\Chapter;
use App\Domain\Manga\Domain\Model\ValueObject\ChapterId;
use App\Domain\Shared\Domain\Contract\CommandHandlerInterface;
use App\Domain\Shared\Domain\Contract\CommandInterface;
readonly class DeleteChapterHandler implements CommandHandlerInterface
{
public function __construct(
private ChapterRepositoryInterface $chapterRepository
private MangaRepositoryInterface $mangaRepository
) {}
public function handle(CommandInterface $command): void
{
assert($command instanceof DeleteChapter);
$chapter = $this->chapterRepository->findVisibleById($command->chapterId);
$chapter = $this->mangaRepository->findVisibleChapterById($command->chapterId);
if (!$chapter) {
throw new ChapterNotFoundException($command->chapterId);
}
$updatedChapter = new Chapter(
id: new ChapterId($chapter->getId()),
mangaId: $chapter->getMangaId(),
number: $chapter->getNumber(),
title: $chapter->getTitle(),
volume: $chapter->getVolume(),
isVisible: false,
cbzPath: $chapter->getCbzPath(),
createdAt: $chapter->getCreatedAt()
);
$this->chapterRepository->save($updatedChapter);
$manga = $this->mangaRepository->findById($chapter->getMangaId()->getValue());
$manga->hideChapter($chapter);
$this->mangaRepository->save($manga);
}
}

14
src/Domain/Manga/Application/CommandHandler/EditMultipleChaptersHandler.php
View File

@@ -3,35 +3,35 @@
namespace App\Domain\Manga\Application\CommandHandler;
use App\Domain\Manga\Application\Command\EditMultipleChapters;
use App\Domain\Manga\Domain\Contract\Repository\ChapterRepositoryInterface;
use App\Domain\Manga\Domain\Contract\Repository\MangaRepositoryInterface;
use App\Domain\Manga\Domain\Exception\ChapterNotFoundException;
readonly class EditMultipleChaptersHandler
{
public function __construct(
private ChapterRepositoryInterface $chapterRepository
private MangaRepositoryInterface $mangaRepository
) {}
public function handle(EditMultipleChapters $command): void
{
foreach ($command->chapters as $chapterData) {
$chapter = $this->chapterRepository->findById($chapterData->id);
$chapter = $this->mangaRepository->findChapterById($chapterData->id);
if (!$chapter) {
throw new ChapterNotFoundException($chapterData->id);
}
$updatedChapter = $chapter;
$manga = $this->mangaRepository->findById($chapter->getMangaId()->getValue());
if ($chapterData->title !== null) {
$updatedChapter = $updatedChapter->updateTitle($chapterData->title);
$manga->updateChapterTitle($chapter, $chapterData->title);
}
if ($chapterData->volume !== null) {
$updatedChapter = $updatedChapter->updateVolume($chapterData->volume);
$manga->updateChapterVolume($chapter, $chapterData->volume);
}
$this->chapterRepository->save($updatedChapter);
$this->mangaRepository->save($manga);
}
}
}

1
src/Domain/Manga/Application/CommandHandler/FetchMangaChaptersHandler.php
View File

@@ -29,5 +29,6 @@ readonly class FetchMangaChaptersHandler
// Synchronisation initiale (pas d'événements)
$this->chapterSynchronizationService->synchronizeChapters($manga);
$this->mangaRepository->save($manga);
}
}

33
src/Domain/Manga/Application/CommandHandler/ImportChapterHandler.php
View File

@@ -3,20 +3,15 @@
namespace App\Domain\Manga\Application\CommandHandler;
use App\Domain\Manga\Application\Command\ImportChapter;
use App\Domain\Manga\Domain\Contract\Repository\ChapterRepositoryInterface;
use App\Domain\Manga\Domain\Contract\Repository\MangaRepositoryInterface;
use App\Domain\Manga\Domain\Exception\MangaNotFoundException;
use App\Domain\Manga\Domain\Exception\ChapterNotFoundException;
use App\Domain\Manga\Domain\Model\Chapter;
use App\Domain\Manga\Domain\Model\ValueObject\ChapterId;
use App\Domain\Shared\Domain\Contract\MangaPathManagerInterface;
use Ramsey\Uuid\Uuid;
readonly class ImportChapterHandler
{
public function __construct(
private MangaRepositoryInterface $mangaRepository,
private ChapterRepositoryInterface $chapterRepository,
private MangaPathManagerInterface $pathManager
) {}
@@ -34,7 +29,7 @@ readonly class ImportChapterHandler
}
// 3. Check if chapter exists
$existingChapter = $this->chapterRepository->findByMangaIdAndChapterNumber(
$existingChapter = $this->mangaRepository->findChapterByMangaIdAndNumber(
$command->mangaId,
$command->chapterNumber
);
@@ -46,37 +41,20 @@ readonly class ImportChapterHandler
// 4. Save the CBZ file to storage using the path manager
$cbzPath = $this->saveCbzFile($command, $manga, $existingChapter);
// 5. Update existing chapter with new CBZ path
$updatedChapter = new Chapter(
id: new ChapterId($existingChapter->getId()),
mangaId: $existingChapter->getMangaId(),
number: $existingChapter->getNumber(),
title: $existingChapter->getTitle(),
volume: $existingChapter->getVolume(),
isVisible: $existingChapter->isVisible(),
cbzPath: $cbzPath,
createdAt: $existingChapter->getCreatedAt()
);
$this->chapterRepository->save($updatedChapter);
// 5. Update existing chapter with new path through the aggregate
$manga->updateChapterPages($existingChapter, $cbzPath, $existingChapter->getPageCount());
$this->mangaRepository->save($manga);
}
/**
* Validate that the binary data is a valid CBZ (ZIP) file
*/
private function isValidCbzFile(string $fileBinary): bool
{
// CBZ files are ZIP archives, check for ZIP magic number
$zipMagicNumber = "\x50\x4b\x03\x04"; // PK\x03\x04
return strpos($fileBinary, $zipMagicNumber) === 0;
}
/**
* Save the CBZ file to storage and return the path
*/
private function saveCbzFile(ImportChapter $command, \App\Domain\Manga\Domain\Model\Manga $manga, Chapter $chapter): string
private function saveCbzFile(ImportChapter $command, \App\Domain\Manga\Domain\Model\Manga $manga, \App\Domain\Manga\Domain\Model\Chapter $chapter): string
{
// Build the final CBZ path using the path manager (creates directories)
$volumeNumber = $chapter->getVolume() ?? 0;
$cbzPath = $this->pathManager->buildChapterCbzPath(
$manga->getTitle()->getValue(),
@@ -85,7 +63,6 @@ readonly class ImportChapterHandler
(string)$command->chapterNumber
);
// Write the binary content directly to the CBZ path
if (!file_put_contents($cbzPath, $command->fileBinary)) {
throw new \RuntimeException('Failed to save CBZ file');
}

34
src/Domain/Manga/Application/CommandHandler/ImportVolumeHandler.php
View File

@@ -3,18 +3,14 @@
namespace App\Domain\Manga\Application\CommandHandler;
use App\Domain\Manga\Application\Command\ImportVolume;
use App\Domain\Manga\Domain\Contract\Repository\ChapterRepositoryInterface;
use App\Domain\Manga\Domain\Contract\Repository\MangaRepositoryInterface;
use App\Domain\Manga\Domain\Exception\MangaNotFoundException;
use App\Domain\Manga\Domain\Model\Chapter;
use App\Domain\Manga\Domain\Model\ValueObject\ChapterId;
use App\Domain\Shared\Domain\Contract\MangaPathManagerInterface;
readonly class ImportVolumeHandler
{
public function __construct(
private MangaRepositoryInterface $mangaRepository,
private ChapterRepositoryInterface $chapterRepository,
private MangaPathManagerInterface $pathManager
) {}
@@ -32,7 +28,7 @@ readonly class ImportVolumeHandler
}
// 3. Get all chapters for this volume
$chapters = $this->chapterRepository->findByMangaIdAndVolume(
$chapters = $this->mangaRepository->findChaptersByMangaIdAndVolume(
$command->mangaId,
$command->volumeNumber
);
@@ -46,46 +42,28 @@ readonly class ImportVolumeHandler
// 4. Save the CBZ file to storage using the path manager
$cbzPath = $this->saveCbzFile($command, $manga);
// 5. Update all chapters with the volume CBZ path
// 5. Update all chapters with the volume path through the aggregate
foreach ($chapters as $chapter) {
$updatedChapter = new Chapter(
id: new ChapterId($chapter->getId()),
mangaId: $chapter->getMangaId(),
number: $chapter->getNumber(),
title: $chapter->getTitle(),
volume: $chapter->getVolume(),
isVisible: $chapter->isVisible(),
cbzPath: $cbzPath,
createdAt: $chapter->getCreatedAt()
);
$this->chapterRepository->save($updatedChapter);
$manga->updateChapterPages($chapter, $cbzPath, $chapter->getPageCount());
}
$this->mangaRepository->save($manga);
}
/**
* Validate that the binary data is a valid CBZ (ZIP) file
*/
private function isValidCbzFile(string $fileBinary): bool
{
// CBZ files are ZIP archives, check for ZIP magic number
$zipMagicNumber = "\x50\x4b\x03\x04"; // PK\x03\x04
return strpos($fileBinary, $zipMagicNumber) === 0;
}
/**
* Save the CBZ file to storage and return the path
*/
private function saveCbzFile(ImportVolume $command, \App\Domain\Manga\Domain\Model\Manga $manga): string
{
// Build the final CBZ path using the path manager (creates directories)
$cbzPath = $this->pathManager->buildVolumeCbzPath(
$manga->getTitle()->getValue(),
(string)$manga->getPublicationYear(),
$command->volumeNumber
);
// Write the binary content directly to the CBZ path
if (!file_put_contents($cbzPath, $command->fileBinary)) {
throw new \RuntimeException('Failed to save CBZ file');
}
@@ -93,7 +71,3 @@ readonly class ImportVolumeHandler
return $cbzPath;
}
}

23
src/Domain/Manga/Application/EventListener/ChapterImportedEventListener.php
View File

@@ -4,10 +4,7 @@ declare(strict_types=1);
namespace App\Domain\Manga\Application\EventListener;
use App\Domain\Manga\Domain\Contract\Repository\ChapterRepositoryInterface;
use App\Domain\Manga\Domain\Contract\Repository\MangaRepositoryInterface;
use App\Domain\Manga\Domain\Model\Chapter;
use App\Domain\Manga\Domain\Model\ValueObject\ChapterId;
use App\Domain\Manga\Domain\Model\ValueObject\MangaSlug;
use App\Domain\Shared\Domain\Event\ChapterImported;
@@ -15,34 +12,22 @@ readonly class ChapterImportedEventListener
{
public function __construct(
private MangaRepositoryInterface $mangaRepository,
private ChapterRepositoryInterface $chapterRepository,
) {}
public function __invoke(ChapterImported $event): void
{
$manga = $this->mangaRepository->findBySlug(new MangaSlug($event->mangaSlug));
if (!$manga) {
return; // Manga introuvable, on ignore
return;
}
$chapters = $this->chapterRepository->findVisibleByMangaIdAndVolume($manga->getId()->getValue(), (int) $event->volume);
$chapters = $this->mangaRepository->findVisibleChaptersByMangaIdAndVolume($manga->getId()->getValue(), (int) $event->volume);
foreach ($chapters as $chapter) {
if ($chapter->getNumber() === (float) $event->chapterNumber) {
$updated = new Chapter(
new ChapterId($chapter->getId()),
$chapter->getMangaId(),
$chapter->getNumber(),
$chapter->getTitle(),
$chapter->getVolume(),
$chapter->isVisible(),
$event->cbzPath,
$chapter->getCreatedAt(),
);
$this->chapterRepository->save($updated);
$manga->updateChapterPages($chapter, $event->cbzPath, $chapter->getPageCount());
$this->mangaRepository->save($manga);
break;
}
}
}
}

21
src/Domain/Manga/Application/EventListener/VolumeImportedEventListener.php
View File

@@ -4,10 +4,7 @@ declare(strict_types=1);
namespace App\Domain\Manga\Application\EventListener;
use App\Domain\Manga\Domain\Contract\Repository\ChapterRepositoryInterface;
use App\Domain\Manga\Domain\Contract\Repository\MangaRepositoryInterface;
use App\Domain\Manga\Domain\Model\Chapter;
use App\Domain\Manga\Domain\Model\ValueObject\ChapterId;
use App\Domain\Manga\Domain\Model\ValueObject\MangaSlug;
use App\Domain\Shared\Domain\Event\VolumeImported;
@@ -15,7 +12,6 @@ readonly class VolumeImportedEventListener
{
public function __construct(
private MangaRepositoryInterface $mangaRepository,
private ChapterRepositoryInterface $chapterRepository,
) {}
public function __invoke(VolumeImported $event): void
@@ -25,25 +21,14 @@ readonly class VolumeImportedEventListener
return;
}
$chapters = $this->chapterRepository->findByMangaIdAndVolume($manga->getId()->getValue(), (int) $event->volume);
$chapters = $this->mangaRepository->findChaptersByMangaIdAndVolume($manga->getId()->getValue(), (int) $event->volume);
if ($chapters === []) {
return;
}
foreach ($chapters as $chapter) {
$updated = new Chapter(
new ChapterId($chapter->getId()),
$chapter->getMangaId(),
$chapter->getNumber(),
$chapter->getTitle(),
$chapter->getVolume(),
$chapter->isVisible(),
$event->cbzPath,
$chapter->getCreatedAt(),
);
$this->chapterRepository->save($updated);
$manga->updateChapterPages($chapter, $event->cbzPath, $chapter->getPageCount());
}
$this->mangaRepository->save($manga);
}
}

15
src/Domain/Manga/Application/QueryHandler/DownloadCbzHandler.php
View File

@@ -4,7 +4,7 @@ namespace App\Domain\Manga\Application\QueryHandler;
use App\Domain\Manga\Application\Query\DownloadCbz;
use App\Domain\Manga\Application\Response\DownloadResponse;
use App\Domain\Manga\Domain\Contract\Repository\ChapterRepositoryInterface;
use App\Domain\Manga\Domain\Contract\Repository\MangaRepositoryInterface;
use App\Domain\Manga\Domain\Contract\Service\FileServiceInterface;
use App\Domain\Manga\Domain\Exception\CbzFileNotFoundException;
use App\Domain\Manga\Domain\Exception\ChapterNotFoundException;
@@ -16,7 +16,7 @@ use App\Domain\Shared\Domain\Contract\ResponseInterface;
readonly class DownloadCbzHandler implements QueryHandlerInterface
{
public function __construct(
private ChapterRepositoryInterface $chapterRepository,
private MangaRepositoryInterface $mangaRepository,
private FileServiceInterface $fileService
) {}
@@ -24,7 +24,7 @@ readonly class DownloadCbzHandler implements QueryHandlerInterface
{
assert($query instanceof DownloadCbz);
$chapter = $this->chapterRepository->findVisibleById($query->chapterId);
$chapter = $this->mangaRepository->findVisibleChapterById($query->chapterId);
if (!$chapter) {
throw new ChapterNotFoundException($query->chapterId);
@@ -34,14 +34,11 @@ readonly class DownloadCbzHandler implements QueryHandlerInterface
throw new ChapterNotAvailableException($query->chapterId);
}
// Use the actual CBZ path from the chapter
$cbzPath = $chapter->getCbzPath();
// Extract the existing filename from the path
$filename = basename($cbzPath);
$pagesDirectory = $chapter->getPagesDirectory();
$filename = basename($pagesDirectory);
try {
$httpResponse = $this->fileService->downloadCbz($cbzPath, $filename);
$httpResponse = $this->fileService->downloadCbz($pagesDirectory, $filename);
} catch (CbzFileNotFoundException $e) {
throw new ChapterNotAvailableException($query->chapterId);
}

7
src/Domain/Manga/Application/QueryHandler/DownloadVolumeHandler.php
View File

@@ -4,7 +4,6 @@ namespace App\Domain\Manga\Application\QueryHandler;
use App\Domain\Manga\Application\Query\DownloadVolume;
use App\Domain\Manga\Application\Response\DownloadResponse;
use App\Domain\Manga\Domain\Contract\Repository\ChapterRepositoryInterface;
use App\Domain\Manga\Domain\Contract\Repository\MangaRepositoryInterface;
use App\Domain\Manga\Domain\Contract\Service\FileServiceInterface;
use App\Domain\Manga\Domain\Exception\MangaNotFoundException;
@@ -16,7 +15,6 @@ use App\Domain\Shared\Domain\Contract\ResponseInterface;
readonly class DownloadVolumeHandler implements QueryHandlerInterface
{
public function __construct(
private ChapterRepositoryInterface $chapterRepository,
private MangaRepositoryInterface $mangaRepository,
private FileServiceInterface $fileService
) {}
@@ -31,7 +29,7 @@ readonly class DownloadVolumeHandler implements QueryHandlerInterface
throw new MangaNotFoundException($query->mangaId);
}
$chapters = $this->chapterRepository->findVisibleWithCbzByMangaIdAndVolume(
$chapters = $this->mangaRepository->findVisibleChaptersWithPagesByMangaIdAndVolume(
$query->mangaId,
$query->volume
);
@@ -40,10 +38,9 @@ readonly class DownloadVolumeHandler implements QueryHandlerInterface
throw new VolumeNotFoundException($query->mangaId, $query->volume);
}
// Collect CBZ paths for all chapters
$cbzPaths = [];
foreach ($chapters as $chapter) {
$cbzPaths[] = $chapter->getCbzPath();
$cbzPaths[] = $chapter->getPagesDirectory();
}
$volumeName = sprintf('%s_vol%d',

4
src/Domain/Manga/Application/QueryHandler/GetMangaChaptersHandler.php
View File

@@ -38,8 +38,8 @@ readonly class GetMangaChaptersHandler
title: $chapter->getTitle(),
volume: $chapter->getVolume(),
isVisible: $chapter->isVisible(),
cbzPath: $chapter->getCbzPath(),
createdAt: $chapter->getCreatedAt()
pagesDirectory: $chapter->getPagesDirectory(),
createdAt: $chapter->getCreatedAt()->format(\DateTimeInterface::RFC3339)
),
$chapters
),

4
src/Domain/Manga/Application/Response/ChapterResponse.php
View File

@@ -10,7 +10,7 @@ readonly class ChapterResponse
public ?string $title,
public ?int $volume,
public bool $isVisible,
public ?string $cbzPath,
public \DateTimeImmutable $createdAt
public ?string $pagesDirectory,
public string $createdAt
) {}
}

29
src/Domain/Manga/Domain/Contract/Repository/ChapterRepositoryInterface.php
View File

@@ -1,29 +0,0 @@
<?php
namespace App\Domain\Manga\Domain\Contract\Repository;
use App\Domain\Manga\Domain\Model\Chapter;
interface ChapterRepositoryInterface
{
public function findById(string $id): ?Chapter;
public function findVisibleById(string $id): ?Chapter;
public function findByMangaIdAndChapterNumber(string $mangaId, float $chapterNumber): ?Chapter;
public function save(Chapter $chapter): void;
public function delete(Chapter $chapter): void;
/**
* @return Chapter[]
*/
public function findByMangaIdAndVolume(string $mangaId, int $volume): array;
/**
* @return Chapter[]
*/
public function findVisibleByMangaIdAndVolume(string $mangaId, int $volume): array;
/**
* @return Chapter[]
*/
public function findVisibleWithCbzByMangaIdAndVolume(string $mangaId, int $volume): array;
}

39
src/Domain/Manga/Domain/Contract/Repository/MangaRepositoryInterface.php
View File

@@ -6,23 +6,35 @@ use App\Domain\Manga\Application\Query\MonitoringCriteria;
use App\Domain\Manga\Domain\Model\Manga;
use App\Domain\Manga\Domain\Model\Chapter;
use App\Domain\Manga\Domain\Model\ValueObject\ExternalId;
use App\Domain\Manga\Domain\Model\ValueObject\ChapterId;
use App\Domain\Manga\Domain\Model\ValueObject\MangaSlug;
interface MangaRepositoryInterface
{
// --- Manga ---
public function findAll(int $page = 1, int $limit = 20, string $sortBy = 'title', string $sortOrder = 'asc'): array;
public function count(): int;
public function findById(string $id): ?Manga;
public function findBySlug(MangaSlug $slug): ?Manga;
public function findByExternalId(ExternalId $externalId): ?Manga;
public function save(Manga $manga): void;
public function delete(Manga $manga): void;
public function findChapters(string $mangaId, int $page = 1, int $limit = 20, string $sortOrder = 'desc'): array;
public function countChapters(string $mangaId): int;
public function findByExternalId(ExternalId $externalId): ?Manga;
public function saveChapter(Chapter $chapter): ChapterId;
public function findBySlug(MangaSlug $slug): ?Manga;
public function search(string $query, int $page = 1, int $limit = 20): array;
public function countSearch(string $query): int;
/**
* @return Manga[]
*/
public function findByMonitoringCriteria(MonitoringCriteria $criteria): array;
// --- Chapters (read) ---
public function findChapters(string $mangaId, int $page = 1, int $limit = 20, string $sortOrder = 'desc'): array;
public function countChapters(string $mangaId): int;
public function findChapterById(string $id): ?Chapter;
public function findVisibleChapterById(string $id): ?Chapter;
public function findChapterByMangaIdAndNumber(string $mangaId, float $chapterNumber): ?Chapter;
/**
* @param float[] $chapterNumbers
* @return array<float, Chapter>
@@ -30,7 +42,18 @@ interface MangaRepositoryInterface
public function findExistingChaptersByNumbers(string $mangaId, array $chapterNumbers): array;
/**
* @return Manga[]
* @return Chapter[]
*/
public function findByMonitoringCriteria(MonitoringCriteria $criteria): array;
public function findChaptersByMangaIdAndVolume(string $mangaId, int $volume): array;
/**
* @return Chapter[]
*/
public function findVisibleChaptersByMangaIdAndVolume(string $mangaId, int $volume): array;
/**
* @return Chapter[]
*/
public function findVisibleChaptersWithPagesByMangaIdAndVolume(string $mangaId, int $volume): array;
}

58
src/Domain/Manga/Domain/Model/Chapter.php
View File

@@ -3,17 +3,19 @@
namespace App\Domain\Manga\Domain\Model;
use App\Domain\Manga\Domain\Model\ValueObject\ChapterId;
use App\Domain\Manga\Domain\Model\ValueObject\MangaId;
readonly class Chapter
class Chapter
{
public function __construct(
private ChapterId $id,
private string $mangaId,
private MangaId $mangaId,
private float $number,
private ?string $title,
private ?int $volume,
private bool $isVisible,
private ?string $cbzPath = null,
private ?string $pagesDirectory = null,
private int $pageCount = 0,
private \DateTimeImmutable $createdAt = new \DateTimeImmutable()
) {}
@@ -22,7 +24,7 @@ readonly class Chapter
return $this->id->getValue();
}
public function getMangaId(): string
public function getMangaId(): MangaId
{
return $this->mangaId;
}
@@ -49,12 +51,17 @@ readonly class Chapter
public function isAvailable(): bool
{
return $this->cbzPath !== null;
return $this->pagesDirectory !== null;
}
public function getCbzPath(): ?string
public function getPagesDirectory(): ?string
{
return $this->cbzPath;
return $this->pagesDirectory;
}
public function getPageCount(): int
{
return $this->pageCount;
}
public function getCreatedAt(): \DateTimeImmutable
@@ -62,31 +69,24 @@ readonly class Chapter
return $this->createdAt;
}
public function updateTitle(?string $title): self
public function updateTitle(?string $title): void
{
return new self(
$this->id,
$this->mangaId,
$this->number,
$title,
$this->volume,
$this->isVisible,
$this->cbzPath,
$this->createdAt
);
$this->title = $title;
}
public function updateVolume(?int $volume): self
public function updateVolume(?int $volume): void
{
return new self(
$this->id,
$this->mangaId,
$this->number,
$this->title,
$volume,
$this->isVisible,
$this->cbzPath,
$this->createdAt
);
$this->volume = $volume;
}
public function updatePagesDirectory(?string $pagesDirectory, int $pageCount = 0): void
{
$this->pagesDirectory = $pagesDirectory;
$this->pageCount = $pageCount;
}
public function hide(): void
{
$this->isVisible = false;
}
}

74
src/Domain/Manga/Domain/Model/Manga.php
View File

@@ -8,10 +8,20 @@ use App\Domain\Manga\Domain\Model\ValueObject\MangaId;
use App\Domain\Manga\Domain\Model\ValueObject\MangaSlug;
use App\Domain\Manga\Domain\Model\ValueObject\MangaTitle;
use App\Domain\Manga\Domain\Model\ValueObject\MonitoringStatus;
use App\Domain\Shared\Domain\Model\AggregateRoot;
use DateTimeImmutable;
final class Manga
final class Manga extends AggregateRoot
{
/** @var Chapter[] */
private array $newChapters = [];
/** @var array<string, Chapter> */
private array $modifiedChapters = [];
/** @var Chapter[] */
private array $chaptersToDelete = [];
public function __construct(
private MangaId $id,
private MangaTitle $title,
@@ -189,4 +199,66 @@ final class Manga
{
$this->lastMonitoringCheck = $lastMonitoringCheck;
}
public function addChapter(Chapter $chapter): void
{
$this->newChapters[] = $chapter;
}
public function updateChapterTitle(Chapter $chapter, ?string $title): void
{
$chapter->updateTitle($title);
$this->modifiedChapters[$chapter->getId()] = $chapter;
}
public function updateChapterVolume(Chapter $chapter, ?int $volume): void
{
$chapter->updateVolume($volume);
$this->modifiedChapters[$chapter->getId()] = $chapter;
}
public function updateChapterPages(Chapter $chapter, ?string $pagesDirectory, int $pageCount = 0): void
{
$chapter->updatePagesDirectory($pagesDirectory, $pageCount);
$this->modifiedChapters[$chapter->getId()] = $chapter;
}
public function hideChapter(Chapter $chapter): void
{
$chapter->hide();
$this->modifiedChapters[$chapter->getId()] = $chapter;
}
public function removeChapterPages(Chapter $chapter): void
{
$chapter->updatePagesDirectory(null, 0);
$this->modifiedChapters[$chapter->getId()] = $chapter;
}
/** @return Chapter[] */
public function pullNewChapters(): array
{
$chapters = $this->newChapters;
$this->newChapters = [];
return $chapters;
}
/** @return Chapter[] */
public function pullModifiedChapters(): array
{
$chapters = array_values($this->modifiedChapters);
$this->modifiedChapters = [];
return $chapters;
}
/** @return Chapter[] */
public function pullChaptersToDelete(): array
{
$chapters = $this->chaptersToDelete;
$this->chaptersToDelete = [];
return $chapters;
}
}

6
src/Domain/Manga/Infrastructure/ApiPlatform/State/Provider/DeleteCbzProvider.php
View File

@@ -4,7 +4,7 @@ namespace App\Domain\Manga\Infrastructure\ApiPlatform\State\Provider;
use ApiPlatform\Metadata\Operation;
use ApiPlatform\State\ProviderInterface;
use App\Domain\Manga\Domain\Contract\Repository\ChapterRepositoryInterface;
use App\Domain\Manga\Domain\Contract\Repository\MangaRepositoryInterface;
use App\Domain\Manga\Domain\Exception\ChapterNotFoundException;
use App\Domain\Manga\Domain\Exception\CbzFileNotFoundException;
use App\Domain\Manga\Infrastructure\ApiPlatform\Resource\DeleteCbzResource;
@@ -13,7 +13,7 @@ use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
readonly class DeleteCbzProvider implements ProviderInterface
{
public function __construct(
private ChapterRepositoryInterface $chapterRepository
private MangaRepositoryInterface $mangaRepository
) {}
public function provide(Operation $operation, array $uriVariables = [], array $context = []): DeleteCbzResource
@@ -25,7 +25,7 @@ readonly class DeleteCbzProvider implements ProviderInterface
$chapterId = $uriVariables['id'];
try {
$chapter = $this->chapterRepository->findVisibleById($chapterId);
$chapter = $this->mangaRepository->findVisibleChapterById($chapterId);
if (!$chapter) {
throw new ChapterNotFoundException($chapterId);

6
src/Domain/Manga/Infrastructure/ApiPlatform/State/Provider/DeleteChapterProvider.php
View File

@@ -4,7 +4,7 @@ namespace App\Domain\Manga\Infrastructure\ApiPlatform\State\Provider;
use ApiPlatform\Metadata\Operation;
use ApiPlatform\State\ProviderInterface;
use App\Domain\Manga\Domain\Contract\Repository\ChapterRepositoryInterface;
use App\Domain\Manga\Domain\Contract\Repository\MangaRepositoryInterface;
use App\Domain\Manga\Domain\Exception\ChapterNotFoundException;
use App\Domain\Manga\Infrastructure\ApiPlatform\Resource\DeleteChapterResource;
use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
@@ -12,7 +12,7 @@ use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
readonly class DeleteChapterProvider implements ProviderInterface
{
public function __construct(
private ChapterRepositoryInterface $chapterRepository
private MangaRepositoryInterface $mangaRepository
) {}
public function provide(Operation $operation, array $uriVariables = [], array $context = []): DeleteChapterResource
@@ -24,7 +24,7 @@ readonly class DeleteChapterProvider implements ProviderInterface
$chapterId = $uriVariables['id'];
try {
$chapter = $this->chapterRepository->findVisibleById($chapterId);
$chapter = $this->mangaRepository->findVisibleChapterById($chapterId);
if (!$chapter) {
throw new ChapterNotFoundException($chapterId);

4
src/Domain/Manga/Infrastructure/ApiPlatform/State/Provider/GetMangaChaptersStateProvider.php
View File

@@ -52,8 +52,8 @@ readonly class GetMangaChaptersStateProvider implements ProviderInterface
title: $chapter->title,
volume: $chapter->volume,
isVisible: $chapter->isVisible,
isAvailable: $chapter->cbzPath !== null,
createdAt: $chapter->createdAt->format(\DateTimeInterface::RFC3339)
isAvailable: $chapter->pagesDirectory !== null,
createdAt: $chapter->createdAt
);
}
}

122
src/Domain/Manga/Infrastructure/Persistence/LegacyMangaRepository.php
View File

@@ -115,6 +115,44 @@ readonly class LegacyMangaRepository implements MangaRepositoryInterface
if ($entity->getId()) {
$manga->updateId(new MangaId((string) $entity->getId()));
}
// Handle new chapters added through the aggregate
foreach ($manga->pullNewChapters() as $chapter) {
$mangaEntity = $this->entityManager->find(EntityManga::class, (int) $manga->getId()->getValue());
$chapterEntity = new EntityChapter();
$chapterEntity->setManga($mangaEntity)
->setNumber($chapter->getNumber())
->setTitle($chapter->getTitle())
->setVolume($chapter->getVolume())
->setVisible($chapter->isVisible())
->setPagesDirectory($chapter->getPagesDirectory())
->setPageCount($chapter->getPageCount());
$this->entityManager->persist($chapterEntity);
}
// Handle chapters modified through the aggregate
foreach ($manga->pullModifiedChapters() as $chapter) {
$chapterEntity = $this->entityManager->find(EntityChapter::class, $chapter->getId());
if ($chapterEntity) {
$chapterEntity->setVisible($chapter->isVisible())
->setPagesDirectory($chapter->getPagesDirectory())
->setPageCount($chapter->getPageCount())
->setTitle($chapter->getTitle())
->setVolume($chapter->getVolume())
->setCbzPath($chapter->getPagesDirectory());
$this->entityManager->persist($chapterEntity);
}
}
// Handle chapters deleted through the aggregate
foreach ($manga->pullChaptersToDelete() as $chapter) {
$chapterEntity = $this->entityManager->find(EntityChapter::class, $chapter->getId());
if ($chapterEntity) {
$this->entityManager->remove($chapterEntity);
}
}
$this->entityManager->flush();
}
public function delete(DomainManga $manga): void
@@ -166,25 +204,75 @@ readonly class LegacyMangaRepository implements MangaRepositoryInterface
return $entity ? $this->toDomain($entity) : null;
}
public function saveChapter(Chapter $chapter): ChapterId
public function findChapterById(string $id): ?Chapter
{
$manga = $this->entityManager->find(EntityManga::class, $chapter->getMangaId());
$entity = $this->entityManager->find(EntityChapter::class, $id);
if (!$manga) {
throw new \RuntimeException('Manga not found');
}
return $entity ? $this->toChapterDomain($entity) : null;
}
$entity = new EntityChapter();
$entity->setManga($manga)
->setNumber($chapter->getNumber())
->setTitle($chapter->getTitle())
->setVolume($chapter->getVolume())
->setVisible($chapter->isVisible());
public function findVisibleChapterById(string $id): ?Chapter
{
$entity = $this->entityManager->createQueryBuilder()
->select('c')
->from(EntityChapter::class, 'c')
->where('c.id = :id')
->andWhere('c.visible = :visible')
->setParameter('id', $id)
->setParameter('visible', 1)
->getQuery()
->getOneOrNullResult();
$this->entityManager->persist($entity);
$this->entityManager->flush();
return $entity ? $this->toChapterDomain($entity) : null;
}
return new ChapterId((string) $entity->getId());
public function findChapterByMangaIdAndNumber(string $mangaId, float $chapterNumber): ?Chapter
{
$entity = $this->entityManager->createQueryBuilder()
->select('c')
->from(EntityChapter::class, 'c')
->where('c.manga = :mangaId')
->andWhere('c.number = :chapterNumber')
->setParameter('mangaId', $mangaId)
->setParameter('chapterNumber', $chapterNumber)
->getQuery()
->getOneOrNullResult();
return $entity ? $this->toChapterDomain($entity) : null;
}
public function findChaptersByMangaIdAndVolume(string $mangaId, int $volume): array
{
$entities = $this->entityManager->getRepository(EntityChapter::class)
->findBy(['manga' => $mangaId, 'volume' => $volume]);
return array_map([$this, 'toChapterDomain'], $entities);
}
public function findVisibleChaptersByMangaIdAndVolume(string $mangaId, int $volume): array
{
$entities = $this->entityManager->getRepository(EntityChapter::class)
->findBy(['manga' => $mangaId, 'volume' => $volume, 'visible' => true]);
return array_map([$this, 'toChapterDomain'], $entities);
}
public function findVisibleChaptersWithPagesByMangaIdAndVolume(string $mangaId, int $volume): array
{
$entities = $this->entityManager->createQueryBuilder()
->select('c')
->from(EntityChapter::class, 'c')
->where('c.manga = :mangaId')
->andWhere('c.volume = :volume')
->andWhere('c.visible = true')
->andWhere('c.pagesDirectory IS NOT NULL OR c.cbzPath IS NOT NULL')
->setParameter('mangaId', $mangaId)
->setParameter('volume', $volume)
->orderBy('c.number', 'ASC')
->getQuery()
->getResult();
return array_map([$this, 'toChapterDomain'], $entities);
}
public function search(string $query, int $page = 1, int $limit = 20): array
@@ -314,12 +402,14 @@ readonly class LegacyMangaRepository implements MangaRepositoryInterface
{
return new Chapter(
id: new ChapterId((string) $entity->getId()),
mangaId: $entity->getManga()->getId(),
mangaId: new MangaId((string) $entity->getManga()->getId()),
number: $entity->getNumber(),
title: $entity->getTitle(),
volume: $entity->getVolume(),
isVisible: $entity->isVisible(),
cbzPath: $entity->getCbzPath()
// Fallback to cbzPath during transition (Phase 4 will drop cbzPath column)
pagesDirectory: $entity->getPagesDirectory() ?? $entity->getCbzPath(),
pageCount: $entity->getPageCount(),
);
}
}

128
src/Domain/Manga/Infrastructure/Persistence/Repository/LegacyChapterRepository.php
View File

@@ -1,128 +0,0 @@
<?php
namespace App\Domain\Manga\Infrastructure\Persistence\Repository;
use App\Domain\Manga\Domain\Contract\Repository\ChapterRepositoryInterface;
use App\Domain\Manga\Domain\Model\Chapter;
use App\Domain\Manga\Domain\Model\ValueObject\ChapterId;
use App\Entity\Chapter as ChapterEntity;
use Doctrine\ORM\EntityManagerInterface;
readonly class LegacyChapterRepository implements ChapterRepositoryInterface
{
public function __construct(
private EntityManagerInterface $entityManager
) {}
public function findById(string $id): ?Chapter
{
$entity = $this->entityManager->find(ChapterEntity::class, $id);
return $entity ? $this->toDomainModel($entity) : null;
}
public function findVisibleById(string $id): ?Chapter
{
$qb = $this->entityManager->createQueryBuilder()
->select('c')
->from(ChapterEntity::class, 'c')
->where('c.id = :id')
->andWhere('c.visible = :visible')
->setParameter('id', $id)
->setParameter('visible', 1);
$entity = $qb->getQuery()->getOneOrNullResult();
return $entity ? $this->toDomainModel($entity) : null;
}
public function findByMangaIdAndChapterNumber(string $mangaId, float $chapterNumber): ?Chapter
{
$qb = $this->entityManager->createQueryBuilder()
->select('c')
->from(ChapterEntity::class, 'c')
->where('c.manga = :mangaId')
->andWhere('c.number = :chapterNumber')
->setParameter('mangaId', $mangaId)
->setParameter('chapterNumber', $chapterNumber);
$entity = $qb->getQuery()->getOneOrNullResult();
return $entity ? $this->toDomainModel($entity) : null;
}
public function save(Chapter $chapter): void
{
$entity = $this->entityManager->find(ChapterEntity::class, $chapter->getId());
if (!$entity) {
throw new \RuntimeException(sprintf('Chapter with id %s not found', $chapter->getId()));
}
$entity->setVisible($chapter->isVisible());
$entity->setCbzPath($chapter->getCbzPath());
$entity->setTitle($chapter->getTitle());
$entity->setVolume($chapter->getVolume());
$this->entityManager->persist($entity);
$this->entityManager->flush();
}
public function delete(Chapter $chapter): void
{
$entity = $this->entityManager->find(ChapterEntity::class, $chapter->getId());
if ($entity) {
$this->entityManager->remove($entity);
$this->entityManager->flush();
}
}
public function findByMangaIdAndVolume(string $mangaId, int $volume): array
{
$entities = $this->entityManager->getRepository(ChapterEntity::class)
->findBy(['manga' => $mangaId, 'volume' => $volume]);
return array_map([$this, 'toDomainModel'], $entities);
}
public function findVisibleByMangaIdAndVolume(string $mangaId, int $volume): array
{
$entities = $this->entityManager->getRepository(ChapterEntity::class)
->findBy(['manga' => $mangaId, 'volume' => $volume, 'visible' => true]);
return array_map([$this, 'toDomainModel'], $entities);
}
public function findVisibleWithCbzByMangaIdAndVolume(string $mangaId, int $volume): array
{
$qb = $this->entityManager->createQueryBuilder()
->select('c')
->from(ChapterEntity::class, 'c')
->where('c.manga = :mangaId')
->andWhere('c.volume = :volume')
->andWhere('c.visible = true')
->andWhere('c.cbzPath IS NOT NULL')
->setParameter('mangaId', $mangaId)
->setParameter('volume', $volume)
->orderBy('c.number', 'ASC');
$entities = $qb->getQuery()->getResult();
return array_map([$this, 'toDomainModel'], $entities);
}
private function toDomainModel(ChapterEntity $entity): Chapter
{
return new Chapter(
new ChapterId((string) $entity->getId()),
(string) $entity->getManga()->getId(),
$entity->getNumber(),
$entity->getTitle(),
$entity->getVolume(),
$entity->isVisible(),
$entity->getCbzPath(),
new \DateTimeImmutable()
);
}
}

19
src/Domain/Manga/Infrastructure/Service/MangadxChapterSynchronizationService.php
View File

@@ -67,12 +67,13 @@ readonly class MangadxChapterSynchronizationService implements ChapterSynchroniz
if ($shouldReplaceChapter) {
$chaptersByNumber[(string) $chapterNumber] = new Chapter(
new ChapterId((string) Uuid::uuid4()),
$manga->getId()->getValue(),
$manga->getId(),
$chapterNumber,
$title,
isset($chapterData['attributes']['volume']) ? (int) $chapterData['attributes']['volume'] : null,
true,
null,
0,
new \DateTimeImmutable()
);
$chapterLanguages[(string) $chapterNumber] = $language;
@@ -97,8 +98,8 @@ readonly class MangadxChapterSynchronizationService implements ChapterSynchroniz
// Sauvegarde uniquement les nouveaux chapitres et collecte leurs IDs
foreach ($chaptersByNumber as $chapterNumber => $chapter) {
if (!isset($existingChapters[(float) $chapterNumber])) {
$newChapterId = $this->mangaRepository->saveChapter($chapter);
$newChapterIds[] = $newChapterId->getValue(); // ✨ Collecte des IDs
$manga->addChapter($chapter);
$newChapterIds[] = $chapter->getId();
}
}
@@ -142,7 +143,8 @@ readonly class MangadxChapterSynchronizationService implements ChapterSynchroniz
$currentChapter->getTitle(),
null, // volume = null
$currentChapter->isVisible(),
$currentChapter->getCbzPath(),
$currentChapter->getPagesDirectory(),
$currentChapter->getPageCount(),
$currentChapter->getCreatedAt()
);
}
@@ -155,7 +157,8 @@ readonly class MangadxChapterSynchronizationService implements ChapterSynchroniz
$currentChapter->getTitle(),
$prevVolume, // prend le volume des adjacents
$currentChapter->isVisible(),
$currentChapter->getCbzPath(),
$currentChapter->getPagesDirectory(),
$currentChapter->getPageCount(),
$currentChapter->getCreatedAt()
);
}
@@ -209,7 +212,8 @@ readonly class MangadxChapterSynchronizationService implements ChapterSynchroniz
$currentChapter->getTitle(),
$prevVolume,
$currentChapter->isVisible(),
$currentChapter->getCbzPath(),
$currentChapter->getPagesDirectory(),
$currentChapter->getPageCount(),
$currentChapter->getCreatedAt()
);
}
@@ -222,7 +226,8 @@ readonly class MangadxChapterSynchronizationService implements ChapterSynchroniz
$currentChapter->getTitle(),
$nextVolume,
$currentChapter->isVisible(),
$currentChapter->getCbzPath(),
$currentChapter->getPagesDirectory(),
$currentChapter->getPageCount(),
$currentChapter->getCreatedAt()
);
}

21
src/Domain/Shared/Domain/Model/AggregateRoot.php Normal file
View File

@@ -0,0 +1,21 @@
<?php
namespace App\Domain\Shared\Domain\Model;
abstract class AggregateRoot
{
private array $domainEvents = [];
protected function recordEvent(object $event): void
{
$this->domainEvents[] = $event;
}
public function pullDomainEvents(): array
{
$events = $this->domainEvents;
$this->domainEvents = [];
return $events;
}
}

30
src/Entity/Chapter.php
View File

@@ -39,6 +39,12 @@ class Chapter
#[ORM\Column(length: 255, nullable: true)]
private ?string $cbzPath = null;
#[ORM\Column(length: 255, nullable: true)]
private ?string $pagesDirectory = null;
#[ORM\Column(options: ['default' => 0])]
private int $pageCount = 0;
#[ORM\Column(type: 'boolean', options: ['default' => true])]
private ?bool $visible = true;
@@ -146,4 +152,28 @@ class Chapter
return $this;
}
public function getPagesDirectory(): ?string
{
return $this->pagesDirectory;
}
public function setPagesDirectory(?string $pagesDirectory): static
{
$this->pagesDirectory = $pagesDirectory;
return $this;
}
public function getPageCount(): int
{
return $this->pageCount;
}
public function setPageCount(int $pageCount): static
{
$this->pageCount = $pageCount;
return $this;
}
}

95
tests/Domain/Manga/Adapter/InMemoryChapterRepository.php
View File

@@ -1,95 +0,0 @@
<?php
namespace App\Tests\Domain\Manga\Adapter;
use App\Domain\Manga\Domain\Contract\Repository\ChapterRepositoryInterface;
use App\Domain\Manga\Domain\Model\Chapter;
class InMemoryChapterRepository implements ChapterRepositoryInterface
{
/** @var array<string, Chapter> */
private array $chapters = [];
public function findById(string $id): ?Chapter
{
return $this->chapters[$id] ?? null;
}
public function findVisibleById(string $id): ?Chapter
{
$chapter = $this->chapters[$id] ?? null;
if ($chapter && $chapter->isVisible()) {
return $chapter;
}
return null;
}
public function findByMangaIdAndChapterNumber(string $mangaId, float $chapterNumber): ?Chapter
{
foreach ($this->chapters as $chapter) {
if ($chapter->getMangaId() === $mangaId && $chapter->getNumber() === $chapterNumber) {
return $chapter;
}
}
return null;
}
public function save(Chapter $chapter): void
{
$this->chapters[$chapter->getId()] = $chapter;
}
public function delete(Chapter $chapter): void
{
unset($this->chapters[$chapter->getId()]);
}
public function findByMangaIdAndVolume(string $mangaId, int $volume): array
{
return array_filter(
$this->chapters,
fn (Chapter $chapter) => $chapter->getMangaId() === $mangaId && $chapter->getVolume() === $volume
);
}
public function findVisibleByMangaIdAndVolume(string $mangaId, int $volume): array
{
return array_filter(
$this->chapters,
fn (Chapter $chapter) =>
$chapter->getMangaId() === $mangaId &&
$chapter->getVolume() === $volume &&
$chapter->isVisible()
);
}
public function findVisibleWithCbzByMangaIdAndVolume(string $mangaId, int $volume): array
{
return array_filter(
$this->chapters,
fn (Chapter $chapter) =>
$chapter->getMangaId() === $mangaId &&
$chapter->getVolume() === $volume &&
$chapter->isVisible() &&
$chapter->isAvailable()
);
}
/**
* Get all chapters
*/
public function getAll(): array
{
return array_values($this->chapters);
}
/**
* Clear all chapters
*/
public function clear(): void
{
$this->chapters = [];
}
}

121
tests/Domain/Manga/Adapter/InMemoryMangaRepository.php
View File

@@ -8,6 +8,7 @@ use App\Domain\Manga\Domain\Model\Chapter;
use App\Domain\Manga\Domain\Model\Manga;
use App\Domain\Manga\Domain\Model\ValueObject\ChapterId;
use App\Domain\Manga\Domain\Model\ValueObject\ExternalId;
use App\Domain\Manga\Domain\Model\ValueObject\MangaId;
use App\Domain\Manga\Domain\Model\ValueObject\MangaSlug;
class InMemoryMangaRepository implements MangaRepositoryInterface
@@ -18,8 +19,8 @@ class InMemoryMangaRepository implements MangaRepositoryInterface
/** @var array<string, array<Chapter>> */
private array $chapters = [];
/** @var array<Chapter> */
private array $savedChapters = [];
/** @var array<string, Chapter> */
private array $chaptersById = [];
public function findAll(int $page = 1, int $limit = 20, string $sortBy = 'title', string $sortOrder = 'asc'): array
{
@@ -62,6 +63,39 @@ class InMemoryMangaRepository implements MangaRepositoryInterface
public function save(Manga $manga): void
{
$this->mangas[$manga->getId()->getValue()] = $manga;
foreach ($manga->pullNewChapters() as $chapter) {
$mangaIdValue = $chapter->getMangaId()->getValue();
if (!isset($this->chapters[$mangaIdValue])) {
$this->chapters[$mangaIdValue] = [];
}
$this->chapters[$mangaIdValue][] = $chapter;
$this->chaptersById[$chapter->getId()] = $chapter;
}
foreach ($manga->pullModifiedChapters() as $chapter) {
$this->chaptersById[$chapter->getId()] = $chapter;
$mangaIdValue = $chapter->getMangaId()->getValue();
if (isset($this->chapters[$mangaIdValue])) {
foreach ($this->chapters[$mangaIdValue] as $key => $existing) {
if ($existing->getId() === $chapter->getId()) {
$this->chapters[$mangaIdValue][$key] = $chapter;
break;
}
}
}
}
foreach ($manga->pullChaptersToDelete() as $chapter) {
unset($this->chaptersById[$chapter->getId()]);
$mangaIdValue = $chapter->getMangaId()->getValue();
if (isset($this->chapters[$mangaIdValue])) {
$this->chapters[$mangaIdValue] = array_values(array_filter(
$this->chapters[$mangaIdValue],
fn (Chapter $c) => $c->getId() !== $chapter->getId()
));
}
}
}
public function delete(Manga $manga): void
@@ -101,20 +135,77 @@ class InMemoryMangaRepository implements MangaRepositoryInterface
return count($this->chapters[$mangaId] ?? []);
}
public function findChapterById(string $id): ?Chapter
{
return $this->chaptersById[$id] ?? null;
}
public function findVisibleChapterById(string $id): ?Chapter
{
$chapter = $this->chaptersById[$id] ?? null;
if ($chapter && $chapter->isVisible()) {
return $chapter;
}
return null;
}
public function findChapterByMangaIdAndNumber(string $mangaId, float $chapterNumber): ?Chapter
{
foreach ($this->chaptersById as $chapter) {
if ($chapter->getMangaId()->getValue() === $mangaId && $chapter->getNumber() === $chapterNumber) {
return $chapter;
}
}
return null;
}
public function findChaptersByMangaIdAndVolume(string $mangaId, int $volume): array
{
return array_values(array_filter(
$this->chaptersById,
fn (Chapter $chapter) => $chapter->getMangaId()->getValue() === $mangaId && $chapter->getVolume() === $volume
));
}
public function findVisibleChaptersByMangaIdAndVolume(string $mangaId, int $volume): array
{
return array_values(array_filter(
$this->chaptersById,
fn (Chapter $chapter) =>
$chapter->getMangaId()->getValue() === $mangaId &&
$chapter->getVolume() === $volume &&
$chapter->isVisible()
));
}
public function findVisibleChaptersWithPagesByMangaIdAndVolume(string $mangaId, int $volume): array
{
return array_values(array_filter(
$this->chaptersById,
fn (Chapter $chapter) =>
$chapter->getMangaId()->getValue() === $mangaId &&
$chapter->getVolume() === $volume &&
$chapter->isVisible() &&
$chapter->isAvailable()
));
}
public function addChaptersToManga(string $mangaId, int $count): void
{
$this->chapters[$mangaId] = [];
for ($i = 1; $i <= $count; $i++) {
$this->chapters[$mangaId][] = new Chapter(
$chapter = new Chapter(
id: new ChapterId((string)$i),
mangaId: $mangaId,
mangaId: new MangaId($mangaId),
number: (float)$i,
title: "Chapter $i",
volume: (int)ceil($i / 10),
isVisible: true,
createdAt: new \DateTimeImmutable()
);
$this->chapters[$mangaId][] = $chapter;
$this->chaptersById[$chapter->getId()] = $chapter;
}
}
@@ -128,27 +219,11 @@ class InMemoryMangaRepository implements MangaRepositoryInterface
return null;
}
public function saveChapter(Chapter $chapter): ChapterId
{
$this->savedChapters[] = $chapter;
if (!isset($this->chapters[$chapter->getMangaId()])) {
$this->chapters[$chapter->getMangaId()] = [];
}
$this->chapters[$chapter->getMangaId()][] = $chapter;
return new ChapterId($chapter->getId());
}
/** @return array<Chapter> */
public function getSavedChapters(): array
{
return $this->savedChapters;
}
public function clear(): void
{
$this->mangas = [];
$this->chapters = [];
$this->savedChapters = [];
$this->chaptersById = [];
}
public function search(string $query, int $page = 1, int $limit = 20): array
@@ -161,7 +236,6 @@ class InMemoryMangaRepository implements MangaRepositoryInterface
$manga->getDescription()
];
// Ajouter les slugs alternatifs aux champs de recherche
foreach ($manga->getAlternativeSlugs() as $altSlug) {
$searchableFields[] = $altSlug;
}
@@ -186,6 +260,7 @@ class InMemoryMangaRepository implements MangaRepositoryInterface
{
return count($this->search($query, 1, PHP_INT_MAX));
}
public function findExistingChaptersByNumbers(string $mangaId, array $chapterNumbers): array
{
if (!isset($this->chapters[$mangaId])) {
@@ -203,12 +278,10 @@ class InMemoryMangaRepository implements MangaRepositoryInterface
return array_filter(
array_values($this->mangas),
function (Manga $manga) use ($criteria) {
// Vérifier si le monitoring est activé selon le critère
if ($manga->getMonitoringStatus()->isEnabled() !== $criteria->enabled) {
return false;
}
// Vérifier la date de dernière vérification si spécifiée
if ($criteria->lastCheckBefore !== null) {
$lastCheck = $manga->getLastMonitoringCheck();
if ($lastCheck === null || $lastCheck >= $criteria->lastCheckBefore) {

39
tests/Domain/Manga/Application/CommandHandler/ImportChapterHandlerTest.php
View File

@@ -12,7 +12,6 @@ use App\Domain\Manga\Domain\Model\ValueObject\ChapterId;
use App\Domain\Manga\Domain\Model\ValueObject\MangaId;
use App\Domain\Manga\Domain\Model\ValueObject\MangaSlug;
use App\Domain\Manga\Domain\Model\ValueObject\MangaTitle;
use App\Tests\Domain\Manga\Adapter\InMemoryChapterRepository;
use App\Tests\Domain\Manga\Adapter\InMemoryMangaRepository;
use App\Tests\Domain\Manga\Adapter\InMemoryPathManager;
use PHPUnit\Framework\TestCase;
@@ -20,18 +19,15 @@ use PHPUnit\Framework\TestCase;
class ImportChapterHandlerTest extends TestCase
{
private InMemoryMangaRepository $mangaRepository;
private InMemoryChapterRepository $chapterRepository;
private InMemoryPathManager $pathManager;
private ImportChapterHandler $handler;
protected function setUp(): void
{
$this->mangaRepository = new InMemoryMangaRepository();
$this->chapterRepository = new InMemoryChapterRepository();
$this->pathManager = new InMemoryPathManager();
$this->handler = new ImportChapterHandler(
$this->mangaRepository,
$this->chapterRepository,
$this->pathManager
);
}
@@ -66,7 +62,7 @@ class ImportChapterHandlerTest extends TestCase
$this->handler->handle($command);
}
public function test_it_updates_existing_chapter_with_new_cbz(): void
public function test_it_updates_existing_chapter_with_new_path(): void
{
// Arrange
$mangaId = 'manga-123';
@@ -80,19 +76,18 @@ class ImportChapterHandlerTest extends TestCase
['action', 'adventure'],
'ongoing'
);
$this->mangaRepository->save($manga);
// Create an existing chapter without CBZ
// Create an existing chapter without pages and add through the aggregate
$existingChapter = new Chapter(
new ChapterId('chapter-123'),
$mangaId,
new MangaId($mangaId),
1.5,
'Chapter 1.5',
1,
true,
null
);
$this->chapterRepository->save($existingChapter);
$manga->addChapter($existingChapter);
$this->mangaRepository->save($manga);
// Import the same chapter with CBZ
$cbzBinary = $this->createValidCbzBinary();
@@ -106,18 +101,16 @@ class ImportChapterHandlerTest extends TestCase
$this->handler->handle($command);
// Assert
$chapters = $this->chapterRepository->getAll();
$this->assertCount(1, $chapters); // Still only one chapter
$updatedChapter = $chapters[0];
$updatedChapter = $this->mangaRepository->findChapterById('chapter-123');
$this->assertNotNull($updatedChapter);
$this->assertEquals('chapter-123', $updatedChapter->getId());
$this->assertEquals($mangaId, $updatedChapter->getMangaId());
$this->assertEquals($mangaId, $updatedChapter->getMangaId()->getValue());
$this->assertEquals(1.5, $updatedChapter->getNumber());
$this->assertEquals('Chapter 1.5', $updatedChapter->getTitle()); // Title preserved
$this->assertEquals(1, $updatedChapter->getVolume()); // Volume preserved
$this->assertEquals('Chapter 1.5', $updatedChapter->getTitle());
$this->assertEquals(1, $updatedChapter->getVolume());
$this->assertTrue($updatedChapter->isVisible());
$this->assertTrue($updatedChapter->isAvailable()); // Now has CBZ
$this->assertStringContainsString('_vol1_ch1.5.cbz', $updatedChapter->getCbzPath());
$this->assertTrue($updatedChapter->isAvailable());
$this->assertNotNull($updatedChapter->getPagesDirectory());
}
public function test_it_throws_exception_when_manga_not_found(): void
@@ -168,24 +161,16 @@ class ImportChapterHandlerTest extends TestCase
$this->handler->handle($command);
}
/**
* Create a minimal valid CBZ (ZIP) binary for testing
*/
private function createValidCbzBinary(): string
{
$tmpFile = tempnam(sys_get_temp_dir(), 'cbz');
// Delete the empty file created by tempnam
unlink($tmpFile);
$zip = new \ZipArchive();
// Create a new ZIP archive (avoid opening empty file)
if ($zip->open($tmpFile, \ZipArchive::CREATE | \ZipArchive::OVERWRITE) !== true) {
throw new \RuntimeException('Cannot create test CBZ file');
}
// Add a dummy image file to the ZIP
$zip->addFromString('image1.jpg', 'fake-image-data');
$zip->close();

26
tests/Domain/Manga/Application/CommandHandler/ImportVolumeHandlerTest.php
View File

@@ -11,7 +11,6 @@ use App\Domain\Manga\Domain\Model\ValueObject\ChapterId;
use App\Domain\Manga\Domain\Model\ValueObject\MangaId;
use App\Domain\Manga\Domain\Model\ValueObject\MangaSlug;
use App\Domain\Manga\Domain\Model\ValueObject\MangaTitle;
use App\Tests\Domain\Manga\Adapter\InMemoryChapterRepository;
use App\Tests\Domain\Manga\Adapter\InMemoryMangaRepository;
use App\Tests\Domain\Manga\Adapter\InMemoryPathManager;
use PHPUnit\Framework\TestCase;
@@ -19,18 +18,15 @@ use PHPUnit\Framework\TestCase;
class ImportVolumeHandlerTest extends TestCase
{
private InMemoryMangaRepository $mangaRepository;
private InMemoryChapterRepository $chapterRepository;
private InMemoryPathManager $pathManager;
private ImportVolumeHandler $handler;
protected function setUp(): void
{
$this->mangaRepository = new InMemoryMangaRepository();
$this->chapterRepository = new InMemoryChapterRepository();
$this->pathManager = new InMemoryPathManager();
$this->handler = new ImportVolumeHandler(
$this->mangaRepository,
$this->chapterRepository,
$this->pathManager
);
}
@@ -50,21 +46,20 @@ class ImportVolumeHandlerTest extends TestCase
['action', 'adventure'],
'ongoing'
);
$this->mangaRepository->save($manga);
// Create chapters in volume 1
// Create chapters in volume 1 and add through the aggregate
for ($i = 1; $i <= 3; $i++) {
$chapter = new Chapter(
new ChapterId("chapter-$i"),
$mangaId,
new MangaId($mangaId),
(float)$i,
"Chapter $i",
$volumeNumber,
true,
null
);
$this->chapterRepository->save($chapter);
$manga->addChapter($chapter);
}
$this->mangaRepository->save($manga);
$cbzBinary = $this->createValidCbzBinary();
$command = new ImportVolume(
@@ -77,12 +72,12 @@ class ImportVolumeHandlerTest extends TestCase
$this->handler->handle($command);
// Assert
$chapters = $this->chapterRepository->findByMangaIdAndVolume($mangaId, $volumeNumber);
$chapters = $this->mangaRepository->findChaptersByMangaIdAndVolume($mangaId, $volumeNumber);
$this->assertCount(3, $chapters);
foreach ($chapters as $chapter) {
$this->assertTrue($chapter->isAvailable());
$this->assertStringContainsString('_vol' . $volumeNumber . '.cbz', $chapter->getCbzPath());
$this->assertNotNull($chapter->getPagesDirectory());
}
}
@@ -153,7 +148,7 @@ class ImportVolumeHandlerTest extends TestCase
$cbzBinary = $this->createValidCbzBinary();
$command = new ImportVolume(
mangaId: $mangaId,
volumeNumber: 999, // Non-existent volume
volumeNumber: 999,
fileBinary: $cbzBinary
);
@@ -165,9 +160,6 @@ class ImportVolumeHandlerTest extends TestCase
$this->handler->handle($command);
}
/**
* Create a minimal valid CBZ (ZIP) binary for testing
*/
private function createValidCbzBinary(): string
{
$tmpFile = tempnam(sys_get_temp_dir(), 'cbz_');
@@ -187,7 +179,3 @@ class ImportVolumeHandlerTest extends TestCase
return $binaryContent;
}
}

33
tests/Feature/Manga/GetMangaListTest.php
View File

@@ -3,12 +3,15 @@
namespace App\Tests\Feature\Manga;
use App\Entity\Manga;
use App\Factory\ChapterFactory;
use App\Factory\MangaFactory;
use App\Tests\Feature\AbstractApiTestCase;
use Zenstruck\Foundry\Test\Factories;
use Zenstruck\Foundry\Test\ResetDatabase;
class GetMangaListTest extends AbstractApiTestCase
{
use ResetDatabase;
use ResetDatabase, Factories;
public function testGetEmptyMangaList(): void
{
@@ -80,6 +83,34 @@ class GetMangaListTest extends AbstractApiTestCase
$this->assertEquals('Manga C', $data['items'][2]['title']);
}
public function testGetMangaListWithChapters(): void
{
// Given — manga with chapters triggers Doctrine EAGER loading of chapters collection
// (regression: colonne pages_directory doit exister sinon 500)
$manga = MangaFactory::createOne([
'title' => 'One Piece',
'slug' => 'one-piece',
'imageUrl' => 'https://example.com/image.jpg',
'thumbnailUrl' => 'https://example.com/thumb.jpg',
]);
ChapterFactory::createOne([
'manga' => $manga,
'number' => 1.0,
'title' => 'Romance Dawn',
'volume' => 1,
'visible' => true,
]);
// When
$client = static::createClient();
$client->request('GET', '/api/mangas');
// Then — doit retourner 200 même avec des chapitres (eager loading OK)
$this->assertResponseIsSuccessful();
$data = $client->getResponse()->toArray();
$this->assertEquals(1, $data['total']);
}
private function createMangas(int $count): void
{
for ($i = 1; $i <= $count; $i++) {