Blasttech\EloquentRelatedPlus\RelatedPlusTrait

Complexity

Total Complexity

84

Size/Duplication

Total Lines	609
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	10

Importance

Changes

0

22 Methods

Rating	Name	Duplication	Size	Complexity
B	bootRelatedPlusTrait()	0	12	5
B	scopeModelJoin()	0	34	5
A	parseRelationNames()	0	17	3
B	scopeRelationJoin()	0	53	8
A	hasOneJoinSql()	0	14	1
A	joinOne()	0	11	1
A	getJoinColumns()	0	13	2
A	selectMinMax()	0	10	2
A	addBackticks()	0	5	2
A	toSqlWithBindings()	0	4	1
A	replacePlaceholders()	0	4	1
A	addWhereConstraints()	0	16	2
A	columnWithTableName()	0	4	2
A	hasManyJoin()	0	20	1
A	addOrder()	0	11	3
C	scopeOrderByCustom()	0	22	8
C	scopeOrderByCheckModel()	0	24	7
B	hasJoin()	0	15	5
C	scopeSetCustomOrder()	0	24	8
A	scopeSetSubquery()	0	9	1
B	scopeOrderByWith()	0	24	4
C	scopeSearch()	0	60	12

<?php

namespace Blasttech\EloquentRelatedPlus;

use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\BelongsTo;
use Illuminate\Database\Eloquent\Relations\HasMany;
use Illuminate\Database\Eloquent\Relations\HasOneOrMany;
use Illuminate\Database\Eloquent\Relations\Relation;
use Illuminate\Database\Query\Expression;
use Illuminate\Database\Query\JoinClause;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Schema;
use InvalidArgumentException;

/**
 * Trait RelatedPlusTrait
 *
 * @property array order_fields
 * @property array order_defaults
 * @property array order_relations
 * @property array order_with
 *
 * @package Blasttech\WherePlus
 */
trait RelatedPlusTrait
{
    /**
     * Boot method for trait
     *
     */
    public static function bootRelatedPlusTrait()
    {
        static::saving(function ($model) {
            if (!empty($model->nullable)) {
                foreach ($model->attributes as $key => $value) {
                    if (isset($model->nullable[$key])) {
                        $model->{$key} = empty(trim($value)) ? null : $value;
                    }
                }
            }
        });
    }

    /**
     * Add joins for one or more relations
     * This determines the foreign key relations automatically to prevent the need to figure out the columns.
     * Usages:
     * $query->modelJoin('customers')
     * $query->modelJoin('customer.client')
     *
     * @param Builder|RelatedPlus $query

Consider making the type for parameter $query a bit more specific; maybe use Builder.

     * @param string $relation_name
     * @param string $operator
     * @param string $type
     * @param bool $where
     * @param bool $related_select
     * @param string|null $direction
     *
     * @return Builder
     */
    public function scopeModelJoin(
        Builder $query,
        $relation_name,

$relation_name does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

        $operator = '=',
        $type = 'left',
        $where = false,
        $related_select = true,

$related_select does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

        $direction = null
    ) {
        /** @var Builder $this */
        $connection = $this->connection;

The property connection does not seem to exist in Illuminate\Database\Eloquent\Builder.

        foreach ($this->parseRelationNames($relation_name) as $relation) {

$relation_name does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

            $table_name = $relation->getRelated()->getTable();

$table_name does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

            // if using a 'table' AS 'table_alias' in a from statement, otherwise alias will be the table name
            $from = explode(' ', $relation->getQuery()->getQuery()->from);
            $table_alias = array_pop($from);

$table_alias does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

            if (empty($query->getQuery()->columns)) {
                /** @var Model $this */
                $query->select($this->getTable() . ".*");

The method select() does not exist on Illuminate\Database\Eloquent\Builder. Did you maybe mean createSelectWithConstraint()?

            }
            if ($related_select) {

$related_select does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

                foreach (Schema::connection($connection)->getColumnListing($table_name) as $related_column) {

$table_name does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

                    $query->addSelect(
                        new Expression("`$table_alias`.`$related_column` AS `$table_alias.$related_column`")

$table_alias does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

                    );
                }
            }
            $query->relationJoin($table_name, $table_alias, $relation, $operator, $type, $where, $direction);

$table_name does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

        }

        return $query;
    }

