ListController::buildContentQuery() - Code Metrics - Inspection of "feat(role): Adds descendant view" - uccellolabs/uccello - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( c92e71...89beee )

by Jonathan
created 2019-09-02 12:24 UTC
ListController::buildContentQuery() C

↳ Parent: Project
Complexity

Conditions	12
Paths	31
Size

Total Lines	55
Code Lines	29
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	12
eloc	29
c	1
b	0
f	0
nc	31
nop	0
dl	0
loc	55
rs	6.9666
How to fix Long Method Complexity

<?php

namespace Uccello\Core\Http\Controllers\Core;

use Schema;
filter:
    dependency_paths: ["lib/*"]
use Illuminate\Http\Request;
filter:
    dependency_paths: ["lib/*"]
use Spatie\Searchable\Search;
filter:
    dependency_paths: ["lib/*"]
use Uccello\Core\Models\Domain;
use Uccello\Core\Models\Module;
use Uccello\Core\Facades\Uccello;
use Uccello\Core\Models\Relatedlist;
use Uccello\Core\Models\Filter;

class ListController extends Controller
{
    protected $viewName = 'list.main';

    /**
     * Check user permissions
     */
    protected function checkPermissions()
    {
        $this->middleware('uccello.permissions:retrieve');
    }

    /**
     * @inheritDoc
     */
    public function process(?Domain $domain, Module $module, Request $request)
    {
        // Pre-process
        $this->preProcess($domain, $module, $request);

        // Selected filter
        if ($request->input('filter')) {
            $selectedFilterId = $request->input('filter');
            $selectedFilter = Filter::find($selectedFilterId);
        }

        if (empty($selectedFilter)) { // For example if the given filter does not exist
            $selectedFilter = $module->filters()->where('type', 'list')->first();
            $selectedFilterId = $selectedFilter->id;
        }

        // Get datatable columns
        $datatableColumns = Uccello::getDatatableColumns($module, $selectedFilterId);


        // Get filters
        $filters = Filter::where('module_id', $module->id)
            ->where('type', 'list')
            ->get();

        // Order by
        $filterOrderBy = (array) $selectedFilter->order_by;

        return $this->autoView(compact('datatableColumns', 'filters', 'selectedFilter', 'filterOrderBy'));
    }

