UccelloModule::getTableAttribute() - Code Metrics - uccellolabs/uccello - Measure and Improve Code Quality continuously with Scrutinizer

UccelloModule::getTableAttribute() A
last analyzed 2020-07-02 16:09 UTC

↳ Parent: UccelloModule
Complexity

Conditions	1
Paths	1
Size

Total Lines	3
Code Lines	1
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
eloc	1
c	1
b	0
f	0
dl	0
loc	3
rs	10
cc	1
nc	1
nop	0
<?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']);

    }

    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();
            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) {
            return Cache::rememberForever('uuid_'.$module->getKey().'_'.$this->/** @scrutinizer ignore-call */ getKey(), function () use ($module) {
                $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) {
            if (Auth::user() && Auth::user()->/** @scrutinizer ignore-call */ canSeeDescendantsRecords($domain) && $withDescendants) {
                $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
filter:
    dependency_paths: ["lib/*"]
     * @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)) {

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

uccellolabs / uccello

UccelloModule::getTableAttribute() A last analyzed 2020-07-02 16:09 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

UccelloModule::getTableAttribute() A
last analyzed 2020-07-02 16:09 UTC