    /**
     * Get the relations from a relation name
     * $relation_name can be a single relation
     * Usage for User model:
     * parseRelationNames('customer') returns [$user->customer()]
     * parseRelationNames('customer.contact') returns [$user->customer(), $user->customer->contact()]
     *
     * @param $relation_name
     * @return Relation[]
     */
    protected function parseRelationNames($relation_name)

$relation_name does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

    {
        $relation_names = explode('.', $relation_name);

$relation_names does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

        $parent_relation_name = null;

$parent_relation_name does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

        $relations = [];

        foreach ($relation_names as $relation_name) {

$relation_names does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

            if (is_null($parent_relation_name)) {

$parent_relation_name does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

                $relations[] = $this->$relation_name();

$relation_name does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

                $parent_relation_name = $this->$relation_name()->getRelated();

$parent_relation_name does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

            } else {
                $relations[] = $parent_relation_name->$relation_name();

$parent_relation_name does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

            }
        }

        return $relations;
    }

    /**
     * Join a model
     *
     * @param Builder|RelatedPlus $query

Consider making the type for parameter $query a bit more specific; maybe use Builder.

     * @param string $table_name
     * @param string $table_alias
     * @param Relation $relation
     * @param string $operator
     * @param string $type
     * @param boolean $where
     * @param null $direction
     * @return Builder
     */
    public function scopeRelationJoin(
        Builder $query,
        $table_name,

$table_name does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

        $table_alias,

$table_alias does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

        $relation,
        $operator,
        $type,
        $where,
        $direction = null
    ) {
        if ($table_alias !== '' && $table_name !== $table_alias) {

$table_alias does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

            $full_table_name = $table_name . ' AS ' . $table_alias;

$full_table_name does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

        } else {
            $full_table_name = $table_name;

$full_table_name does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

        }

        return $query->join($full_table_name, function (JoinClause $join) use (

$full_table_name does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

            $table_name,
            $table_alias,
            $relation,
            $operator,
            $direction
        ) {
            // If a HasOne relation and ordered - ie join to the latest/earliest
            if (class_basename($relation) === 'HasOne' && !empty($relation->toBase()->orders)) {
                // Get first relation order (should only be one)
                $order = $relation->toBase()->orders[0];

                return $join->on($order['column'], $this->hasOneJoinSql($relation, $order));
            } else {
                // Get relation join columns
                $joinColumns = $this->getJoinColumns($relation);

                $first = $joinColumns->first;
                $second = $joinColumns->second;
                if ($table_name !== $table_alias) {

$table_name does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

                    $first = str_replace($table_name, $table_alias, $first);

$table_name does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

                    $second = str_replace($table_name, $table_alias, $second);

$table_name does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

                }

                $join->on($first, $operator, $second);

                // Add any where clauses from the relationship
                $join = $this->addWhereConstraints($join, $relation, $table_alias);

$table_alias does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

                if (!is_null($direction) && get_class($relation) === HasMany::class) {
                    $join = $this->hasManyJoin($join, $first, $relation, $table_alias, $direction);

$table_alias does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

It seems like $join can also be of type object<Illuminate\Database\Eloquent\Builder>; however, Blasttech\EloquentRelatedPlus\RelatedPlusTrait::hasManyJoin() does only seem to accept object<Illuminate\Database\Query\JoinClause>, maybe add an additional type check?

                }

                return $join;
            }
        }, null, null, $type, $where);
    }

    /**
     * Get join sql for a HasOne relation
     *
     * @param Relation $relation
     * @param array $order
     * @return Expression
     */
    public function hasOneJoinSql($relation, $order)
    {
        // Build subquery for getting first/last record in related table
        $subQuery = $this
            ->joinOne(
                $relation->getRelated()->newQuery(),
                $relation,
                $order['column'],
                $order['direction']
            )
            ->setBindings($relation->getBindings());

        return DB::raw('(' . $this->toSqlWithBindings($subQuery) . ')');
    }

