fomvasss / laravel-variables

src/VariableManager.php

<?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 $useCache;

    /**
     * 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->useCache = $this->config['cache']['is_use_cache'] ?? true;

        $this->variableModel = $variableModel;

        $this->cacheRepository = $cacheRepository;
    }

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

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

        return $this->getCollection($useCache);
    }

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

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

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

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

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 $key
     * @param array $default
     * @param string|null $langcode
     * @param bool|null $useCache
     * @return array|mixed
     */
    public function getArray(string $key, $default = [], ?string $langcode = null, ?bool $useCache = null)
    {
        $res = json_decode($this->get($key, '[]', $langcode, $useCache), true);

        return  empty($res) ? $default : $res;
    }

    /**
     * @param string $key
     * @param array $value
     * @param string|null $langcode
     * @return mixed
     */
    public function saveArray(string $key, $value = [], ?string $langcode = null)
    {
        $value = json_encode($value);

        return $this->save($key, $value, $langcode);
    }

    /**
     * @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->useCache = $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 $useCache): \Illuminate\Database\Eloquent\Collection
    {
        try {
            if ($useCache) {
                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;
    }
}