Stu\Module\Trade\Lib\TradePostStorageManager

Complexity

Total Complexity

14

Size/Duplication

Total Lines	102
Duplicated Lines	0 %

Test Coverage

Coverage

91.67%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	upperStorage()	0	19	3
A	getFreeStorage()	0	3	1
A	getStorage()	0	11	3
A	lowerStorage()	0	17	3
A	getStorageSum()	0	10	2
A	getTradePost()	0	3	1
A	__construct()	0	10	1

<?php

declare(strict_types=1);

namespace Stu\Module\Trade\Lib;

use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Common\Collections\Collection;
use InvalidArgumentException;
use Stu\Orm\Entity\StorageInterface;
use Stu\Orm\Entity\TradePostInterface;
use Stu\Orm\Entity\UserInterface;
use Stu\Orm\Repository\CommodityRepositoryInterface;
use Stu\Orm\Repository\StorageRepositoryInterface;

final class TradePostStorageManager implements TradePostStorageManagerInterface
{
    private StorageRepositoryInterface $storageRepository;

    private CommodityRepositoryInterface $commodityRepository;

    private TradePostInterface $tradePost;

    private UserInterface $user;

    private ?int $storageSum = null;

    /**
     * @var ArrayCollection<int, StorageInterface>
     */
    private ?ArrayCollection $storage = null;

    public function __construct(
        StorageRepositoryInterface $storageRepository,
        CommodityRepositoryInterface $commodityRepository,
        TradePostInterface $tradePost,
        UserInterface $user
    ) {
        $this->storageRepository = $storageRepository;
        $this->commodityRepository = $commodityRepository;
        $this->tradePost = $tradePost;
        $this->user = $user;
    }

    public function getTradePost(): TradePostInterface
    {
        return $this->tradePost;
    }

    public function getStorageSum(): int
    {
        if ($this->storageSum === null) {
            $this->storageSum = array_reduce(
                $this->getStorage()->toArray(),
                fn (int $value, StorageInterface $storage): int => $value + $storage->getAmount(),
                0
            );
        }
        return $this->storageSum;

The expression return $this->storageSum could return the type null which is incompatible with the type-hinted return integer. Consider adding an additional type-check to rule them out.

    }

    public function getFreeStorage(): int
    {
        return max(0, $this->tradePost->getStorage() - $this->getStorageSum());
    }

    public function getStorage(): Collection
    {
        if ($this->storage === null) {
            $this->storage = new ArrayCollection();

            foreach ($this->storageRepository->getByTradePostAndUser($this->tradePost->getId(), $this->user->getId()) as $storage) {
                $this->storage->set($storage->getCommodityId(), $storage);

The method set() does not exist on null.

            }
        }

        return $this->storage;

The expression return $this->storage could return the type null which is incompatible with the type-hinted return Doctrine\Common\Collections\Collection. Consider adding an additional type-check to rule them out.

    }

    public function upperStorage(int $commodityId, int $amount): void
    {
        $storage = $this->getStorage();

        $stor = $storage->get($commodityId) ?? null;
        if ($stor === null) {
            $stor = $this->storageRepository->prototype();
            $stor->setUser($this->user);
            $commodity = $this->commodityRepository->find($commodityId);
            if ($commodity === null) {
                throw new InvalidArgumentException(sprintf('commodityId %d does not exist', $commodityId));
            }
            $stor->setCommodity($commodity);
            $stor->setTradePost($this->tradePost);
        }
        $stor->setAmount($stor->getAmount() + $amount);
        $storage->set($commodityId, $stor);

        $this->storageRepository->save($stor);
    }

    public function lowerStorage(int $commodityId, int $amount): void
    {
        $storage = $this->getStorage();

        $stor = $storage->get($commodityId) ?? null;
        if ($stor === null) {
            return;
        }

        if ($stor->getAmount() <= $amount) {
            $storage->remove($commodityId);
            $this->storageRepository->delete($stor);
            return;
        }
        $stor->setAmount($stor->getAmount() - $amount);

        $this->storageRepository->save($stor);
    }
}