Terranet\Administrator\Decorators\Grid

Complexity

Total Complexity

30

Size/Duplication

Total Lines	131
Duplicated Lines	0 %

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	realColum()	0	3	1
B	make()	0	39	11
C	detectField()	0	46	15
A	__construct()	0	3	2
A	fetchTablesColumns()	0	3	1

<?php

namespace Terranet\Administrator\Decorators;

use function admin\db\connection;
use function admin\db\enum_values;
use function admin\db\translated_values;
use Czim\Paperclip\Contracts\AttachableInterface;
use Illuminate\Database\Eloquent\Model;
use Terranet\Administrator\Field\Boolean;
use Terranet\Administrator\Field\Email;
use Terranet\Administrator\Field\Enum;
use Terranet\Administrator\Field\File;
use Terranet\Administrator\Field\Generic;
use Terranet\Administrator\Field\Id;
use Terranet\Administrator\Field\Image;
use Terranet\Administrator\Field\Link;
use Terranet\Administrator\Field\Phone;
use Terranet\Administrator\Field\Rank;
use Terranet\Administrator\Field\Text;
use Terranet\Administrator\Field\Textarea;
use Terranet\Rankable\Rankable;

The type Terranet\Rankable\Rankable was not found. Maybe you did not declare it correctly or list all dependencies?

use Terranet\Translatable\Translatable;

class Grid
{
    /** @var Model */
    private $model;

    /**
     * Grid constructor.
     *
     * @param null|Model $model
     */
    public function __construct(Model $model = null)
    {
        $this->model = $model ?: app('scaffold.module')->model();

The method model() does not exist on Illuminate\Foundation\Application.

    }

    /**
     * @param $element
     *
     * @return mixed|\Terranet\Administrator\Field\Generic
     */
    public function make($element)
    {
        // decorate attachment
        if ($this->model instanceof AttachableInterface
            && method_exists($this->model, 'getAttachedFiles')
            && array_key_exists($element, $this->model->getAttachedFiles())

It seems like $this->model->getAttachedFiles() can also be of type mixed and Illuminate\Database\Eloquent\Builder; however, parameter $search of array_key_exists() does only seem to accept array, maybe add an additional type check?

        ) {
            $file = $this->model->getAttachedFiles()[$element];
            if ($file->variants()) {
                return Image::make($element, $element);
            }

            return File::make($element, $element);
        }

        // decorate translatable attachment
        if ($this->model instanceof Translatable) {
            $translation = $this->model->getTranslationModel();

            if ($translation instanceof AttachableInterface
                && method_exists($translation, 'getAttachedFiles')
                && array_key_exists($element, $translation->getAttachedFiles())

It seems like $translation->getAttachedFiles() can also be of type Czim\Paperclip\Contracts\AttachableInterface&object and Illuminate\Database\Eloquent\Builder&Czim\Paperclip\Contracts\AttachableInterface&object; however, parameter $search of array_key_exists() does only seem to accept array, maybe add an additional type check?

            ) {
                return Image::make($element);
            }
        }

        // decorate table column
        if ($this->realColum($element)) {
            $field = $this->detectField($element);

            if (is_object($field)) {
                return $field;
            }

            return forward_static_call_array([$field, 'make'], [$element, $element]);
        }

        return Text::make($element, $element);
    }

    /**
     * @param $column
     *
     * @return bool
     */
    protected function realColum($column)
    {
        return array_key_exists($column, $this->fetchTablesColumns());
    }

    /**
     * @param $column
     *
     * @return Generic
     */
    protected function detectField($column)
    {
        if ($column === $this->model->getKeyName()) {
            return Id::class;

The expression return Terranet\Administrator\Field\Id::class returns the type string which is incompatible with the documented return type Terranet\Administrator\Field\Generic.

        }

        $data = $this->fetchTablesColumns()[$column];
        $className = class_basename($data->getType());

        switch (true) {
            case $this->model instanceof Rankable && $column === $this->model->getRankableColumn():
                return Rank::class;

The expression return Terranet\Administrator\Field\Rank::class returns the type string which is incompatible with the documented return type Terranet\Administrator\Field\Generic.

            case in_array($className, ['TimeType', 'DateType', 'DateTimeType'], true):
                $type = str_replace('Type', '', $className);

                return "\\Terranet\\Administrator\\Field\\{$type}";

The expression return '\\Terranet\\Administrator\\Field\\'.$type returns the type string which is incompatible with the documented return type Terranet\Administrator\Field\Generic.

            case 'BooleanType' === $className:
                return Boolean::class;

The expression return Terranet\Administrator\Field\Boolean::class returns the type string which is incompatible with the documented return type Terranet\Administrator\Field\Generic.

            case 'TextType' === $className:
                return Textarea::class;

The expression return Terranet\Administrator\Field\Textarea::class returns the type string which is incompatible with the documented return type Terranet\Administrator\Field\Generic.

            case 'StringType' === $className:
                if (connection('mysql') && !$data->getLength()) {
                    if ($values = enum_values($this->model->getTable(), $column)) {
                        $values = translated_values($values, app('scaffold.module')->url(), $column);

The method url() does not exist on Illuminate\Foundation\Application.

                        if (!$data->getNotNull()) {
                            $values = ['' => '----'] + $values;
                        }

                        return Enum::make($column, $column)->setOptions($values);
                    }
                }

                if (str_contains($column, 'email')) {
                    return Email::class;

The expression return Terranet\Administrator\Field\Email::class returns the type string which is incompatible with the documented return type Terranet\Administrator\Field\Generic.

                }

                if (str_contains($column, ['url', 'site', 'host'])) {
                    return Link::class;

The expression return Terranet\Administrator\Field\Link::class returns the type string which is incompatible with the documented return type Terranet\Administrator\Field\Generic.

                }

                if (str_contains($column, ['phone', 'gsm'])) {
                    return Phone::class;

The expression return Terranet\Administrator\Field\Phone::class returns the type string which is incompatible with the documented return type Terranet\Administrator\Field\Generic.

                }
            // no break
            default:
                return Text::class;

The expression return Terranet\Administrator\Field\Text::class returns the type string which is incompatible with the documented return type Terranet\Administrator\Field\Generic.

        }
    }

    /**
     * @return array
     */
    protected function fetchTablesColumns()
    {
        return \admin\db\table_columns($this->model, true);
    }
}