Blackmine\Repository\CacheableRepository

Complexity

Total Complexity

30

Size/Duplication

Total Lines	203
Duplicated Lines	0 %

Importance

Changes	2
Bugs	0	Features	0

20 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	1
A	update()	0	8	2
A	cacheModel()	0	14	2
A	supportsTagging()	0	3	1
A	getEndpoint()	0	3	1
A	delete()	0	8	3
A	getClient()	0	3	1
A	get()	0	12	2
A	getRelationClassMap()	0	3	1
A	getAllowedFilters()	0	3	1
A	getRelationClassFor()	0	3	1
A	__call()	0	7	2
A	addRelationToFetch()	0	3	1
A	constructEndpointUrl()	0	3	1
A	getModelClass()	0	3	1
A	getCacheTTL()	0	3	1
A	create()	0	8	2
A	search()	0	18	3
A	actingAs()	0	11	2
A	getFetchRelations()	0	3	1

<?php

namespace Blackmine\Repository;

use Blackmine\Client\ClientInterface;
use Blackmine\Client\ClientOptions;
use Blackmine\Client\Generator\KeyGeneratorInterface;
use Blackmine\Exception\Api\AbstractApiException;
use Blackmine\Exception\InvalidModelException;
use Blackmine\Model\AbstractModel;
use Blackmine\Model\User\User;
use Doctrine\Common\Collections\ArrayCollection;
use JsonException;
use Psr\Cache\InvalidArgumentException;
use Symfony\Contracts\Cache\CacheInterface;
use Symfony\Contracts\Cache\ItemInterface;
use Symfony\Contracts\Cache\TagAwareCacheInterface;

/**
 * @method ArrayCollection all(?string $endpoint = null)
 */
class CacheableRepository implements RepositoryInterface
{
    use RepositoryTrait;
    use SearchableTrait;

    public function __construct(
        protected AbstractRepository $repository,
        protected CacheInterface | TagAwareCacheInterface $cache,
        protected KeyGeneratorInterface $generator,
        protected array $options = [
            ClientOptions::CLIENT_OPTION_REQUEST_HEADERS => []
        ]
    ) {
    }

    public function actingAs(string | User $user): self
    {
        if ($user instanceof User) {
            $this->options[ClientOptions::CLIENT_OPTION_REQUEST_HEADERS][ClientOptions::REDMINE_IMPERSONATE_HEADER] =
                $user->getLogin();
        } else {
            $this->options[ClientOptions::CLIENT_OPTION_REQUEST_HEADERS][ClientOptions::REDMINE_IMPERSONATE_HEADER] =
                $user;
        }

        return $this;
    }

    /**
     * @throws InvalidArgumentException
     */
    public function get(mixed $id): ?AbstractModel
    {
        $cache_key = $this->generator->generate($this->repository->getModelClass(), $id);
        return $this->cache->get($cache_key, function (ItemInterface $item) use ($id) {
            $model = $this->repository->get($id);
            if ($model) {
                $item->set($model);
                $item->expiresAfter($this->getCacheTTL());
                $item->tag([$model->getEntityName()]);
            }

            return $model;
        });
    }

    /**
     * @throws InvalidArgumentException
     * @throws JsonException
     * @throws AbstractApiException
     * @throws InvalidModelException
     */
    public function create(AbstractModel $model): ?AbstractModel
    {
        $model = $this->repository->create($model);
        if ($model?->isCacheable()) {
            return $this->cacheModel($model);
        }

        return $model;
    }

    /**
     * @throws InvalidArgumentException
     * @throws JsonException
     * @throws AbstractApiException
     * @throws InvalidModelException
     */
    public function update(AbstractModel $model): ?AbstractModel
    {
        $model = $this->repository->update($model);
        if ($model?->isCacheable()) {
            return $this->cacheModel($model);
        }

        return $model;
    }

    /**
     * @throws InvalidArgumentException
     * @throws JsonException
     * @throws AbstractApiException
     * @throws InvalidModelException
     */
    public function delete(AbstractModel $model): void
    {
        $this->repository->delete($model);
        if ($model->isCacheable()) {
            $cache_key = $this->generator->generate($model->getEntityName(), $model->getId());
            $this->cache->delete($cache_key);
            if ($this->supportsTagging()) {
                $this->cache->invalidateTags([$model->getEntityName() . "_search_results"]);
            }
        }
    }

    /**
     * @throws JsonException
     * @throws InvalidArgumentException
     */
    public function search(): ArrayCollection
    {
        $cache_key = $this->generator->generate(
            $this->repository->getEndpoint(),
            json_encode(static::$filter_params, JSON_THROW_ON_ERROR)
        );

        return $this->cache->get($cache_key, function (ItemInterface $item) {
            $search_results = $this->doSearch();
            if (!$search_results->isEmpty()) {
                $item->set($search_results);
                $item->expiresAfter($this->getCacheTTL());
                if ($this->supportsTagging()) {
                    $item->tag([$search_results->first()->getEntityName() . "_search_results"]);
                }
            }

            return $search_results;
        });
    }

    public function getClient(): ClientInterface
    {
        return $this->repository->getClient();
    }

    public function getAllowedFilters(): array
    {
        return $this->repository->getAllowedFilters();
    }

    public function getRelationClassMap(): array
    {
        return $this->repository->getRelationClassMap();
    }

    public function getEndpoint(): string
    {
        return $this->repository->getEndpoint();
    }

    public function constructEndpointUrl(string $endpoint, array $params): string
    {
        return $this->repository->constructEndpointUrl($endpoint, $params);
    }

    public function addRelationToFetch(string $relation): void
    {
        $this->repository->addRelationToFetch($relation);
    }

    public function getModelClass(): string
    {
        return $this->repository->getModelClass();
    }

    public function __call(string $method, array $args): mixed
    {
        if (method_exists($this->repository, $method)) {
            return call_user_func_array([$this->repository, $method], $args);
        }

        return null;
    }

    /**
     * @throws InvalidArgumentException
     */
    protected function cacheModel(AbstractModel $model): ?AbstractModel
    {
        $cache_key = $this->generator->generate($model->getEntityName(), $model->getId());

        $this->cache->delete($cache_key);
        return $this->cache->get($cache_key, function (ItemInterface $item) use ($model) {
            $item->set($model);
            $item->expiresAfter($this->getCacheTTL());
            if ($this->supportsTagging()) {
                $this->cache->invalidateTags([$model->getEntityName() . "_search_results"]);
                $item->tag([$model->getEntityName()]);
            }

            return $model;
        });
    }

    protected function getCacheTTL(): int
    {
        return $this->options[ClientOptions::CLIENT_OPTIONS_CACHE_TTL] ?? ClientOptions::CACHE_DEFAULT_TTL;
    }

    protected function supportsTagging(): bool
    {
        return $this->cache instanceof TagAwareCacheInterface;
    }

    public static function getRelationClassFor(string $relation): ?string
    {
        return null;
    }

    public function getFetchRelations(): array
    {
        return $this->repository->getFetchRelations();
    }
}