Kepawni\Twilted\Basic\TestSample\ShoppingBasket

Complexity

Total Complexity

11

Size/Duplication

Total Lines	64
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	whenShoppingBasketWasCheckedOut()	0	4	1
A	whenShoppingBasketWasPickedUpByNewCustomer()	0	2	1
A	magicallyCreateCustomerId()	0	3	1
A	pickUp()	0	10	2
A	checkout()	0	5	1
A	whenShoppingBasketWasPickedUpByReturningCustomer()	0	3	1
A	addItem()	0	4	1
A	whenItemWasAddedToShoppingBasket()	0	4	1
A	quickCheckout()	0	5	2

<?php declare(strict_types=1);
namespace Kepawni\Twilted\Basic\TestSample;

use Assert\Assert;
use Kepawni\Twilted\Basic\SimpleAggregateRoot;
use Kepawni\Twilted\Basic\TestSample\Event\ItemWasAddedToShoppingBasket;
use Kepawni\Twilted\Basic\TestSample\Event\ShoppingBasketWasCheckedOut;
use Kepawni\Twilted\Basic\TestSample\Event\ShoppingBasketWasPickedUpByNewCustomer;
use Kepawni\Twilted\Basic\TestSample\Event\ShoppingBasketWasPickedUpByReturningCustomer;
use Kepawni\Twilted\EntityIdentifier;

class ShoppingBasket extends SimpleAggregateRoot
{
    const FAKE_CUSTOMER_ID = '8ccbb53b-6f23-43b8-be73-00efdfb90996';
    private $isClosed = false;
    private $items = [];
    /** @var string|null */
    private $returningCustomerId = null;

    public static function pickUp(EntityIdentifier $uuid, string $returningCustomerId = null)
    {
        $basket = new static($uuid);
        if ($returningCustomerId) {
            Assert::that($returningCustomerId)->uuid();
            $basket->recordThat(new ShoppingBasketWasPickedUpByReturningCustomer($returningCustomerId));
        } else {
            $basket->recordThat(new ShoppingBasketWasPickedUpByNewCustomer());
        }
        return $basket;
    }

    public function addItem(string $itemCode, int $quantity = 1)
    {
        Assert::that($this->isClosed)->false('Basket has been closed during checkout');
        $this->recordThat(new ItemWasAddedToShoppingBasket($itemCode, $quantity));
    }

    public function checkout($billingData, $shippingData, $paymentInformation)
    {
        Assert::that(array_sum($this->items))->greaterThan(0, 'Empty baskets cannot be processed');
        $newCustomerId = $this->magicallyCreateCustomerId($billingData, $shippingData, $paymentInformation);
        $this->recordThat(new ShoppingBasketWasCheckedOut($newCustomerId));
    }

    public function quickCheckout()
    {
        Assert::that(array_sum($this->items))->greaterThan(0, 'Empty baskets cannot be processed');
        Assert::that($this->returningCustomerId)->notNull('Quick checkout is possible only for returning customers');
        $this->recordThat(new ShoppingBasketWasCheckedOut($this->returningCustomerId ?: ''));
    }

    protected function whenItemWasAddedToShoppingBasket(ItemWasAddedToShoppingBasket $event)
    {
        $this->items[$event->getItemCode()] = $this->items[$event->getItemCode()] ?? 0;
        $this->items[$event->getItemCode()] += $event->getQuantity();
    }

    protected function whenShoppingBasketWasCheckedOut(ShoppingBasketWasCheckedOut $event)

The parameter $event is not used and could be removed.

    {
        $this->isClosed = true;
        $this->items = [];
    }

    protected function whenShoppingBasketWasPickedUpByNewCustomer(ShoppingBasketWasPickedUpByNewCustomer $event)

The parameter $event is not used and could be removed.

    {
    }

    protected function whenShoppingBasketWasPickedUpByReturningCustomer(ShoppingBasketWasPickedUpByReturningCustomer $event)
    {
        $this->returningCustomerId = $event->getReturningCustomerId();
    }

    private function magicallyCreateCustomerId($billingData, $shippingData, $paymentInformation): string

The parameter $shippingData is not used and could be removed.

The parameter $billingData is not used and could be removed.

The parameter $paymentInformation is not used and could be removed.

    {
        return self::FAKE_CUSTOMER_ID;
    }
}