RequestCriteria::parserSearch() - Code Metrics - Inspection of ":sparkles: Another way to do it" - frowhy/module-core - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — feature/optimize ( 6201d6...123ace )

by Fu
created 2019-05-22 11:01 UTC
RequestCriteria::parserSearch() F

↳ Parent: RequestCriteria
Complexity

Conditions	37
Paths	434
Size

Total Lines	166
Code Lines	131
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
eloc	131
dl	0
loc	166
rs	0.6288
c	0
b	0
f	0
cc	37
nc	434
nop	0
How to fix Long Method Complexity

<?php
/**
 * Created by PhpStorm.
 * User: guoliang
 * Date: 2019/3/11
 * Time: 上午10:11
 */

namespace Modules\Core\Criteria;

use Exception;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Http\Request;
use Prettus\Repository\Contracts\CriteriaInterface;
use Prettus\Repository\Contracts\RepositoryInterface;

class RequestCriteria implements CriteriaInterface
{
    /**
     * @var \Illuminate\Http\Request
     */
    protected $request;
    /**
     * @var \Illuminate\Database\Eloquent\Builder|\Illuminate\Database\Eloquent\Model
     */
    private $model;
    private $search;
    private $searchData;
    private $searchFields;
    private $isFirstField = true;
    private $modelForceAndWhere;
    private $fieldsSearchable;
    private $fields;
    private $filter;
    private $orderBy;
    private $sortedBy;
    private $with;
    private $searchJoin;
    private $acceptedConditions;
    private $originalFields;


    public function __construct(Request $request)
    {
        $this->request = $request;
    }

    /**
     * Apply criteria in query repository
     *
     * @param Builder|Model $model
     * @param RepositoryInterface $repository
     *
     * @return mixed
     * @throws \Exception
     */
    public function apply($model, RepositoryInterface $repository)
    {
        $this->model = $model;
        $this->fieldsSearchable = $repository->getFieldsSearchable();
        $this->search = $this->request->get(config('repository.criteria.params.search', 'search'), null);
        $this->searchFields =
            $this->request->get(config('repository.criteria.params.searchFields', 'searchFields'), null);
        $this->filter = $this->request->get(config('repository.criteria.params.filter', 'filter'), null);
        $this->orderBy = $this->request->get(config('repository.criteria.params.orderBy', 'orderBy'), null);
        $this->sortedBy = $this->request->get(config('repository.criteria.params.sortedBy', 'sortedBy'), 'asc');
        $this->with = $this->request->get(config('repository.criteria.params.with', 'with'), null);
        $this->searchJoin = $this->request->get(config('repository.criteria.params.searchJoin', 'searchJoin'), null);
        $this->sortedBy = !empty($sortedBy) ? $sortedBy : 'asc';

        $this->acceptedConditions = config('repository.criteria.acceptedConditions', ['=', 'like']);

        $this->parserSearch();
        $this->parserOrderBy();
        $this->parserFilter();
        $this->parserWith();

        return $this->model;
    }

    protected function parserSearchData()
    {
        $searchData = [];

        if (stripos($this->search, ':')) {
            $fields = explode(';', $this->search);

            foreach ($fields as $row) {
                try {
                    list($field, $value) = explode(':', $row);
                    $searchData[$field] = $value;
                } catch (Exception $e) {
                    //Surround offset error
                }
            }
        }

        $this->searchData = $searchData;
    }

    protected function parserSearchValue()
    {
        if (stripos($this->search, ';') || stripos($this->search, ':')) {
            $values = explode(';', $this->search);
            foreach ($values as $value) {
                $s = explode(':', $value);
                if (count($s) == 1) {
                    $this->search = $s[0];
                }
            }

            $this->search = null;
        }
    }

