Uccello\Core\Support\Traits\UccelloModule

Complexity

Total Complexity

45

Size/Duplication

Total Lines	219
Duplicated Lines	0 %

Importance

Changes	9
Bugs	6	Features	0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	initializeUccelloModule()	0	3	1
A	getTableAttribute()	0	3	1
B	bootUccelloModule()	0	25	7
A	getModuleAttribute()	0	3	1
A	getModuleFromClass()	0	11	1
B	isFilteredByUser()	0	15	7
A	getAssignedUserAttribute()	0	3	1
A	getUuidAttribute()	0	22	3
A	getCreatorAttribute()	0	17	3
C	scopeFilterBy()	0	51	14
A	scopeInDomain()	0	18	6

<?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;
use Uccello\Core\Support\Scopes;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Schema;
use Illuminate\Support\Str;
use Uccello\Core\Models\Domain;

trait UccelloModule
{
    use RelatedlistTrait;

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

        // Create uuid after save
        static::created(function ($model) {
            $module = Module::where('model_class', get_class($model))->first();
            if ($module) {
                Entity::create([
                    'id' => (string) Str::uuid(),
                    'module_id' => $module->id,
                    'record_id' => $model->getKey(),
                    'creator_id' => auth()->id(),
                ]);
            }
        });

        // Delete uuid after forced delete
        static::deleted(function ($model) {
            if (!empty($model->uuid) && (!method_exists($model, 'isForceDeleting') || $model->isForceDeleting() === true)) {
                $entity = Entity::find($model->uuid);
                if ($entity) {
                    $entity->delete();
                }
            }
        });
    }

    public function initializeUccelloModule()
    {
        $this->appends = array_merge($this->appends, ['recordLabel','uuid']);

The property appends does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

    }

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

        $user = Auth::user();

        if ($user && !$user->is_admin) {

Accessing is_admin on the interface Illuminate\Contracts\Auth\Authenticatable suggest that you code against a concrete implementation. How about adding an instanceof check?

            $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();
            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;

        $module = $this->module;

        if ($module) {
            return Cache::rememberForever('uuid_'.$module->getKey().'_'.$this->getKey(), function () use ($module) {

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

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

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

                return $uuid;
            });
        }

        return $uuid;
    }

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

    /**
     * Returns user who created the entity, if defined.
     *
     * @return \Uccello\Core\Models\User|null
     */
    public function getCreatorAttribute()
    {
        $creator = null;

        $module = $this->module;

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

            if ($entity) {
                $creator = $entity->creator;
            }
        }

        return $creator;
    }

    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() && Auth::user()->canSeeDescendantsRecords($domain) && $withDescendants) {

The method canSeeDescendantsRecords() does not exist on Illuminate\Contracts\Auth\Authenticatable. It seems like you code against a sub-type of Illuminate\Contracts\Auth\Authenticatable such as Illuminate\Foundation\Auth\User.

                $query->whereIn('domain_id', function ($query) use ($domain) {
                    $query->select('id')
                    ->from((new Domain)->getTable())
                    ->where('path', 'like', $domain->id.'/%')
                    ->orWhere('path', 'like', '%/'.$domain->id.'/%')
                    ->get();
                });
            } else {
                $query->where('domain_id', $domain->id);
            }
        }

        return $query;
    }

    /**
     * Add filter conditions to a query.
     * @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 Filter|int|array $filter
     * @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)) {

The property conditions does not seem to exist on Uccello\Core\Models\Filter. Are you sure there is no database migration missing?

                        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) {

The property order does not seem to exist on Uccello\Core\Models\Filter. Are you sure there is no database migration missing?

                        // 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;
    }
}