Fomvasss\Variable\VariableManager

Complexity

Total Complexity

22

Size/Duplication

Total Lines	168
Duplicated Lines	0 %

Importance

Changes	8
Bugs	3	Features	1

9 Methods

Rating	Name	Duplication	Size	Complexity
A	cacheClear()	0	3	1
A	useCache()	0	5	1
A	setLang()	0	5	1
A	getVariableModel()	0	3	1
A	__construct()	0	14	2
A	getCollection()	0	17	3
A	all()	0	12	4
A	save()	0	7	2
B	get()	0	24	7

<?php

namespace Fomvasss\Variable;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Collection;

/**
 * Class VariableManager
 *
 * @package \Fomvasss\Variable
 */
class VariableManager implements VariableManagerContract
{
    protected $app;

    /** @var \Fomvasss\Variable\Models\Variable */
    protected $variableModel;

    /** @var \Illuminate\Cache\Repository */
    protected $cacheRepository;

    /** @var string */
    protected $langcode = null;

    /** @var \Illuminate\Database\Eloquent\Collection */
    protected $variables = null;

    /** @var bool */
    protected $isUseCache;

    /**
     * VariableManager constructor.
     * @param $variableModel
     * @param $cacheRepository
     * @param null $app

Are you sure the doc-type for parameter $app is correct as it would always require null to be passed?

     */
    public function __construct($variableModel, $cacheRepository, $app = null)
    {
        if (! $app) {

$app is of type null, thus it always evaluated to false.

            $app = app();   //Fallback when $app is not given

The function app was not found. Maybe you did not declare it correctly or list all dependencies?

        }
        $this->app = $app;

        $this->config = $this->app['config']->get('variables');

The property config does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        
        $this->isUseCache = $this->config['cache']['is_use_cache'] ?? true;

        $this->variableModel = $variableModel;

        $this->cacheRepository = $cacheRepository;
    }

    /**
     * @param string|null $langcode
     * @param bool|null $isUseCache
     * @return array|\Illuminate\Database\Eloquent\Collection
     */
    public function all(?string $langcode = null, ?bool $isUseCache = null)
    {
        $langcode = $langcode ?: $this->langcode;
        $isUseCache = $isUseCache === null
            ? $this->isUseCache
            : $isUseCache;

        if ($langcode) {
            return $this->getCollection($isUseCache)->where('langcode', $langcode);
        }

        return $this->getCollection($isUseCache);
    }
    
    /**
     * @param string $key
     * @param null $default

Are you sure the doc-type for parameter $default is correct as it would always require null to be passed?

     * @param string|null $langcode
     * @param bool $useCache
     * @return mixed|null
     */
    public function get(string $key, $default = null, ?string $langcode = null, ?bool $isUseCache = null)
    {
        $langcode = $langcode ?: $this->langcode;
        $isUseCache = $isUseCache === null
            ? $this->isUseCache
            : $isUseCache;

        if ($var = $this->getCollection($isUseCache)
            ->where('key', $key)
            ->where('langcode', $langcode)
            ->first()) {

            return $var->value ?: $default;
        }

        if ($var = $var = $this->getCollection($isUseCache)

The assignment to $var is dead and can be removed.

            ->where('key', $key)
            ->where('langcode', null)
            ->first()) {

            return $var->value ?: $default;
        }
        
        return $default;
    }

    /**
     * @param string $key
     * @param null $value

Are you sure the doc-type for parameter $value is correct as it would always require null to be passed?

     * @param string|null $langcode
     * @return mixed
     */
    public function save(string $key, $value = null, ?string $langcode = null)
    {
        return $this->getVariableModel()->updateOrCreate([
            'key' => $key,
            'langcode' => $langcode ?: $this->langcode,
        ], [
            'value' => $value,
        ]);
    }

    /**
     * @param string|null $langcode
     * @return $this
     */
    public function setLang(?string $langcode = null): VariableManagerContract
    {
        $this->langcode = $langcode;

        return $this;
    }

    /**
     * @param bool $val
     * @return $this|mixed
     */
    public function useCache(bool $val = true): VariableManagerContract
    {
        $this->isUseCache = $val;
        
        return $this;
    }

    /**
     * @return bool
     */
    public function cacheClear()
    {
        return $this->cacheRepository->forget($this->config['cache']['name']);
    }

    /**
     * @return \Illuminate\Database\Eloquent\Collection
     */
    protected function getCollection(bool $isUseCache): \Illuminate\Database\Eloquent\Collection
    {
        try {
            if ($isUseCache) {
                return $this->cacheRepository->remember(

The expression return $this->cacheRepository->remember($this->config['cache']['name'], $this->config['cache']['time'], function(...) { /* ... */ }) could return the type array which is incompatible with the type-hinted return Illuminate\Database\Eloquent\Collection. Consider adding an additional type-check to rule them out.

                    $this->config['cache']['name'],
                    $this->config['cache']['time'],
                    function () {
                        return $this->getVariableModel()->all();
                    });  
            } else {
                return $this->getVariableModel()->all();
            }
        } catch (\Exception $exception) {
            $this->app['log']->warning($exception->getMessage());

            return new \Illuminate\Database\Eloquent\Collection;
        }
    }

    /**
     * @return Model
     */
    protected function getVariableModel(): Model
    {
        return $this->variableModel;
    }
}