Sco\Admin\Config\ModelConfig

Complexity

Total Complexity

12

Size/Duplication

Total Lines	135
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	15	1
A	getRepository()	0	4	1
A	parseRows()	0	14	4
A	get()	0	16	2
A	delete()	0	4	1
A	usePagination()	0	4	1
A	getConfigValues()	0	14	2

<?php

namespace Sco\Admin\Config;

use Illuminate\Config\Repository as ConfigRepository;
use Illuminate\Foundation\Application;
use JsonSerializable;
use Illuminate\Contracts\Support\Arrayable;
use Illuminate\Contracts\Support\Jsonable;
use Sco\Admin\Contracts\Config as ConfigContract;
use Sco\Admin\Contracts\Repository as RepositoryContract;
use Sco\Attributes\HasAttributesTrait;

class ModelConfig implements Arrayable, Jsonable, JsonSerializable
{
    use HasAttributesTrait;

    /**
     * @var \Illuminate\Foundation\Application
     */
    protected $app;

    /**
     * @var \Sco\Admin\Contracts\Config
     */
    protected $configFactory;
    /**
     * @var \Illuminate\Database\Eloquent\Model
     */
    //protected $model;

    /**
     * @var mixed|\Sco\Admin\Repositories\Repository
     */
    protected $repository;

    protected $config;

    public function __construct(Application $app, ConfigContract $factory)
    {
        $this->app = $app;
        $this->configFactory = $factory;
        //$this->model = $model;

50% of this comment could be valid code. Did you maybe forget this after debugging?

        $this->config = new ConfigRepository(
            $this->getConfigValues()
        );

        $this->repository = $this->app->make(RepositoryContract::class);

        $this->repository->setClass(
            $this->config->get('class')
        );
    }

    /**
     * @return mixed|\Sco\Admin\Repositories\Repository
     */
    public function getRepository()
    {
        return $this->repository;
    }

    protected function parseRows($rows)
    {
        $data = collect();
        if ($rows) {
            foreach ($rows as $row) {
                $newRow = collect();
                foreach ($this->configFactory->getColumns() as $column) {
                    $newRow->put($column->getName(), $column->setModel($row)->render());
                }
                $data->push($newRow);
            }
        }
        return $data;
    }

    public function get()
    {
        $orderBy = $this->config->get('orderBy', [$this->getRepository()->getKeyName(), 'desc']);
        $query = $this->getRepository()->orderBy($orderBy[0], $orderBy[1]);

        if ($this->usePagination()) {
            $data = $query->paginate($this->config->get('perPage'));

            $data->setCollection($this->parseRows($data->items()));
        } else {
            $data = $this->parseRows($query->get());
        }


        return $data;
    }

    public function delete($id)

The parameter $id is not used and could be removed.

    {

    }

    protected function usePagination()
    {
        return $this->config->get('perPage') > 0;
    }

    protected function getConfigValues()
    {
        $config = $this->configFactory->getConfigRepository()->get('model');
        if (is_string($config)) {
            $config = [
                'class' => $config
            ];
        }
        $config = array_merge([
            //'orderBy' => [],

72% of this comment could be valid code. Did you maybe forget this after debugging?

            'perPage' => 10,
        ], $config);
        return $config;
    }

    /**
     * Handle dynamic method calls into the model.
     *
     * @param  string  $method
     * @param  array  $parameters
     * @return mixed
     */
    /*public function __call($method, $parameters)

66% of this comment could be valid code. Did you maybe forget this after debugging?

    {
        if (in_array($method, ['getKeyName'])) {
            return $this->model->$method(...$parameters);
        }

        $this->model = $this->model->$method(...$parameters);
        return $this;
    }*/

    /**
     * Handle dynamic static method calls into the method.
     *
     * @param  string  $method
     * @param  array  $parameters
     * @return mixed
     */
    /*public static function __callStatic($method, $parameters)

69% of this comment could be valid code. Did you maybe forget this after debugging?

    {
        return (new static)->$method(...$parameters);
    }*/
}