    /**
     * Display a listing of the resources.
     * The result is formated differently if it is a classic query or one requested by datatable.
     * Filter on domain if domain_id column exists.
     * @param  \Uccello\Core\Models\Domain|null $domain
     * @param  \Uccello\Core\Models\Module $module
     * @param  \Illuminate\Http\Request $request
     * @return \Illuminate\Http\Response
filter:
    dependency_paths: ["lib/*"]
     */
    public function processForContent(?Domain $domain, Module $module, Request $request)
    {
        $length = (int)$request->get('length') ?? env('UCCELLO_ITEMS_PER_PAGE', 15);
        $length = (int)$request->get('length') ?? /** @scrutinizer ignore-call */ env('UCCELLO_ITEMS_PER_PAGE', 15);

        $recordId = $request->get('id');
        $relatedListId = $request->get('relatedlist');
        $action = $request->get('action');

        // Pre-process
        $this->preProcess($domain, $module, $request, false);

        // Get model model class
        $modelClass = $module->model_class;

        // Check if the class exists
        if (!class_exists($modelClass)) {
            return false;

        }

        // Build query
        $query = $this->buildContentQuery();

        // Limit the number maximum of items per page
        $maxItemsPerPage = env('UCCELLO_MAX_ITEMS_PER_PAGE', 100);
        if ($length > $maxItemsPerPage) {
            $length = $maxItemsPerPage;
        }

        // If the query is for a related list, add conditions
        if ($relatedListId && $action !== 'select') {
            // Get related list
            $relatedList = Relatedlist::find($relatedListId);

            if ($relatedList && $relatedList->method) {
                // Related list method
                $method = $relatedList->method;

                // Update query
                $model = new $modelClass;
                $records = $model->$method($relatedList, $recordId, $query)->paginate($length);
            }
        } elseif ($relatedListId && $action === 'select') {
            // Get related list
            $relatedList = Relatedlist::find($relatedListId);

            if ($relatedList && $relatedList->method) {
                // Related list method
                $method = $relatedList->method;
                $recordIdsMethod = $method . 'RecordIds';

                // Get related records ids
                $model = new $modelClass;
                $filteredRecordIds = $model->$recordIdsMethod($relatedList, $recordId);

                // Add the record id itself to be filtered
                if ($relatedList->module_id === $relatedList->related_module_id && !empty($recordId) && !$filteredRecordIds->contains($recordId)) {
                    $filteredRecordIds[] = (int)$recordId;
                }

                // Make the quer
                $records = $query->whereNotIn($model->getKeyName(), $filteredRecordIds)->paginate($length);
            }
        } else {
            // Paginate results
            $records = $query->paginate($length);
        }

        $records->getCollection()->transform(function ($record) use ($domain, $module) {

            foreach ($module->fields as $field) {
                // If a special template exists, use it. Else use the generic template
                $uitype = uitype($field->uitype_id);
                $uitypeViewName = sprintf('uitypes.list.%s', $uitype->name);
                $uitypeFallbackView = 'uccello::modules.default.uitypes.list.text';
                $uitypeViewToInclude = uccello()->view($uitype->package, $module, $uitypeViewName, $uitypeFallbackView);
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
if ($a->getObject()) {
                $record->{$field->name.'_html'} = view()->make($uitypeViewToInclude, compact('domain', 'module', 'record', 'field'))->render();
                $record->{$field->name.'_html'} = /** @scrutinizer ignore-call */ view()->make($uitypeViewToInclude, compact('domain', 'module', 'record', 'field'))->render();
            }

            return $record;
        });

        return $records;
    }

    /**
     * Autocomplete a listing of the resources.
     * The result is formated differently if it is a classic query or one requested by datatable.
     * Filter on domain if domain_id column exists.
     * @param  \Uccello\Core\Models\Domain|null $domain
     * @param  \Uccello\Core\Models\Module $module
     * @param  \Illuminate\Http\Request $request
     * @return \Illuminate\Http\Response
     */
    public function processForAutocomplete(?Domain $domain, Module $module, Request $request)
    {
        // If we don't use multi domains, find the first one
        if (!uccello()->useMultiDomains()) {
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
if ($a->getObject()) {
            $domain = Domain::first();

        }

        // Query
        $q = $request->get('q');
        // Model class
        $modelClass = $module->model_class;

        $results = collect();
        $results = /** @scrutinizer ignore-call */ collect();
        if (method_exists($modelClass, 'getSearchResult') && property_exists($modelClass, 'searchableColumns')) {
            $searchResults = new Search();
            $searchResults->registerModel($modelClass, (array) (new $modelClass)->searchableColumns);
            $results = $searchResults->search($q)->take(config('uccello.max_results.autocomplete', 10));
            $results = $searchResults->search($q)->take(/** @scrutinizer ignore-call */ config('uccello.max_results.autocomplete', 10));
        }

        return $results;
    }

    /**
     * Save list filter into database
     *
     * @param \Uccello\Core\Models\Domain|null $domain
     * @param \Uccello\Core\Models\Module $module
     * @param \Illuminate\Http\Request $request
     * @return \Illuminate\Http\Response
     */
    public function saveFilter(?Domain $domain, Module $module, Request $request)
    {
        $saveOrder = $request->input('save_order');
        $savePageLength = $request->input('save_page_length');

        // Optional data
        $data = [];
        if ($savePageLength) {
            $data["length"] = $request->input('page_length');
        }

        $filter = Filter::firstOrNew([
            'domain_id' => $domain->id,
            'module_id' => $module->id,
            'user_id' => auth()->id(),
            'user_id' => /** @scrutinizer ignore-call */ auth()->id(),
            'name' => $request->input('name'),
            'type' => $request->input('type')
        ]);
        $filter->columns = $request->input('columns');
        $filter->conditions = $request->input('conditions') ?? null;
        $filter->order_by = $saveOrder ? $request->input('order') : null;
        $filter->is_default = $request->input('default');
        $filter->is_public = $request->input('public');
        $filter->data = !empty($data) ? $data : null;
        $filter->save();

        return $filter;
    }

    /**
     * Retrieve a filter by its id and delete it
     *
     * @param \Uccello\Core\Models\Domain|null $domain
     * @param \Uccello\Core\Models\Module $module
     * @param \Illuminate\Http\Request $request
     * @return \Illuminate\Http\Response
     */
    public function deleteFilter(?Domain $domain, Module $module, Request $request)
    {
        // Retrieve filter by id
        $filterId = $request->input('id');
        $filter = Filter::find($filterId);

        if ($filter) {
            if ($filter->readOnly) {
                // Response
                $success = false;
                $message = uctrans('error.filter.read_only', $module);
            } else {
                // Delete
                $filter->delete();

                // Response
                $success = true;
                $message = uctrans('success.filter.deleted', $module);
            }
        } else {
            // Response
            $success = false;
            $message = uctrans('error.filter.not_found', $module);
        }

        return [
            'success' => $success,
            'message' => $message
        ];
    }

    /**
     * Build query for retrieving content
     *
     * @return \Illuminate\Database\Eloquent\Builder;
filter:
    dependency_paths: ["lib/*"]
     */
    protected function buildContentQuery()
    {
        $order = $this->request->get('order');
        $columns = $this->request->get('columns');

        $domain = $this->domain;
        $module = $this->module;

         // Get model model class
         $modelClass = $module->model_class;

         // Check if the class exists
         if (!class_exists($modelClass)) {
             return false;

         }

        // Filter on domain if column exists
        if (Schema::hasColumn((new $modelClass)->getTable(), 'domain_id')) {
            // Activate transversal view if the user is allowed
            if (auth()->user()->canSeeDescendantsRecords($domain) && request('descendants')) {
            if (auth()->user()->canSeeDescendantsRecords($domain) && /** @scrutinizer ignore-call */ request('descendants')) {
                $domainsIds = $domain->findDescendants()->pluck('id');
                $query = $modelClass::whereIn('domain_id', $domainsIds);
            } else {
                $query = $modelClass::where('domain_id', $domain->id);
            }
        } else {
            $query = $modelClass::query();
        }

        // Search by column
        foreach ($columns as $fieldName => $column) {
            if (!empty($column[ "search" ])) {
                $searchValue = $column[ "search" ];
            } else {
                $searchValue = null;
            }

            // Get field by name and search by field column
            $field = $module->getField($fieldName);
            if (isset($searchValue) && !is_null($field)) {
                $uitype = uitype($field->uitype_id);
                $query = $uitype->addConditionToSearchQuery($query, $field, $searchValue);
            }
        }

        // Order results
        if (!empty($order)) {
            foreach ($order as $fieldColumn => $value) {
                if (!is_null($field)) {

                    $query = $query->orderBy($fieldColumn, $value);
                }
            }
        }

        return $query;
    }
}

uccellolabs / uccello

Push — master ( c92e71...89beee )

ListController::buildContentQuery() C

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like
