143 lines
4.3 KiB
PHP
143 lines
4.3 KiB
PHP
<?php
|
|
|
|
declare(strict_types=1);
|
|
|
|
namespace App\Services;
|
|
|
|
use App\Dto\ProductDto;
|
|
use App\Dto\ProductPricingDto;
|
|
use App\Dto\ProductWithPricingDto;
|
|
use App\Models\Product;
|
|
use Domain\Models\Entities\Product as DomainProduct;
|
|
use Illuminate\Database\Eloquent\Collection;
|
|
use Illuminate\Pagination\LengthAwarePaginator;
|
|
use Illuminate\Support\Collection as BaseCollection;
|
|
use Infrastructure\Adapters\Repositories\EloquentProductRepository;
|
|
use Webmozart\Assert\Assert;
|
|
|
|
/**
|
|
* Point unique d'assemblage des DTOs produit : précharge en lot les relations
|
|
* manquantes sans recharger les produits déjà hydratés et en dérive la commandabilité
|
|
* et le pricing, afin que les DTOs restent purs (aucun accès au conteneur ni au repository).
|
|
*/
|
|
final readonly class ProductDtoAssemblerService
|
|
{
|
|
public function __construct(
|
|
private EloquentProductRepository $productRepository,
|
|
) {
|
|
}
|
|
|
|
public function toDto(Product $product): ProductDto
|
|
{
|
|
return $this->toDtos([$product])[0];
|
|
}
|
|
|
|
public function toDtoWithPricing(Product $product): ProductWithPricingDto
|
|
{
|
|
return $this->toDtosWithPricing([$product])[0];
|
|
}
|
|
|
|
/**
|
|
* @param iterable<Product> $products
|
|
* @return list<ProductDto>
|
|
*/
|
|
public function toDtos(iterable $products): array
|
|
{
|
|
[$models, $entities] = $this->load($products);
|
|
|
|
return array_values(array_map(
|
|
fn (Product $model): ProductDto => ProductDto::fromModel(
|
|
$model,
|
|
$this->entityOf($entities, $model)->isOrderable(),
|
|
),
|
|
$models
|
|
));
|
|
}
|
|
|
|
/**
|
|
* @param iterable<Product> $products
|
|
* @return list<ProductWithPricingDto>
|
|
*/
|
|
public function toDtosWithPricing(iterable $products): array
|
|
{
|
|
[$models, $entities] = $this->load($products);
|
|
|
|
return array_values(array_map(
|
|
function (Product $model) use ($entities): ProductWithPricingDto {
|
|
$entity = $this->entityOf($entities, $model);
|
|
|
|
return new ProductWithPricingDto(
|
|
product: ProductDto::fromModel(
|
|
$model,
|
|
$entity->isOrderable(),
|
|
validDiscountOnly: true,
|
|
),
|
|
pricing: ProductPricingDto::fromModel($entity->pricing()),
|
|
);
|
|
},
|
|
$models
|
|
));
|
|
}
|
|
|
|
/**
|
|
* Remplace le contenu d'un paginator de modèles par des DTOs (sans pricing).
|
|
*
|
|
* @param LengthAwarePaginator<int, Product> $paginator
|
|
* @return LengthAwarePaginator<int, ProductDto>
|
|
*/
|
|
public function paginateDtos(LengthAwarePaginator $paginator): LengthAwarePaginator
|
|
{
|
|
$dtos = $this->toDtos($paginator->items());
|
|
|
|
/** @var LengthAwarePaginator<int, ProductDto> $paginator */
|
|
$paginator = $paginator->setCollection(new BaseCollection($dtos));
|
|
|
|
return $paginator;
|
|
}
|
|
|
|
/**
|
|
* @param LengthAwarePaginator<int, Product> $paginator
|
|
* @return LengthAwarePaginator<int, ProductWithPricingDto>
|
|
*/
|
|
public function paginateDtosWithPricing(LengthAwarePaginator $paginator): LengthAwarePaginator
|
|
{
|
|
$dtos = $this->toDtosWithPricing($paginator->items());
|
|
|
|
/** @var LengthAwarePaginator<int, ProductWithPricingDto> $paginator */
|
|
$paginator = $paginator->setCollection(new BaseCollection($dtos));
|
|
|
|
return $paginator;
|
|
}
|
|
|
|
/**
|
|
* @param iterable<Product> $products
|
|
* @return array{0: list<Product>, 1: array<string, DomainProduct>}
|
|
*/
|
|
private function load(iterable $products): array
|
|
{
|
|
$models = [];
|
|
foreach ($products as $product) {
|
|
$models[] = $product;
|
|
}
|
|
|
|
(new Collection($models))->loadMissing(['range', 'inco', 'validDiscount']);
|
|
|
|
$entities = [];
|
|
foreach ($models as $model) {
|
|
$entities[(string) $model->id] = $this->productRepository->toEntity($model);
|
|
}
|
|
|
|
return [$models, $entities];
|
|
}
|
|
|
|
/**
|
|
* @param array<string, DomainProduct> $entities
|
|
*/
|
|
private function entityOf(array $entities, Product $model): DomainProduct
|
|
{
|
|
$entity = $entities[(string) $model->id] ?? null;
|
|
Assert::notNull($entity, "Domain product not found for ID {$model->id}");
|
|
|
|
return $entity;
|
|
}
|
|
}
|