Halalsoft\LaravelDynamicColumn\DynamicBuilder

Complexity

Total Complexity

23

Size/Duplication

Total Lines	115
Duplicated Lines	0 %

Importance

Changes	2
Bugs	0	Features	0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	whereDynamicExists()	0	11	2
A	where()	0	12	5
A	__construct()	0	11	3
B	whereNull()	0	17	7
A	get()	0	21	6

<?php

namespace Halalsoft\LaravelDynamicColumn;

use Closure;
use Illuminate\Support\Arr;
use Illuminate\Support\Collection;
use Illuminate\Support\Facades\DB;
use Illuminate\Database\ConnectionInterface;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Query\Builder as QueryBuilder;
use Illuminate\Database\Query\Expression;
use Illuminate\Database\Query\Grammars\Grammar;
use Illuminate\Database\Query\Processors\Processor;

class DynamicBuilder extends QueryBuilder
{

    private $model;
    private $dynamicColumns;

    public function __construct(
        ConnectionInterface $connection,
        Grammar $grammar = null,
        Processor $processor = null,
        Model $model = null
    ) {
        $this->connection     = $connection;
        $this->grammar        = $grammar ?: $connection->getQueryGrammar();
        $this->processor      = $processor ?: $connection->getPostProcessor();
        $this->model          = $model;
        $this->dynamicColumns = $this->model->getDynamicColumns() ?? [];

The method getDynamicColumns() does not exist on null.

    }


    /**
     * Override a basic where clause to the query.
     *
     * @param  Closure|string|array  $column
     * @param  mixed  $operator
     * @param  mixed  $value
     * @param  string  $boolean
     *
     * @return $this
     */
    public function where($column, $operator = null, $value = null, $boolean = 'and')
    {
        if ($this->model !== null && !empty($this->dynamicColumns)) {
            if (strpos($column, '->')) {
                $parts = explode('->', $column, 2);
                if (in_array($parts[0], $this->dynamicColumns)) {

It seems like $this->dynamicColumns can also be of type Illuminate\Database\Eloquent\Builder; however, parameter $haystack of in_array() does only seem to accept array, maybe add an additional type check?

                    $column = DB::raw("COLUMN_GET(`$parts[0]`, '$parts[1]' as char)");
                }
            }
        }

        parent::where($column, $operator, $value, $boolean);
    }


    /**
     * Add a "where null" clause to the query.
     *
     * @param  string|array  $columns
     * @param  string  $boolean
     * @param  bool  $not
     *
     * @return $this
     */
    public function whereNull($columns, $boolean = 'and', $not = false)
    {
        $type = $not ? 'NotNull' : 'Null';

        foreach (Arr::wrap($columns) as $column) {
            if ($this->model !== null && !empty($this->dynamicColumns)) {
                if (strpos($column, '->')) {
                    $parts = explode('->', $column, 2);
                    if (in_array($parts[0], $this->dynamicColumns)) {

It seems like $this->dynamicColumns can also be of type Illuminate\Database\Eloquent\Builder; however, parameter $haystack of in_array() does only seem to accept array, maybe add an additional type check?

                        $column = DB::raw("COLUMN_GET(`$parts[0]`, '$parts[1]' as char)");
                    }
                }
            }
            $this->wheres[] = compact('type', 'column', 'boolean');
        }

        return $this;
    }


    public function whereDynamicExists($column, $value = null, $boolean = 'and', $not = false)
    {
        $type = 'DynamicColumnExists';

        $this->wheres[] = compact('type', 'column', 'value', 'boolean', 'not');

        if (!$value instanceof Expression) {
            $this->addBinding($this->grammar->prepareBindingForJsonContains($value));
        }

        return $this;
    }

    /**
     * Execute the query as a "select" statement.
     *
     * @param  array|string  $columns
     *
     * @return Collection
     */
    public function get($columns = ['*'])
    {
        if ($this->model !== null && !empty($this->dynamicColumns)) {
            $i = 0;
            foreach ($this->wheres as $where) {
                if (strpos($where['column'], '->')) {
                    $parts = explode('->', $where['column'], 2);
                    if (in_array($parts[0], $this->dynamicColumns)) {

It seems like $this->dynamicColumns can also be of type Illuminate\Database\Eloquent\Builder; however, parameter $haystack of in_array() does only seem to accept array, maybe add an additional type check?

                        $this->wheres[$i]['column'] = DB::raw("COLUMN_GET(`$parts[0]`, '$parts[1]' as char)");
                    }
                }

                $i++;
            }
        }

        return collect(
            $this->onceWithColumns(
                Arr::wrap($columns),
                function() {
                    return $this->processor->processSelect($this, $this->runSelect());
                }
            )
        );
    }

}