Foundation\Cache\ModelCache

Complexity

Total Complexity

12

Size/Duplication

Total Lines	108
Duplicated Lines	0 %

Test Coverage

Coverage

96.97%

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	find()	0	3	1
A	clearAll()	0	4	1
A	findOrRequery()	0	4	1
A	store()	0	3	1
A	remove()	0	3	1
A	getCacheTime()	0	3	1
A	clearModel()	0	4	1
A	getCacheConnection()	0	7	2
A	getCacheName()	0	3	1
A	findWithoutRequery()	0	3	1
A	deleteWithPrefix()	0	6	1

<?php
/**
 * Created by PhpStorm.
 * User: arthur
 * Date: 11.10.18
 * Time: 14:11.
 */

namespace Foundation\Cache;

use Cache;
use Foundation\Exceptions\Exception;
use Illuminate\Support\Facades\Redis;

class ModelCache
{
    /**
     * @param $id
     * @param string $modelClass
     *
     * @return mixed
     */
    public static function find($id, $modelClass)
    {
        return Cache::get(self::getCacheName($id, $modelClass));
    }

    public static function findOrRequery($id, $modelClass)
    {
        return Cache::remember(self::getCacheName($id, $modelClass), self::getCacheTime(), function () use ($id, $modelClass) {
            return $modelClass::findWithoutCache($id);
        });
    }

    /**
     * @param string
     */
    public static function getCacheName($id, $modelClass)
    {
        return config('model.cache_prefix').':'.strtolower(get_short_class_name($modelClass)).':'.$id;
    }

    /**
     * @return \Illuminate\Config\Repository|mixed
     */
    private static function getCacheTime()
    {
        return config('model.cache_time');
    }

    /**
     * @param $id
     * @param string $modelClass
     *
     * @return mixed
     */
    public static function findWithoutRequery($id, $modelClass)
    {
        return Cache::get(self::getCacheName($id, $modelClass));
    }

    /**
     * @param \Eloquent $model
     */
    public static function store($model)
    {
        Cache::put(self::getCacheName($model->getKey(), $model), $model->fresh(), self::getCacheTime());
    }

    /**
     * @param $id
     * @param string $modelClass
     *
     * @return bool
     */
    public static function remove($id, $modelClass)
    {
        return Cache::forget(self::getCacheName($id, $modelClass));
    }

    public static function clearAll()
    {
        $pattern = config('model.cache_prefix');
        self::deleteWithPrefix($pattern);
    }

    /**
     * @param $prefix
     *
     * @throws Exception
     */
    private static function deleteWithPrefix($prefix)
    {
        $redis = self::getCacheConnection();
        $keyPattern = Cache::getPrefix().$prefix.'*';
        $keys = $redis->keys($keyPattern);
        $redis->delete($keys);
    }

    /**
     * @throws Exception
     *
     * @return \Illuminate\Redis\Connections\Connection
     */
    private static function getCacheConnection()
    {
        if (config('cache.default') === 'redis') {
            return Redis::connection('cache');
        }

        throw new Exception('This action is only possible with redis as cache driver');
    }

    /**
     * @param $modelClass
     *
     * @throws Exception
     */
    public static function clearModel($modelClass)
    {
        $pattern = config('model.cache_prefix').':'.strtolower(get_short_class_name($modelClass));
        self::deleteWithPrefix($pattern);
    }
}