    /**
     * @throws \Exception
     */
    protected function parserFieldsSearch()
    {
        $this->parserSearchFields();
        $fields = $this->fieldsSearchable;

        if (!is_null($this->searchFields) && count($this->searchFields)) {

            $this->parserOriginalFields();

            $fields = [];

            foreach ($this->originalFields as $field => $condition) {
                if (is_numeric($field)) {
                    $field = $condition;
                    $condition = "=";
                }
                if (in_array($field, $this->searchFields)) {
                if (in_array($field, /** @scrutinizer ignore-type */ $this->searchFields)) {
                    $fields[$field] = $condition;
                }
            }

            if (count($fields) == 0) {
                throw new Exception(trans('repository::criteria.fields_not_accepted', ['field' => implode(',', $this->searchFields)]));
                throw new Exception(/** @scrutinizer ignore-type */ trans('repository::criteria.fields_not_accepted', ['field' => implode(',', $this->searchFields)]));
            }

        }

        $this->fields = $fields;
    }

    protected function parserOrderBy()
    {
        if (isset($this->orderBy) && !empty($this->orderBy)) {
            $split = explode('|', $this->orderBy);
            if (count($split) > 1) {
                $table = $this->model->getModel()->getTable();
                $sortTable = $split[0];
                $sortColumn = $split[1];

                $split = explode(':', $sortTable);
                if (count($split) > 1) {
                    $sortTable = $split[0];
                    $keyName = $table.'.'.$split[1];
                } else {
                    $prefix = str_singular($sortTable);
                    $prefix = /** @scrutinizer ignore-deprecated */ str_singular($sortTable);
                    $keyName = $table.'.'.$prefix.'_id';
                }

                $this->model = $this->model->leftJoin($sortTable, $keyName, '=', $sortTable.'.id')
class Id
{
    public $id;

    public function __construct($id)
    {
        $this->id = $id;
    }

}

class Account
{
    /** @var  Id $id */
    public $id;
}

$account_id = false;

if (starsAreRight()) {
    $account_id = new Id(42);
}

$account = new Account();
if ($account instanceof Id)
{
    $account->id = $account_id;
}
                                           ->orderBy($sortColumn, $this->sortedBy)
                                           ->addSelect($table.'.*');
            } else {
                $this->model = $this->model->orderBy($this->orderBy, $this->sortedBy);
            }
        }
    }

    protected function parserFilter()
    {
        if (isset($this->filter) && !empty($this->filter)) {
            if (is_string($this->filter)) {
                $this->filter = explode(';', $this->filter);
            }

            $this->model = $this->model->select($this->filter);
class Id
{
    public $id;

    public function __construct($id)
    {
        $this->id = $id;
    }

}

class Account
{
    /** @var  Id $id */
    public $id;
}

$account_id = false;

if (starsAreRight()) {
    $account_id = new Id(42);
}

$account = new Account();
if ($account instanceof Id)
{
    $account->id = $account_id;
}
        }
    }

    protected function parserWith()
    {
        if ($this->with) {
            $this->with = explode(';', $this->with);
            $this->model = $this->model->with($this->with);
        }
    }

    /**
     * @throws \Exception
     */
    protected function parserSearch()
    {
        if ($this->search && is_array($this->fieldsSearchable) && count($this->fieldsSearchable)) {

            $this->parserFieldsSearch();
            $this->parserSearchData();
            $this->parserSearchValue();

            $this->modelForceAndWhere = strtolower($this->searchJoin) === 'and';

            foreach ($this->fields as $field => $condition) {

                if (is_numeric($field)) {
                    $field = $condition;
                    $condition = "=";
                }

                $value = null;

                $condition = trim(strtolower($condition));

                if (isset($this->searchData[$field])) {
                    $value = $this->searchData[$field];
                    if ($condition == "like" || $condition == "ilike") {
                        $value = "%{$value}%";
                    }
                    if ($condition == "in" || $condition == "between" || $condition == "cross") {
                        $value = explode(',', $value);
                    }
                } else {
                    if (!is_null($this->search)) {
                        $value = $this->search;
                        if ($condition == "like" || $condition == "ilike") {
                            $value = "%{$value}%";
                        }
                        if ($condition == "in" || $condition == "between" || $condition == "cross") {
                            $value = explode(',', $value);
                        }
                    }
                }

                $relation = null;
                if (stripos($field, '.')) {
                    $explode = explode('.', $field);
                    $field = array_pop($explode);
                    $relation = implode('.', $explode);
                }
                $modelTableName = $this->model->getModel()->getTable();
                if ($this->isFirstField || $this->modelForceAndWhere) {
                    if (!is_null($value)) {
                        if (!is_null($relation)) {
                            $this->model = $this->model->whereHas($relation, function (Builder $query) use (
                                $field,
                                $condition,
                                $value
                            ) {
                                if ($condition == 'in') {
                                    $query->whereIn($field, $value);
                                } elseif ($condition == 'between') {
                                    $query->whereBetween($field, $value);
                                } elseif ($condition == 'cross') {
                                    $query->where(function (Builder $query) use ($field, $value) {
                                        $query->where(function (Builder $query) use ($field, $value) {
                                            $query->where("{$field}_min", '<=', $value[0])
                                                  ->where("{$field}_max", '>=', $value[1]);
                                        })->orWhere(function (Builder $query) use ($field, $value) {
                                            $query->where("{$field}_min", '<=', $value[0])
                                                  ->where("{$field}_max", '>=', $value[0]);
                                        })->orWhere(function (Builder $query) use ($field, $value) {
                                            $query->where("{$field}_min", '>=', $value[0])
                                                  ->where("{$field}_max", '<=', $value[1]);
                                        })->orWhere(function (Builder $query) use ($field, $value) {
                                            $query->where("{$field}_min", '>=', $value[0])
                                                  ->where("{$field}_max", '>=', $value[1])
                                                  ->where("{$field}_min", '<=', $value[1]);
                                        });
                                    });
                                } else {
                                    $query->where($field, $condition, $value);
                                }
                            });
                        } else {
                            if ($condition == 'in') {
                                $this->model = $this->model->whereIn($field, $value);
class Id
{
    public $id;

    public function __construct($id)
    {
        $this->id = $id;
    }

}

class Account
{
    /** @var  Id $id */
    public $id;
}

$account_id = false;

if (starsAreRight()) {
    $account_id = new Id(42);
}

$account = new Account();
if ($account instanceof Id)
{
    $account->id = $account_id;
}
                            } elseif ($condition == 'between') {
                                $this->model = $this->model->whereBetween($field, $value);
                            } elseif ($condition == 'cross') {
                                $this->model = $this->model->where(function (Builder $query) use ($field, $value) {
                                    $query->where(function (Builder $query) use ($field, $value) {
                                        $query->where("{$field}_min", '<=', $value[0])
                                              ->where("{$field}_max", '>=', $value[1]);
                                    })->orWhere(function (Builder $query) use ($field, $value) {
                                        $query->where("{$field}_min", '<=', $value[0])
                                              ->where("{$field}_max", '>=', $value[0]);
                                    })->orWhere(function (Builder $query) use ($field, $value) {
                                        $query->where("{$field}_min", '>=', $value[0])
                                              ->where("{$field}_max", '<=', $value[1]);
                                    })->orWhere(function (Builder $query) use ($field, $value) {
                                        $query->where("{$field}_min", '>=', $value[0])
                                              ->where("{$field}_max", '>=', $value[1])
                                              ->where("{$field}_min", '<=', $value[1]);
                                    });
                                });
                            } else {
                                $this->model = $this->model->where($field, $condition, $value);
                            }
                        }
                        $this->isFirstField = false;
                    }
                } else {
                    if (!is_null($value)) {
                        if (!is_null($relation)) {
                            $this->model = $this->model->orWhereHas($relation, function (Builder $query) use (
                                $field,
                                $condition,
                                $value
                            ) {
                                if ($condition == 'in') {
                                    $query->whereIn($field, $value);
                                } elseif ($condition == 'between') {
                                    $query->whereBetween($field, $value);
                                } elseif ($condition == 'cross') {
                                    $query->where(function (Builder $query) use ($field, $value) {
                                        $query->where(function (Builder $query) use ($field, $value) {
                                            $query->where("{$field}_min", '<=', $value[0])
                                                  ->where("{$field}_max", '>=', $value[1]);
                                        })->orWhere(function (Builder $query) use ($field, $value) {
                                            $query->where("{$field}_min", '<=', $value[0])
                                                  ->where("{$field}_max", '>=', $value[0]);
                                        })->orWhere(function (Builder $query) use ($field, $value) {
                                            $query->where("{$field}_min", '>=', $value[0])
                                                  ->where("{$field}_max", '<=', $value[1]);
                                        })->orWhere(function (Builder $query) use ($field, $value) {
                                            $query->where("{$field}_min", '>=', $value[0])
                                                  ->where("{$field}_max", '>=', $value[1])
                                                  ->where("{$field}_min", '<=', $value[1]);
                                        });
                                    });
                                } else {
                                    $query->where($field, $condition, $value);
                                }
                            });
                        } else {
                            if ($condition == 'in') {
                                $this->model = $this->model->orWhereIn($modelTableName.'.'.$field, $value);
                            } elseif ($condition == 'between') {
                                $this->model = $this->model->orWhereBetween($modelTableName.'.'.$field, $value);
                            } elseif ($condition == 'cross') {
                                $this->model = $this->model->orWhere(function (Builder $query) use ($field, $value) {
                                    $query->where(function (Builder $query) use ($field, $value) {
                                        $query->where("{$field}_min", '<=', $value[0])
                                              ->where("{$field}_max", '>=', $value[1]);
                                    })->orWhere(function (Builder $query) use ($field, $value) {
                                        $query->where("{$field}_min", '<=', $value[0])
                                              ->where("{$field}_max", '>=', $value[0]);
                                    })->orWhere(function (Builder $query) use ($field, $value) {
                                        $query->where("{$field}_min", '>=', $value[0])
                                              ->where("{$field}_max", '<=', $value[1]);
                                    })->orWhere(function (Builder $query) use ($field, $value) {
                                        $query->where("{$field}_min", '>=', $value[0])
                                              ->where("{$field}_max", '>=', $value[1])
                                              ->where("{$field}_min", '<=', $value[1]);
                                    });
                                });
                            } else {
                                $this->model = $this->model->orWhere($modelTableName.'.'.$field, $condition, $value);
                            }
                        }
                    }
                }
            }
        }
    }

    protected function parserSearchFields()
    {
        if (!is_array($this->searchFields) && !is_null($this->searchFields)) {
            $this->searchFields = explode(';', $this->searchFields);
        }
    }

    protected function parserOriginalFields()
    {
        $this->originalFields = $this->fieldsSearchable;

        foreach ($this->searchFields as $index => $field) {
            $field_parts = explode(':', $field);
            $temporaryIndex = array_search($field_parts[0], $this->originalFields);

            if (count($field_parts) == 2) {
                if (in_array($field_parts[1], $this->acceptedConditions)) {
                    unset($this->originalFields[$temporaryIndex]);
                    $field = $field_parts[0];
                    $condition = $field_parts[1];
                    $this->originalFields[$field] = $condition;
                    $this->searchFields[$index] = $field;
                }
            }
        }
    }
}

frowhy / module-core

Push — feature/optimize ( 6201d6...123ace )

RequestCriteria::parserSearch() F

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like