    /**
     * Adds a where for a relation's join columns and and min/max for a given column
     *
     * @param Builder|RelatedPlus $query
     * @param Relation $relation
     * @param string $column
     * @param string $direction
     * @return mixed

Consider making the return type a bit more specific; maybe use Builder.

     */
    public function joinOne($query, $relation, $column, $direction)
    {
        // Get join fields
        $joinColumns = $this->getJoinColumns($relation);

        return $this->selectMinMax(
            $query->whereColumn($joinColumns->first, '=', $joinColumns->second),
            $column,
            $direction
        );
    }

    /**
     * Get the join columns for a relation
     *
     * @param Relation|BelongsTo|HasOneOrMany $relation
     * @return \stdClass
     */
    protected function getJoinColumns($relation)
    {
        // Get keys with table names
        if ($relation instanceof BelongsTo) {
            $first = $relation->getOwnerKey();
            $second = $relation->getForeignKey();
        } else {
            $first = $relation->getQualifiedParentKeyName();
            $second = $relation->getQualifiedForeignKeyName();
        }

        return (object)['first' => $first, 'second' => $second];
    }

    /**
     * Adds a select for a min or max on the given column, depending on direction given
     *
     * @param Builder|RelatedPlus $query
     * @param string $column
     * @param string $direction
     * @return Builder
     */
    public function selectMinMax($query, $column, $direction)
    {
        $column = $this->addBackticks($column);

        if ($direction == 'asc') {
            return $query->select(DB::raw('MIN(' . $column . ')'));
        } else {
            return $query->select(DB::raw('MAX(' . $column . ')'));
        }
    }

    /**
     * Add backticks to a table/column
     *
     * @param $column
     * @return string
     */
    private function addBackticks($column)
    {
        return preg_match('/^[0-9a-zA-Z\.]*$/', $column) ?
            '`' . str_replace(['`', '.'], ['', '`.`'], $column) . '`' : $column;
    }

    /**
     * Return the sql for a query with the bindings replaced with the binding values
     *
     * @param Builder $builder
     * @return string
     */
    private function toSqlWithBindings(Builder $builder)
    {
        return vsprintf($this->replacePlaceholders($builder), array_map('addslashes', $builder->getBindings()));
    }

    /**
     * Replace SQL placeholders with '%s'
     *
     * @param Builder $builder
     * @return mixed
     */
    private function replacePlaceholders(Builder $builder)
    {
        return str_replace(['?'], ['\'%s\''], $builder->toSql());
    }

    /**
     * Add wheres if they exist for a relation
     *
     * @param Builder|JoinClause $builder
     * @param Relation|BelongsTo|HasOneOrMany $relation
     * @param string $table
     * @return Builder|JoinClause
     */
    protected function addWhereConstraints($builder, $relation, $table)
    {
        // Get where clauses from the relationship
        $wheres = collect($relation->toBase()->wheres)
            ->where('type', 'Basic')
            ->map(function ($where) use ($table) {
                // Add table name to column if it is absent
                return [$this->columnWithTableName($table, $where['column']), $where['operator'], $where['value']];
            })->toArray();

        if (!empty($wheres)) {
            $builder->where($wheres);
        }

        return $builder;
    }

    /**
     * Add table name to column name if table name not already included in column name
     *
     * @param string $table
     * @param string $column
     * @return string
     */
    private function columnWithTableName($table, $column)
    {
        return (preg_match('/(' . $table . '\.|`' . $table . '`)/i', $column) > 0 ? '' : $table . '.') . $column;
    }

    /**
     * If the relation is one-to-many, just get the first related record
     *
     * @param JoinClause $joinClause
     * @param string $column
     * @param HasMany|Relation $relation
     * @param string $table
     * @param string $direction
     *
     * @return JoinClause
     */
    public function hasManyJoin(JoinClause $joinClause, $column, $relation, $table, $direction)
    {
        return $joinClause->where(
            $column,
            function ($subQuery) use ($table, $direction, $relation, $column) {
                $subQuery = $this->joinOne(
                    $subQuery->from($table),
                    $relation,
                    $column,
                    $direction
                );

                // Add any where statements with the relationship
                $subQuery = $this->addWhereConstraints($subQuery, $relation, $table);

                // Add any order statements with the relationship
                return $this->addOrder($subQuery, $relation, $table);
            }
        );
    }

