Laravel\DataTables\Services\BaseDataTableService

Complexity

Total Complexity

25

Size/Duplication

Total Lines	263
Duplicated Lines	0 %

Importance

Changes	6
Bugs	0	Features	0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	getUpdatableColumns()	0	7	2
A	getCustomColumnNames()	0	7	2
A	buildSearchQuery()	0	7	1
A	getColumnsWithoutPrimaryKey()	0	6	1
A	getDatabaseColumnNames()	0	3	1
A	getSelectableColumns()	0	7	2
A	getRecords()	0	25	5
A	response()	0	12	1
A	getModel()	0	11	2
A	getTable()	0	3	1
A	builder()	0	13	3
A	getDisplayableColumns()	0	9	2
A	hasSearchQuery()	0	3	1
A	resolveQueryParts()	0	31	1

<?php

namespace Laravel\DataTables\Services;

use Arr;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Collection;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\QueryException;
use Illuminate\Http\Request;
use Illuminate\Support\Traits\Macroable;
use Laravel\DataTables\Contracts\Displayable;
use Laravel\DataTables\Exceptions\EloquentBuilderWasSetToNullException;
use Laravel\DataTables\Exceptions\InvalidColumnSearchException;
use Schema;

abstract class BaseDataTableService implements Displayable
{
    use Macroable;

The trait Illuminate\Support\Traits\Macroable requires the property $name which is not provided by Laravel\DataTables\Services\BaseDataTableService.

    /**
     * Load the relationships associated with the collection that will be returned.
     *
     * @var array
     */
    public $relations;

    /**
     * Get/Set the eloquent builder.
     *
     * @return \Illuminate\Database\Eloquent\Builder
     */
    public function builder(): Builder
    {
        /**
         * @var mixed
         */
        static $builder = null;

        if (! is_null($builder) && ! app()->environment('testing')) {

The method environment() does not exist on Illuminate\Container\Container. Are you sure you never get this type here, but always one of the subclasses?

            return $builder;
        }
        $builder = $this->query()->newQuery();

        return $builder;
    }

    /**
     * @param $columns
     */
    public function getColumnsWithoutPrimaryKey($columns)
    {
        $primaryKey = $this->getModel()->getKeyName();

        return array_filter($columns, function ($column) use ($primaryKey) {
            return $primaryKey !== $column;
        });
    }

    /**
     * Get Custom Column Names.
     *
     * @return array
     */
    public function getCustomColumnNames(): array
    {
        if (method_exists($model = $this->getModel(), 'getCustomColumnNames')) {
            return $model->getCustomColumnNames();
        }

        return [];
    }

    /**
     * Get displayable columns.
     *
     * @return array
     */
    public function getDisplayableColumns(): array
    {
        if (method_exists($model = $this->getModel(), 'getDisplayableColumns')) {
            return $model->getDisplayableColumns();
        }

        return array_diff(
            $this->getDatabaseColumnNames(),
            $this->getModel()->getHidden()
        );
    }

    /**
     * @return mixed
     */
    public function getModel(): Model
    {
        /**
         * @var mixed
         */
        static $model = null;
        if (! is_null($model)) {
            return $model;
        }

        return $model = $this->builder()->getModel();
    }

    /**
     * Fetch records from the database.
     *
     * @param  Request    $request
     * @param  callable   $callback
     * @return Collection
     */
    public function getRecords(Request $request = null, callable $callback = null): Collection
    {
        $builder = $this->builder();

        // we will check if the request has a query string for search. the query string for searching must contain column, operator which identified at resolveQueryParts method in form of the keys of the array. and the value that user is trying to search for
        // example: http://localhost:8000/api/posts?column=title&operator=contains&value=hello
        if ($request && $this->hasSearchQuery($request)) {
            $builder = $this->buildSearchQuery($builder, $request);
        }

        // Turn on the flexibility for the programmer to apply his own query to chain on the current query then we will retrieve back the query builder after the programmer applies his logic and proceed our own queries.
        if ($callback) {
            $builder = $callback($builder);
            throw_unless($builder, new EloquentBuilderWasSetToNullException);
        }

        // we will try to parse the query and return the output of it, if anything goes wrong, by default we will be returning an empty collection.
        try {
            // if the request doesn't have a limit, it will return null, and since limit takes an integer value >= 0, then it won't limit
            // at all since we will replace the null with a negative number.
            return $builder->select(...$this->getSelectableColumns())->limit(
                $request->limit ?? -1
            )->get();
        } catch (QueryException $e) {
            return collect([]);
        }
    }

