FiltersQueries::filter() - Code Metrics - scrnhq/laravel-bakery - Measure and Improve Code Quality continuously with Scrutinizer

FiltersQueries::filter() C
last analyzed 2020-07-22 12:22 UTC

↳ Parent: FiltersQueries
Complexity

Conditions	16
Paths	28
Size

Total Lines	42
Code Lines	34
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
eloc	34
c	1
b	0
f	0
dl	0
loc	42
rs	5.5666
cc	16
nc	28
nop	5
How to fix Complexity

<?php

namespace Bakery\Traits;

use Illuminate\Support\Str;
use Bakery\Support\Arguments;
use Bakery\Eloquent\ModelSchema;
use Bakery\Support\TypeRegistry;
use Illuminate\Support\Facades\DB;
use Illuminate\Database\Connection;
use Bakery\Types\CollectionFilterType;
use Illuminate\Database\Query\Grammars;
use Illuminate\Database\Eloquent\Builder;

/**
 * @property ModelSchema $modelSchema
 * @property TypeRegistry $registry
 */
trait FiltersQueries
{
    /**
     * Filter the query based on the filter argument.
     *
     * @param \Illuminate\Database\Eloquent\Builder $query
     * @param Arguments $args
     * @return \Illuminate\Database\Eloquent\Builder
     */
    protected function applyFilters(Builder $query, Arguments $args): Builder
    {
        // We wrap the query in a closure to make sure it
        // does not clash with other (scoped) queries that are on the builder.
        return $query->where(function ($query) use ($args) {
            return $this->applyFiltersRecursively($query, $args);
        });
    }

    /**
     * Apply filters recursively.
     *
     * @param \Illuminate\Database\Eloquent\Builder $query
     * @param Arguments $args
     * @param mixed $type
     * @return \Illuminate\Database\Eloquent\Builder
     */
    protected function applyFiltersRecursively(Builder $query, Arguments $args = null, $type = null): Builder
    {
        foreach ($args as $filter => $value) {
            if ($filter === 'AND' || $filter === 'OR') {
                $query->where(function ($query) use ($value, $filter) {
                    foreach ($value as $set) {
                        if (! empty($set)) {
                            $this->applyFiltersRecursively($query, $set, $filter);
                        }
                    }
                });
            } else {
                $key = $this->getKeyForFilter($filter);
                $schema = $this->registry->resolveSchemaForModel(get_class($query->getModel()));
                $field = $schema->getFieldByKey($key);

                if ($field->isRelationship()) {
                    $relation = $field->getAccessor();
                    $this->applyRelationFilter($query, $relation, $value, $type);
                } else {
                    $column = $field->getAccessor();
                    $this->filter($query, $filter, $column, $value, $type);
                }
            }
        }

        return $query;
    }

    /**
     * Filter the query based on the filter argument that contain relations.
     *
     * @param \Illuminate\Database\Eloquent\Builder $query
     * @param string $relation
     * @param Arguments $args
     * @param string $type
     * @return \Illuminate\Database\Eloquent\Builder
     */
    protected function applyRelationFilter(Builder $query, string $relation, Arguments $args = null, $type = null): Builder
    {
        $count = 1;
        $operator = '>=';
        $type = $type ?: 'and';

        if (! $args || $args->isEmpty()) {
            return $query->doesntHave($relation, $type);
        }

        return $query->has($relation, $operator, $count, $type, function ($subQuery) use ($args) {
            return $this->applyFiltersRecursively($subQuery, $args);
        });
    }

    /**
     * Filter the query by a key and value.
     *
     * @param \Illuminate\Database\Eloquent\Builder $query
     * @param string $key
     * @param string $column
     * @param mixed $value
     * @param string $type (AND or OR)
     * @return \Illuminate\Database\Eloquent\Builder
     */
    protected function filter(Builder $query, string $key, string $column, $value, $type): Builder
    {
        $type = $type ?: 'AND';

        $likeOperator = $this->getCaseInsensitiveLikeOperator();

        $table = $query->getModel()->getTable();
        $qualifiedColumn = $table.'.'.$column;

        $value = $value instanceof Arguments ? $value->toArray() : $value;

        if (Str::endsWith($key, 'NotContains')) {
            $query->where($qualifiedColumn, 'NOT '.$likeOperator, '%'.$value.'%', $type);
            $query->where($qualifiedColumn, 'NOT '.$likeOperator, '%'./** @scrutinizer ignore-type */ $value.'%', $type);
        } elseif (Str::endsWith($key, 'Contains')) {
            $query->where($qualifiedColumn, $likeOperator, '%'.$value.'%', $type);
        } elseif (Str::endsWith($key, 'NotStartsWith')) {
            $query->where($qualifiedColumn, 'NOT '.$likeOperator, $value.'%', $type);
        } elseif (Str::endsWith($key, 'StartsWith')) {
            $query->where($qualifiedColumn, $likeOperator, $value.'%', $type);
        } elseif (Str::endsWith($key, 'NotEndsWith')) {
            $query->where($qualifiedColumn, 'NOT '.$likeOperator, '%'.$value, $type);
        } elseif (Str::endsWith($key, 'EndsWith')) {
            $query->where($qualifiedColumn, $likeOperator, '%'.$value, $type);
        } elseif (Str::endsWith($key, 'Not')) {
            $query->where($qualifiedColumn, '!=', $value, $type);
        } elseif (Str::endsWith($key, 'NotIn')) {
            $query->whereNotIn($qualifiedColumn, $value, $type);
        } elseif (Str::endsWith($key, 'In')) {
            $query->whereIn($qualifiedColumn, $value, $type);
        } elseif (Str::endsWith($key, 'LessThan')) {
            $query->where($qualifiedColumn, '<', $value, $type);
        } elseif (Str::endsWith($key, 'LessThanOrEquals')) {
            $query->where($qualifiedColumn, '<=', $value, $type);
        } elseif (Str::endsWith($key, 'GreaterThan')) {
            $query->where($qualifiedColumn, '>', $value, $type);
        } elseif (Str::endsWith($key, 'GreaterThanOrEquals')) {
            $query->where($qualifiedColumn, '>=', $value, $type);
        } else {
            $query->where($qualifiedColumn, '=', $value, $type);
        }

        return $query;
    }

    /**
     * Check if the current database grammar supports the insensitive like operator.
     *
     * @return string
     */
    protected function getCaseInsensitiveLikeOperator()
    {
        /** @var Connection $connection */
        $connection = DB::connection();

        return $connection->getQueryGrammar() instanceof Grammars\PostgresGrammar ? 'ILIKE' : 'LIKE';
    }

    /**
     * Get the key for a certain filter.
     * E.g. TitleStartsWith => Title.
     *
     * @param string $subject
     * @return string
     */
    protected function getKeyForFilter(string $subject): string
    {
        foreach (CollectionFilterType::$filters as $filter) {
            if (Str::endsWith($subject, $filter)) {
                return Str::before($subject, $filter);
            }
        }

        return $subject;
    }
}

scrnhq / laravel-bakery

FiltersQueries::filter() C last analyzed 2020-07-22 12:22 UTC

Complexity

Size

Duplication

Importance

How to fix Complexity

Long Method

Duplication Side-by-Side

Filter issues like

FiltersQueries::filter() C
last analyzed 2020-07-22 12:22 UTC
