Uccello\Core\Support\Traits\UccelloModule

Complexity

Total Complexity

34

Size/Duplication

Total Lines	151
Duplicated Lines	0 %

Importance

Changes	4
Bugs	2	Features	0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	getModuleAttribute()	0	3	1
A	getModuleFromClass()	0	11	1
A	getAssignedUserAttribute()	0	3	1
C	scopeFilterBy()	0	51	14
A	getTableAttribute()	0	3	1
A	getUuidAttribute()	0	13	2
A	bootUccelloModule()	0	4	2
A	scopeInDomain()	0	13	5
B	isFilteredByUser()	0	15	7

<?php

namespace Uccello\Core\Support\Traits;

use Uccello\Core\Models\Entity;
use Uccello\Core\Models\Module;
use Uccello\Core\Models\Filter;
use Illuminate\Support\Facades\Cache;

The type Illuminate\Support\Facades\Cache was not found. Maybe you did not declare it correctly or list all dependencies?

use Uccello\Core\Support\Scopes;
use Illuminate\Support\Facades\Auth;

The type Illuminate\Support\Facades\Auth was not found. Maybe you did not declare it correctly or list all dependencies?

use Illuminate\Support\Facades\Schema;

The type Illuminate\Support\Facades\Schema was not found. Maybe you did not declare it correctly or list all dependencies?

use Uccello\Core\Models\Domain;

trait UccelloModule
{
    /**
     * The "booting" method of the trait.
     *
     * @return void
     */
    protected static function bootUccelloModule()
    {
        if (static::isFilteredByUser()) {
            static::addGlobalScope(new Scopes\AssignedUser);
        }
    }

    protected static function isFilteredByUser()
    {
        $isFilteredByUser = false;

        $user = Auth::user();

        if ($user && !$user->is_admin) {
            $module = static::getModuleFromClass(static::class);

            if ($module && $module->data && property_exists($module->data, 'private') && $module->data->private) {
                $isFilteredByUser = true;
            }
        }

        return $isFilteredByUser;
    }

    public function getTableAttribute()
    {
        return $this->table;
    }

    public function getModuleAttribute()
    {
        return static::getModuleFromClass(get_class($this));
    }

    protected static function getModuleFromClass($className)
    {
        $modules = Cache::rememberForever('modules_by_model_class', function () {
            $modulesGroupedByModelClass = collect();

The function collect was not found. Maybe you did not declare it correctly or list all dependencies?

            Module::all()->map(function ($item) use ($modulesGroupedByModelClass) {
                $modulesGroupedByModelClass[$item->model_class] = $item;
                return $modulesGroupedByModelClass;
            });
            return $modulesGroupedByModelClass;
        });
        return $modules[(string) $className] ?? null;
    }

    public function getUuidAttribute()
    {
        $uuid = null;

        $entity = Entity::where('module_id', $this->module->getKey())
                        ->where('record_id', $this->getKey())

It seems like getKey() must be provided by classes using this trait. How about adding it as abstract method to this trait?

                        ->first();

        if ($entity) {
            $uuid = $entity->getKey();
        }

        return $uuid;
    }

    /**
     * Returns Assigned User
     *
     * @return string|null
     */
    public function getAssignedUserAttribute(): ?string
    {
        return $this->assigned_user_id;
    }

    public function scopeInDomain($query, ?Domain $domain, $withDescendants = false)
    {
        if (!empty($domain) && Schema::hasColumn($this->table, 'domain_id')) {
            // Activate descendant view if the user is allowed
            if (Auth::user()->canSeeDescendantsRecords($domain) && $withDescendants) {
                $domainsIds = $domain->findDescendants()->pluck('id');
                $query = $query->whereIn('domain_id', $domainsIds);
            } else {
                $query = $query->where('domain_id', $domain->id);
            }
        }

        return $query;
    }

    /**
     * Returns Assigned User
     * @param QueryBuilder $query

The type Uccello\Core\Support\Traits\QueryBuilder was not found. Maybe you did not declare it correctly or list all dependencies?

     * @param Field|int|array $filter

The type Uccello\Core\Support\Traits\Field was not found. Maybe you did not declare it correctly or list all dependencies?

     * @return QueryBuilder|null
     */
    public function scopeFilterBy($query, $filter)
    {
        $filterModel = null;

        if (!empty($filter)) {
            // $filter: int id
            if (is_numeric($filter)) {
                // TODO: Check permissions ?? (domain, user)
                $filterModel = Filter::where('id', $filter)
                                        ->where('module_id', $this->module->getKey())
                                        ->first();
            }
            // $filter: array data
            elseif (is_array($filter)) {
                $filterModel = Filter::newFromData($filter);
            }
            // $filter: Filter model
            elseif (substr(strrchr(get_class($filter), "\\"), 1) == 'Filter') {
                $filterModel = $filter;
            }

            if ($filterModel) {
                // Conditions
                if (!empty($filterModel->conditions)) {
                    // Search
                    if (!empty($filterModel->conditions->search)) {
                        foreach ($filterModel->conditions->search as $fieldName => $searchValue) {
                            // Get field by name and search by field column
                            $field = $this->module->getField($fieldName);
                            if (isset($searchValue) && !is_null($field)) {
                                $uitype = uitype($field->uitype_id);
                                $query = $uitype->addConditionToSearchQuery($query, $field, $searchValue);
                            }
                        }
                    }
                }

                // Order results
                if (!empty($filterModel->order)) {
                    foreach ($filterModel->order as $fieldName => $value) {
                        // Get field by name and search by field column
                        $field = $this->module->getField($fieldName);
                        if (!is_null($field)) {
                            $query = $query->orderBy($field->column, $value);
                        }
                    }
                }
            }
        }

        return $query;
    }
}