    /**
     * Add orderBy if orders exist for a relation
     *
     * @param Builder|JoinClause $builder
     * @param Relation|BelongsTo|HasOneOrMany $relation
     * @param string $table
     * @return Builder
     */
    protected function addOrder($builder, $relation, $table)
    {
        if (!empty($relation->toBase()->orders)) {
            // Get where clauses from the relationship
            foreach ($relation->toBase()->orders as $order) {
                $builder->orderBy($this->columnWithTableName($table, $order['column']), $order['direction']);

The method orderBy does only exist in Illuminate\Database\Query\JoinClause, but not in Illuminate\Database\Eloquent\Builder.

            }
        }

        return $builder;
    }

    /**
     * Set the order of a model
     *
     * @param Builder|RelatedPlus $query

Consider making the type for parameter $query a bit more specific; maybe use Builder.

     * @param string $order_field
     * @param string $dir
     * @return Builder
     */
    public function scopeOrderByCustom(Builder $query, $order_field, $dir)

$order_field does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

    {
        if (!isset($this->order_fields) || !is_array($this->order_fields)) {
            throw new InvalidArgumentException(get_class($this) . ' order fields not set correctly.');
        }

        if (($order_field === '' || $dir === '')

$order_field does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

            && (!isset($this->order_defaults) || !is_array($this->order_defaults))) {
            throw new InvalidArgumentException(get_class($this) . ' order defaults not set and not overriden.');
        }

        // Remove order global scope if it exists
        /** @var Model $this */
        $global_scopes = $this->getGlobalScopes();

$global_scopes does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

        if (isset($global_scopes['order'])) {

$global_scopes does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

            $query->withoutGlobalScope('order');
        }

        $query->setCustomOrder($order_field, $dir);

$order_field does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

        return $query;
    }

    /**
     * Check if column being sorted by is from a related model
     *
     * @param Builder|RelatedPlus $query

Consider making the type for parameter $query a bit more specific; maybe use Builder.

     * @param string $column
     * @param string $direction
     * @return Builder
     */
    public function scopeOrderByCheckModel(Builder $query, $column, $direction)
    {
        $query->orderBy(DB::raw($column), $direction);

The method orderBy() does not exist on Illuminate\Database\Eloquent\Builder. Did you maybe mean enforceOrderBy()?

        $period_pos = strpos($column, '.');

$period_pos does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

        if (isset($this->order_relations) && ($period_pos !== false || isset($this->order_relations[$column]))) {

$period_pos does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

            $table = ($period_pos !== false ? substr($column, 0, $period_pos) : $column);

$period_pos does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

            if (isset($this->order_relations[$table]) &&
                !$this->hasJoin($query, $table, $this->order_relations[$table])) {
                $column_relations = $this->order_relations[$table];

$column_relations does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

                $query->modelJoin(
                    $column_relations,

$column_relations does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

                    '=',
                    'left',
                    false,
                    false
                );
            }
        }

        return $query;
    }

    /**
     * Check if this model has already been joined to a table or relation
     *
     * @param Builder $builder
     * @param string $table
     * @param \Illuminate\Database\Eloquent\Relations\Relation $relation
     * @return bool
     */
    protected function hasJoin(Builder $builder, $table, $relation)
    {
        $joins = $builder->getQuery()->joins;
        if (!is_null($joins)) {
            foreach ($joins as $JoinClause) {

$JoinClause does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

                if ($JoinClause->table == $table) {

$JoinClause does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

                    return true;
                }
            }
        }

        $eager_loads = $builder->getEagerLoads();

$eager_loads does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

        return !is_null($eager_loads) && in_array($relation, $eager_loads);

$eager_loads does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

    }

    /**
     * Set the model order
     *
     * @param Builder|RelatedPlus $query

Consider making the type for parameter $query a bit more specific; maybe use Builder.

     * @param string $column
     * @param string $direction
     * @return Builder
     */
    public function scopeSetCustomOrder(Builder $query, $column, $direction)
    {
        if (isset($this->order_defaults)) {
            // If $column not in order_fields list, use default
            if ($column == '' || !isset($this->order_fields[$column])) {
                $column = $this->order_defaults['field'];
            }

            // If $direction not asc or desc, use default
            if ($direction == '' || !in_array(strtoupper($direction), ['ASC', 'DESC'])) {
                $direction = $this->order_defaults['dir'];
            }
        }

        if (!is_array($this->order_fields[$column])) {
            $query->orderByCheckModel($this->order_fields[$column], $direction);
        } else {
            foreach ($this->order_fields[$column] as $db_field) {

$db_field does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

                $query->orderByCheckModel($db_field, $direction);

$db_field does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

            }
        }

        return $query;
    }

