264 lines
8.6 KiB
PHP
264 lines
8.6 KiB
PHP
<?php
|
|
|
|
declare(strict_types=1);
|
|
|
|
namespace Domain\Services;
|
|
|
|
use Carbon\CarbonImmutable;
|
|
use Carbon\CarbonInterface;
|
|
use Domain\Builders\OrderBuilder;
|
|
use Domain\Builders\OrderBuilderCompleted;
|
|
use Domain\Builders\OrderBuilderWithBasket;
|
|
use Domain\Exceptions\OrderTunnel\ExpiredPickupTimeSlotException;
|
|
use Domain\Exceptions\OrderTunnel\MissingOrderBuilderException;
|
|
use Domain\Exceptions\OrderTunnel\OrderLimitExceededException;
|
|
use Domain\Exceptions\OrderTunnel\RegateExportFailedException;
|
|
use Domain\Exceptions\OrderTunnel\UnorderableProductException;
|
|
use Domain\Exceptions\OrderTunnel\WeeklyLimitExceededException;
|
|
use Domain\Models\Entities\Basket;
|
|
use Domain\Models\Entities\Order;
|
|
use Domain\Models\Entities\Shop;
|
|
use Domain\Models\Entities\Shopper;
|
|
use Domain\Models\ValueObjects\Entities\ShopperId;
|
|
use Domain\Models\ValueObjects\PickupTimeSlot;
|
|
use Domain\Policies\CustomerOrderLimitPolicy;
|
|
use Domain\Ports\Repositories\OrderRepository;
|
|
use Domain\Ports\Repositories\ProductRepository;
|
|
use Domain\Ports\Repositories\ShopperRepository;
|
|
use Domain\Ports\Repositories\ShopRepository;
|
|
use Domain\Ports\Services\EmployeeStatisticsService;
|
|
use Domain\Ports\Services\OrderBuilderSessionManager;
|
|
use Domain\Ports\Services\RegateService;
|
|
use Shared\DDD\DomainEventDispatcher;
|
|
|
|
class OrderTunnelService
|
|
{
|
|
private const TIMESLOTS_DAY_TARGET = 28;
|
|
|
|
public function __construct(
|
|
private readonly DomainEventDispatcher $eventDispatcher,
|
|
private readonly ShopperService $shopperService,
|
|
private readonly OrderBuilderSessionManager $orderBuilderSessionManager,
|
|
private readonly PickupSchedulingService $pickupService,
|
|
private readonly OrderRepository $orderRepository,
|
|
private readonly ProductRepository $productRepository,
|
|
private readonly CustomerOrderLimitPolicy $orderLimitPolicy,
|
|
private readonly ShopRepository $shopRepository,
|
|
private readonly ShopperRepository $shopperRepository,
|
|
private readonly OrderService $orderService,
|
|
private readonly EmployeeStatisticsService $employeeStatisticsService,
|
|
private readonly RegateService $regateService,
|
|
) {
|
|
}
|
|
|
|
public function canAccessBooking(): bool
|
|
{
|
|
$builder = $this->orderBuilderSessionManager->get();
|
|
|
|
return $builder instanceof OrderBuilderWithBasket
|
|
&& $builder->getBasket()->countItems() > 0;
|
|
}
|
|
|
|
public function canAccessConfirmation(): bool
|
|
{
|
|
$builder = $this->orderBuilderSessionManager->get();
|
|
|
|
return $builder instanceof OrderBuilderCompleted
|
|
&& $builder->getBasket()->countItems() > 0;
|
|
}
|
|
|
|
/**
|
|
* Resolve the shop assigned to a customer.
|
|
*
|
|
* @throws \UnexpectedValueException If no shop can be resolved.
|
|
*/
|
|
public function getShopForCustomer(ShopperId $customerId): Shop
|
|
{
|
|
return $this->shopperService->getShopFor($customerId)
|
|
?? throw new \UnexpectedValueException(
|
|
"No shop found for customer '{$customerId->value}'"
|
|
);
|
|
}
|
|
|
|
/** @return array<PickupTimeSlot> */
|
|
public function getAvailableTimeSlots(Shop $shop): array
|
|
{
|
|
return $this->pickupService->getTimeSlotsFor(
|
|
$shop,
|
|
$this->getTimeslotsUntil()
|
|
);
|
|
}
|
|
|
|
public function initializeFromBasket(Basket $basket, ShopperId $customerId): void
|
|
{
|
|
$builder = OrderBuilder::fromBasket($basket, $customerId);
|
|
|
|
$this->orderBuilderSessionManager->save($builder);
|
|
}
|
|
|
|
/**
|
|
* @throws \Domain\Exceptions\OrderTunnel\MissingOrderBuilderException
|
|
*/
|
|
public function getBuilderFromBasketOrFail(): OrderBuilderWithBasket
|
|
{
|
|
$builder = $this->orderBuilderSessionManager->get();
|
|
|
|
if (! $builder instanceof OrderBuilderWithBasket || $builder->getBasket()->countItems() === 0) {
|
|
throw new MissingOrderBuilderException();
|
|
}
|
|
|
|
return $builder;
|
|
}
|
|
|
|
/**
|
|
* @throws \Domain\Exceptions\OrderTunnel\MissingOrderBuilderException
|
|
*/
|
|
public function getBuilderCompletedOrFail(): OrderBuilderCompleted
|
|
{
|
|
$builder = $this->orderBuilderSessionManager->get();
|
|
|
|
if (! $builder instanceof OrderBuilderCompleted || $builder->getBasket()->countItems() === 0) {
|
|
throw new MissingOrderBuilderException();
|
|
}
|
|
|
|
return $builder;
|
|
}
|
|
|
|
/**
|
|
* Validate that the selected date matches an available slot and apply it to the builder.
|
|
*
|
|
* @param array<PickupTimeSlot> $availableSlots
|
|
*/
|
|
public function applyTimeSlot(
|
|
OrderBuilderWithBasket $builder,
|
|
Shop $shop,
|
|
CarbonInterface $selectedDate,
|
|
array $availableSlots
|
|
): ?PickupTimeSlot {
|
|
$matchedSlot = null;
|
|
foreach ($availableSlots as $ts) {
|
|
if ($selectedDate->isSameDay($ts->getAt())) {
|
|
$matchedSlot = $ts;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ($matchedSlot === null) {
|
|
return null;
|
|
}
|
|
|
|
$completed = $builder->withPickupTimeSlot($shop->id(), $matchedSlot);
|
|
|
|
$this->orderBuilderSessionManager->save($completed);
|
|
|
|
return $matchedSlot;
|
|
}
|
|
|
|
/**
|
|
* @throws WeeklyLimitExceededException
|
|
* @throws OrderLimitExceededException
|
|
* @throws ExpiredPickupTimeSlotException
|
|
* @throws UnorderableProductException
|
|
* @throws RegateExportFailedException
|
|
*/
|
|
public function finalizeOrder(OrderBuilderCompleted $builder): Order
|
|
{
|
|
$shopperId = $builder->getShopperId();
|
|
$basket = $this->revalidateBasket($builder->getBasket());
|
|
$pickupTimeSlot = $builder->getPickupTimeSlot();
|
|
$shopId = $builder->getShopId();
|
|
$shopper = $this->shopperRepository->getByIdOrFail($shopperId);
|
|
|
|
$this->assertBasketAmountWithinLimit($basket);
|
|
$this->assertBasketWeeklyAmountWithinLimitFor(
|
|
$shopper,
|
|
$basket,
|
|
$pickupTimeSlot->getAt()
|
|
);
|
|
|
|
$shop = $this->shopRepository->find($shopId);
|
|
if (! $shop) {
|
|
throw new \DomainException("Shop with id '{$shopId->value}' not found.");
|
|
}
|
|
|
|
$this->assertPickupTimeSlotIsAvailable($shop, $pickupTimeSlot);
|
|
|
|
$order = $this->orderService->createOrderFromBasket(
|
|
$basket,
|
|
$pickupTimeSlot,
|
|
$shopper,
|
|
$shop
|
|
);
|
|
|
|
$this->orderRepository->persist($order);
|
|
|
|
$placedEvent = $order->toPlacedEvent();
|
|
|
|
$this->regateService->processOrder(
|
|
$order->reference,
|
|
$order->employee->matricule,
|
|
CarbonImmutable::instance($order->pickupTimeSlot->getAt()),
|
|
$placedEvent->lines,
|
|
);
|
|
|
|
$this->eventDispatcher->dispatch($placedEvent);
|
|
|
|
return $order;
|
|
}
|
|
|
|
/** @throws \Domain\Exceptions\OrderTunnel\OrderLimitExceededException */
|
|
public function assertBasketAmountWithinLimit(Basket $basket): void
|
|
{
|
|
$this->orderLimitPolicy->assertCanPlaceOrder($basket->totalTaxIncluded());
|
|
}
|
|
|
|
/** @throws \Domain\Exceptions\OrderTunnel\WeeklyLimitExceededException */
|
|
public function assertBasketWeeklyAmountWithinLimitFor(
|
|
Shopper $shopper,
|
|
Basket $withBasket,
|
|
\DateTimeInterface $atDate
|
|
): void {
|
|
$startOfWeek = CarbonImmutable::instance($atDate)->startOfWeek(CarbonInterface::MONDAY);
|
|
$endOfWeek = CarbonImmutable::instance($atDate)->endOfWeek(CarbonInterface::SUNDAY);
|
|
|
|
$weekTotal = $this->employeeStatisticsService->getWeeklyTotalForEmployee(
|
|
$shopper->matricule,
|
|
$startOfWeek,
|
|
$endOfWeek
|
|
);
|
|
|
|
$this->orderLimitPolicy->assertCanPlaceWeeklyOrder($withBasket->totalTaxIncluded(), $weekTotal);
|
|
}
|
|
|
|
private function revalidateBasket(Basket $basket): Basket
|
|
{
|
|
$refreshedItems = [];
|
|
|
|
foreach ($basket->items() as $item) {
|
|
$refreshedItems[] = $this->productRepository->getBasketProduct($item->id, $item->qty);
|
|
}
|
|
|
|
return new Basket($basket->id, $refreshedItems);
|
|
}
|
|
|
|
/**
|
|
* @throws \Domain\Exceptions\OrderTunnel\ExpiredPickupTimeSlotException
|
|
*/
|
|
private function assertPickupTimeSlotIsAvailable(Shop $shop, PickupTimeSlot $pickupTimeSlot): void
|
|
{
|
|
$availableSlots = $this->getAvailableTimeSlots($shop);
|
|
|
|
foreach ($availableSlots as $slot) {
|
|
if (CarbonImmutable::instance($pickupTimeSlot->getAt())->isSameDay($slot->getAt())) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
throw new ExpiredPickupTimeSlotException();
|
|
}
|
|
|
|
private function getTimeslotsUntil(): CarbonInterface
|
|
{
|
|
return CarbonImmutable::now()->addDays(self::TIMESLOTS_DAY_TARGET);
|
|
}
|
|
}
|