    /**
     * @return mixed
     */
    public function getSelectableColumns(): array
    {
        if (method_exists($model = $this->getModel(), 'getSelectableColumns')) {
            return $model->getSelectableColumns();
        }

        return $this->getDisplayableColumns();
    }

    /**
     * Get The Table Name.
     *
     * @return string
     */
    public function getTable(): string
    {
        return $this->getModel()->getTable();
    }

    /**
     * @return array
     */
    public function getUpdatableColumns(): array
    {
        if (method_exists($this->getModel(), 'getUpdatableColumns')) {
            return $this->getColumnsWithoutPrimaryKey($this->getModel()->getUpdatableColumns());
        }

        return $this->getColumnsWithoutPrimaryKey($this->getDisplayableColumns());
    }

    /**
     * Get query source of dataTable.
     *
     * @return \Illuminate\Database\Eloquent\Builder
     */
    abstract public function query(): Builder;

    /**
     * Return the response skeleton.
     *
     * @return array
     */
    public function response(callable $callback = null): array
    {
        return [
            'table' => $this->getTable(),
            'displayable' => $this->getDisplayableColumns(),
            'records' => $this->getRecords(request(), $callback)->load((array) $this->relations),
            'updatable' => $this->getUpdatableColumns(),
            'custom_columns' => $this->getCustomColumnNames(),
            'allow' => [
                'creatable' => $this->allowCreating ?? false,

The property allowCreating does not exist on Laravel\DataTables\Services\BaseDataTableService. Did you maybe forget to declare it?

                'deletable' => $this->allowDeleting ?? false,

The property allowDeleting does not exist on Laravel\DataTables\Services\BaseDataTableService. Did you maybe forget to declare it?

                'updatable' => $this->allowUpdating ?? false,

The property allowUpdating does not exist on Laravel\DataTables\Services\BaseDataTableService. Did you maybe forget to declare it?

            ],
        ];
    }

    /**
     * Build Search Query.
     *
     * @param  Builder $builder
     * @param  Request $request
     * @return Builder
     */
    protected function buildSearchQuery(Builder $builder, Request $request): Builder
    {
        [ 'operator' => $operator, 'value' => $value ] = $this->resolveQueryParts($request->operator, $request->value);

        throw_unless(in_array($request->column, $this->getDisplayableColumns()), InvalidColumnSearchException::class);

        return $builder->where($request->column, $operator, $value);
    }

    /**
     * Get Database Column Names.
     *
     * @return array
     */
    protected function getDatabaseColumnNames(): array
    {
        return Schema::getColumnListing($this->getTable());
    }

    /**
     * Check if the request has a search query.
     *
     * @param \Illuminate\Http\Request $request.
     * @return bool
     */
    protected function hasSearchQuery(Request $request): bool
    {
        return count(array_filter($request->only(['column', 'operator', 'value']))) === 3;
    }

    /**
     * Resolve Query Parts.
     *
     * @param string $operator
     * @param string $value
     *
     * @return array
     */
    protected function resolveQueryParts(string $operator, string $value): array
    {
        return Arr::get([
            'equals' => [
                'operator' => '=',
                'value' => $value,
            ],
            'contains' => [
                'operator' => 'LIKE',
                'value' => "%{$value}%",
            ],
            'starts_with' => [
                'operator' => 'LIKE',
                'value' => "{$value}%",
            ],
            'ends_with' => [
                'operator' => 'LIKE',
                'value' => "%{$value}",

            ],
            'greater_than' => [
                'operator' => '>',
                'value' => $value,

            ],
            'less_than' => [
                'operator' => '<',
                'value' => $value,

            ],
        ], $operator);
    }
}