Mostafaznv\LaraCache\Traits\InteractsWithCache

Complexity

Total Complexity

32

Size/Duplication

Total Lines	128
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	retrieve()	0	10	2
A	updateCacheEntity()	0	13	2
A	findCacheEntity()	0	13	4
A	__construct()	0	5	1
A	deleteCacheEntity()	0	8	2
A	getEntityFullName()	0	3	1
A	storeCache()	0	9	2
A	updateCacheEntitiesList()	0	22	5
B	entityIsCallable()	0	7	9
A	callCacheClosure()	0	12	4

<?php

namespace Mostafaznv\LaraCache\Traits;

use Illuminate\Support\Facades\Cache;
use Illuminate\Support\Str;
use Mostafaznv\LaraCache\CacheEntity;
use Mostafaznv\LaraCache\DTOs\CacheData;
use Mostafaznv\LaraCache\DTOs\CacheEvent;
use Mostafaznv\LaraCache\DTOs\CacheStatus;
use Mostafaznv\LaraCache\Exceptions\CacheEntityDoesNotExist;

trait InteractsWithCache
{
    private string $prefix;
    private mixed  $model;
    private string $laracacheListKey;

    public function __construct(string $model)
    {
        $this->prefix = Str::kebab(class_basename($model));
        $this->model = $model;
        $this->laracacheListKey = config('laracache.laracache-list');
    }


    private function getEntityFullName(CacheEntity $entity): string
    {
        return $this->prefix . '.' . $entity->name;
    }

    private function findCacheEntity(string $name, ?CacheEntity $entity = null): CacheEntity
    {
        if ($entity) {
            return $entity;
        }

        foreach ($this->model::cacheEntities() as $cacheEntity) {
            if ($cacheEntity->name === $name) {
                return $cacheEntity;
            }
        }

        throw CacheEntityDoesNotExist::make($name, $this->model);
    }

    private function entityIsCallable(CacheEntity $entity, ?CacheEvent $event = null): bool
    {
        return is_null($event)
            or ($event->equals(CacheEvent::CREATED()) and $entity->refreshAfterCreate)
            or ($event->equals(CacheEvent::UPDATED()) and $entity->refreshAfterUpdate)
            or ($event->equals(CacheEvent::DELETED()) and $entity->refreshAfterDelete)
            or ($event->equals(CacheEvent::RESTORED()) and $entity->refreshAfterRestore);
    }

    private function callCacheClosure(CacheEntity $entity, int $ttl, bool $delete = false): CacheData
    {
        if ($delete) {
            return CacheData::make(CacheStatus::DELETED(), $ttl, $entity->default);
        }

        $value = $entity->cacheClosure ? call_user_func($entity->cacheClosure) : null;

        return CacheData::make(
            status: CacheStatus::CREATED(),
            ttl: $ttl,
            value: $value ?: $entity->default
        );
    }

    private function updateCacheEntitiesList(CacheEntity $entity): void
    {
        $name = $this->getEntityFullName($entity);
        $list = Cache::store($entity->driver)->get($this->laracacheListKey);

        if (is_array($list)) {
            if (isset($list[$this->model]) and is_array($list[$this->model])) {
                if (!in_array($name, $list[$this->model])) {
                    $list[$this->model][] = $name;
                }
            }
            else {
                $list[$this->model] = [$name];
            }
        }
        else {
            $list = [
                $this->model => [$name]
            ];
        }

        Cache::store($entity->driver)->forever($this->laracacheListKey, $list);
    }

    private function storeCache(CacheData $cache, CacheEntity $entity, int $ttl): void
    {
        $name = $this->getEntityFullName($entity);

        is_null($cache->expiration)
            ? Cache::store($entity->driver)->forever($name, $cache)
            : Cache::store($entity->driver)->put($name, $cache, $ttl);

        $this->updateCacheEntitiesList($entity);
    }

    private function updateCacheEntity(string $name, ?CacheEvent $event = null, CacheEntity $entity = null): CacheData
    {
        $entity = $this->findCacheEntity($name, $entity);

        if ($this->entityIsCallable($entity, $event)) {
            $ttl = $entity->getTtl();
            $cache = $this->callCacheClosure($entity, $ttl);
            $this->storeCache($cache, $entity, $ttl);

            return $cache;
        }

        return CacheData::fromCache($entity, $this->prefix);
    }

    private function deleteCacheEntity(string $name, bool $deleteForever = false, CacheEntity $entity = null): CacheData
    {
        $entity = $this->findCacheEntity($name, $entity);
        $ttl = !$deleteForever ? $entity->getTtl() : 0;
        $cache = $this->callCacheClosure($entity, $ttl, true);
        $this->storeCache($cache, $entity, $ttl);

        return $cache;
    }

    private function retrieve(string $name): CacheData
    {
        $entity = $this->findCacheEntity($name);
        $cache = CacheData::fromCache($entity, $this->prefix);

        if ($cache->status->equals(CacheStatus::NOT_CREATED())) {
            return $this->updateCacheEntity($name, null, $entity);
        }

        return $cache;
    }
}