    /**
     * Switch a query to be a subquery of a model
     *
     * @param Builder|RelatedPlus $query

Consider making the type for parameter $query a bit more specific; maybe use Builder.

     * @param Builder $model
     * @return Builder
     */
    public function scopeSetSubquery(Builder $query, $model)
    {
        $sql = $this->toSqlWithBindings($model);
        $table = $model->getQuery()->from;

        return $query
            ->from(DB::raw("({$sql}) as " . $table))
            ->select($table . '.*');
    }

    /**
     * Use a model method to add columns or joins if in the order options
     *
     * @param Builder|RelatedPlus $query

Consider making the type for parameter $query a bit more specific; maybe use Builder.

     * @param string $order
     * @return Builder
     */
    public function scopeOrderByWith(Builder $query, $order)
    {
        if (isset($this->order_with[$order])) {
            $with = 'with' . $this->order_with[$order];

            $query->$with();
        }

        if (isset($this->order_fields[$order])) {
            $order_option = (explode('.', $this->order_fields[$order]))[0];

$order_option does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

            if (isset($this->order_relations[$order_option])) {

$order_option does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

                $query->modelJoin(
                    $this->order_relations[$order_option],

$order_option does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

                    '=',
                    'left',
                    false,
                    false
                );
            }
        }

        return $query;
    }

    /**
     * Add where statements for the model search fields
     *
     * @param Builder|RelatedPlus $query

Consider making the type for parameter $query a bit more specific; maybe use Builder.

     * @param string $search
     * @return Builder
     */
    public function scopeSearch(Builder $query, $search = '')
    {
        $search = trim($search);

        // If search is set
        if ($search != "") {
            if (!isset($this->search_fields) || !is_array($this->search_fields) || empty($this->search_fields)) {
                throw new InvalidArgumentException(get_class($this) . ' search properties not set correctly.');
            } else {
                $search_fields = $this->search_fields;

$search_fields does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

The property search_fields does not exist. Did you maybe forget to declare it?

                /** @var Model $this */
                $table = $this->getTable();
                $query->where(function (Builder $query) use ($search_fields, $table, $search) {
                    foreach ($search_fields as $search_field => $search_field_parameters) {

$search_fields does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

                        if (!isset($search_field_parameters['regex']) ||

$search_field_parameters does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

                            preg_match($search_field_parameters['regex'], $search)) {

$search_field_parameters does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

                            $search_column = is_array($search_field_parameters)

$search_column does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

                                ? $search_field : $search_field_parameters;

$search_field does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

                            $search_operator = isset($search_field_parameters['operator'])

$search_operator does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

                                ? $search_field_parameters['operator'] : 'like';

$search_field_parameters does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

                            $search_value = isset($search_field_parameters['value'])

$search_value does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

                                ? $search_field_parameters['value'] : '%{{search}}%';

$search_field_parameters does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

                            if (isset($search_field_parameters['relation'])) {

$search_field_parameters does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

                                $relation = $search_field_parameters['relation'];

$search_field_parameters does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

                                $related_table = $this->$relation()->getRelated()->getTable();

$related_table does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

                                $query->orWhere(function (Builder $query) use (
                                    $search,
                                    $search_column,
                                    $search_field_parameters,
                                    $relation,
                                    $related_table
                                ) {
                                    $query->orWhereHas($relation, function (Builder $query2) use (
                                        $search,
                                        $search_column,
                                        $search_field_parameters,
                                        $related_table
                                    ) {
                                        $query2->where($related_table . '.' . $search_column, 'like', $search . '%');

$related_table does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

                                    });
                                });
                            } else {
                                $query->orWhere(
                                    $table . '.' . $search_column,

$search_column does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

                                    $search_operator,

$search_operator does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

                                    str_replace('{{search}}', $search, $search_value)

$search_value does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

                                );
                            }
                        }
                    }

                    return $query;
                });
            }
        }

        return $query;
    }
}