Datatable::applyCachedConfig() - Code Metrics - Inspection of "wip" - Laravel-Backpack/CRUD - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — datatable-single-component ( 863f17...49cc78 )

by Pedro
created 2025-05-02 11:06 UTC
Datatable::applyCachedConfig() C

↳ Parent: Datatable
Complexity

Conditions	13
Paths	27
Size

Total Lines	71
Code Lines	46
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	13
eloc	46
nc	27
nop	1
dl	0
loc	71
rs	6.6166
c	1
b	0
f	0
How to fix Long Method Complexity

<?php

namespace Backpack\CRUD\app\Library\Datatable;

use Backpack\CRUD\app\Library\CrudPanel\CrudPanel;
use Backpack\CRUD\CrudManager;
use Illuminate\Support\Facades\Cache;
use Illuminate\Support\Str;
use Illuminate\View\Component;

class Datatable extends Component
{
    protected string $tableId;

    public function __construct(
        private string $controller,
        private ?CrudPanel $crud = null,
        private bool $updatesUrl = true,
        private ?\Closure $configure = null,
        private ?string $type = null,
        private ?string $name = null
    ) {
        // Set active controller for proper context
        CrudManager::setActiveController($controller);
                     setActiveController($controller);
        
        $this->crud ??= CrudManager::crudFromController($controller);
        $this->crud ??= CrudManager::/** @scrutinizer ignore-call */ crudFromController($controller);
       
        $controllerPart = str_replace('\\', '_', $this->controller);
        $typePart = $this->type ?? 'default';
        $namePart = $this->name ?? 'default';
        $uniqueId = md5($controllerPart . '_' . $typePart . '_' . $namePart);
        $this->tableId = 'crudTable_' . $uniqueId;
        
        
        if ($this->configure) {
            // Apply the configuration
            ($this->configure)($this->crud);
            
            // Store the configuration in cache for Ajax requests
            $this->storeDatatableConfig();
        }
        
        if (! $this->crud->getOperationSetting('datatablesUrl')) {
        if (! $this->crud->/** @scrutinizer ignore-call */ getOperationSetting('datatablesUrl')) {
            $this->crud->setOperationSetting('datatablesUrl', $this->crud->getRoute());
        }
        
        // Reset the active controller
        CrudManager::unsetActiveController($controller);
                     unsetActiveController($controller);
    }
    
    /**
     * Store the datatable configuration in the cache for later use in Ajax requests
     */
    private function storeDatatableConfig()
    {
        if (!$this->configure) {
            return;
        }
    
        $controllerClass = $this->controller;
        $cruds = CrudManager::getCruds();
        $cruds = CrudManager::getCruds();
        $parentCrud = reset($cruds);
        
        if ($parentCrud && $parentCrud->getCurrentEntry()) {
            $parentEntry = $parentCrud->getCurrentEntry();
            $parentController = $parentCrud->crudController;
            $cacheKey = 'datatable_config_' . $this->tableId;
            
            // Store the controller class, parent entry, element type and name
            Cache::put($cacheKey, [
                'controller' => $controllerClass,
                'parentController' => $parentController,
                'parent_entry' => $parentEntry,
                'element_type' => $this->type,
                'element_name' => $this->name,
            ], now()->addHours(1));
            
            $this->crud->setOperationSetting('datatable_id', $this->tableId);
        }
    }
    
    public static function applyCachedConfig($crud)
    {
        $tableId = request('datatable_id');
        
        if (!$tableId) {
            \Log::debug('Missing datatable_id in request parameters');
            return false;
        }
        
        $cacheKey = 'datatable_config_' . $tableId;
        $cachedData = Cache::get($cacheKey);
        
        if (!$cachedData) {
            \Log::debug('No cached configuration found for the given datatable_id');
            return false;
        }
        
        try {            
            \Log::debug('Found matching configuration by table ID', [
                'controller' => $cachedData['controller'],
                'element_type' => $cachedData['element_type'],
                'element_name' => $cachedData['element_name'],
                'table_id' => $tableId
            ]);
            
            // Get the parent crud instance
            $parentCrud = CrudManager::crudFromController($cachedData['parentController'], 'show');
            $entry = $cachedData['parent_entry'];
            
            // Get element type and name from cached data
            $elementType = $cachedData['element_type'];
            $elementName = $cachedData['element_name'];
            
            \Log::debug('Element type and name', [
                'element_type' => $elementType,
                'element_name' => $elementName
            ]);
            
            if ($elementType === 'column') {
                $column = $parentCrud->columns()[$elementName] ?? null;
                if ($column && isset($column['configure'])) {
                    self::applyColumnDatatableConfig($parentCrud, $crud, $elementName, $entry);
                    // clear the cache after applying the configuration
                    Cache::forget($cacheKey);
                    return true;
                }
                \Log::debug('Column not found or no configure closure defined');
                return false;
            } else if ($elementType === 'widget') {
                $widgets = $parentCrud->getOperationSetting('widgets') ?? [];
                foreach ($widgets as $widget) {
                    if ($widget['type'] === 'datatable' && 
                        (isset($widget['name']) && $widget['name'] === $elementName) && 
                        isset($widget['configure'])) {
                        self::applyWidgetDatatableConfig($parentCrud, $crud, $elementName, $entry);
                        // clear the cache after applying the configuration
                        Cache::forget($cacheKey);
                        return true;
                    }
                }
                \Log::debug('Widget not found or no configure closure defined');
                return false;
            }
        } catch (\Exception $e) {
            \Log::error("Error applying cached datatable config: " . $e->getMessage(), [
                'exception' => $e
            ]);
        }
        
        \Log::debug('No matching configuration found');
        return false;
    }

    private static function applyColumnDatatableConfig($parentCrud, $crud, $elementName, $entry)
    {
        $column = $parentCrud->columns()[$elementName];
        if (isset($column['configure'])) {
            ($column['configure'])($crud, $entry);
            return true;
        }
        return false;
    }

    private static function applyWidgetDatatableConfig($parentCrud, $crud, $elementName, $entry)
    {
        $widgets = $parentCrud->getOperationSetting('widgets') ?? [];
        foreach ($widgets as $widget) {
            if ($widget['type'] === 'datatable' && 
                (isset($widget['name']) && $widget['name'] === $elementName) && 
                isset($widget['configure'])) {
                ($widget['configure'])($crud, $entry);
                return true;
            }
        }
        return false;
    }

    public function render()
    {
        return view('crud::datatable.datatable', [
            'crud' => $this->crud,
            'updatesUrl' => $this->updatesUrl,
            'tableId' => $this->tableId,
        ]);
    }
}
Laravel-Backpack / CRUD

Scrutinizer GitHub App not installed

Push — datatable-single-component ( 863f17...49cc78 )

Datatable::applyCachedConfig() C

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like
