ModelAdmin::routeParameters() - Code Metrics - Inspection of "Adds an EntityTitle and PluralEntityTitle to Model..." - laravelflare/flare - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 32da41...f25af1 )

by Aden

created 2016-03-02 15:54 UTC

ModelAdmin::routeParameters() A

↳ Parent: ModelAdmin

Complexity

Conditions	1
Paths	1

Size

Total Lines	6
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Metric	Value
dl	0
loc	6
rs	9.4285
cc	1
eloc	3
nc	1
nop	0

<?php

namespace LaravelFlare\Flare\Admin\Models;

use Illuminate\Support\Str;
use LaravelFlare\Flare\Admin\Admin;
use LaravelFlare\Flare\Exceptions\ModelAdminException;
use LaravelFlare\Flare\Admin\Models\Traits\ModelSaving;
use LaravelFlare\Flare\Admin\Models\Traits\ModelQuerying;
use LaravelFlare\Flare\Contracts\ModelAdmin\ModelQueryable;

class ModelAdmin extends Admin implements ModelQueryable
{
    use ModelQuerying;
    use ModelSaving;

    /**
     * Class of Model to Manage.
     * 
     * @var string
     */
    protected $managedModel;

    /**
     * Entiy Title .
     *
     * @var string
     */
    protected $entityTitle;

    /**
     * Plural Entity Title.
     *
     * @var string
     */
    protected $pluralEntityTitle;

    /**
     * Validation Rules for onCreate, onEdit actions.
     * 
     * @var array
     */
    protected $rules = [];

    /**
     * Columns for Model.
     *
     * Defines which fields to show in the listing tables output.
     * 
     * @var array
     */
    protected $columns = [];

    /**
     * Map Model Attributes to FieldTypes with
     * additional parameters which will be output
     * as fields when viewing, editting or adding
     * a new model entry.
     * 
     * @var array
     */
    protected $fields = [];

    /**
     * Columns for Model are Sortable.
     *
     * @var bool
     */
    protected $sortable = true;

    /**
     * The Controller to be used by the Model Admin.
     *
     * This defaults to parent::getController()
     * if it has been left undefined. 
     * 
     * @var string
     */
    protected $controller = '\LaravelFlare\Flare\Admin\Models\ModelAdminController';

    /**
     * The Policy used for the Model Authorization logic.
     *
     * This class should implement the ModelAdminPoliceable which
     * includes authorization checks for the create, view, edit and delete actions.
     * 
     * @var string
     */
    protected $policy = '\LaravelFlare\Flare\Permissions\ModelAdminPolicy';

    /**
     * The current model to be managed.
     * 
     * @var Model
     */
    public $model;

    /**
     * __construct.
     */
    public function __construct()
    {
        $this->getManagedModel();

        $this->model = $this->model();
    }

    /**
     * Returns a Model Instance.
     * 
     * @return Model
     */
    public function model()
    {
        if (!$this->model) {
            $class = $this->getManagedModel();

            return $this->model = new $class();
        }

        return $this->model;
    }

    /**
     * Returns a New Model Instance.
     *
     * @return Model
     */
    public function newModel()
    {
        $class = self::getManagedModel();

        return new $class();
    }

    /**
     * Returns the Managed Model Class.
     * 
     * @return string
     */
    public function getManagedModel()
    {
        if (!isset($this->managedModel) || $this->managedModel === null) {
            throw new ModelAdminException('You have a ModelAdmin which does not have a model assigned to it. ModelAdmins must include a model to manage.', 1);
        }

        return $this->managedModel;
    }

    /**
     * Set the Managed Model Class.
     * 
     * @param string $managedModel
     */
    public function setManagedModel($managedModel = null)
    {
        $this->managedModel = $managedModel;
    }

    /**
     * Get the Entity Title.
     *
     * @return string
     */
    public function getEntityTitle()
    {
        if (!isset($this->entityTitle) || !$this->entityTitle) {
            return $this->getTitle();
        }

        return $this->entityTitle;
    }

    /**
     * Set Entity Title.
     *
     * @param string $entityTitle
     */
    public function setTitle($entityTitle = null)
    {
        $this->entityTitle = $title;

    }

    /**
     * Plural Entity Title
     *
     * @return string
     */
    public function getPluralEntityTitle()
    {
        if (!isset($this->pluralEntityTitle) || !$this->pluralEntityTitle) {
            return Str::plural($this->getEntityTitle());
        }

        return $this->pluralEntityTitle;
    }

    /**
     * Set Plural Title.
     * 
     * @param string $pluralEntityTitle
     */
    public function setPluralTitle($pluralEntityTitle = null)
    {
        $this->pluralEntityTitle = $pluralEntityTitle;
    }


    /**
     * Returns the Route Paramets.
     * 
     * @return array
     */
    public function routeParameters()
    {
        return array_merge(parent::routeParameters(), [
                                                    'model' => $this->managedModel,
                                                ]);
    }

    /**
     * Formats and returns the Columns.
     *
     * This is really gross, I'm removing it soon.
     * 
     * @return
     */
    public function getColumns()
    {
        $columns = [];

        foreach ($this->columns as $field => $fieldTitle) {
            if (in_array($field, $this->model->getFillable())) {
                if (!$field) {
                    $field = $fieldTitle;
                    $fieldTitle = Str::title($fieldTitle);
                }
                $columns[$field] = $fieldTitle;
                continue;
            }

            // We can replace this with data_get() I believe.
            if (($methodBreaker = strpos($field, '.')) !== false) {
                $method = substr($field, 0, $methodBreaker);
                if (method_exists($this->model, $method)) {
                    if (method_exists($this->model->$method(), $submethod = str_replace($method.'.', '', $field))) {
                        $this->model->$method()->$submethod();

                        $columns[$field] = $fieldTitle;
                        continue;
                    }
                }
            }

            if (is_numeric($field)) {
                $field = $fieldTitle;
                $fieldTitle = Str::title($fieldTitle);
            }

            $columns[$field] = $fieldTitle;
        }

        if (count($columns)) {
            return $columns;
        }

        return [$this->model->getKeyName() => $this->model->getKeyName()];
    }

    /**
     * Gets an Attribute by the provided key
     * on either the current model or a provided model instance.
     * 
     * @param string $key
     * @param mixed  $model
     * 
     * @return mixed
     */
    public function getAttribute($key, $model = false)
    {
        if (!$key) {
            return;
        }

        if (!$model) {
            $model = $this->model;
        }

        if ($this->hasGetAccessor($key)) {
            $method = 'get'.Str::studly($key).'Attribute';

            return $this->{$method}($model);
        }

        if ($this->hasRelatedKey($key, $model)) {
            return $this->relatedKey($key, $model);
        }

        return $model->getAttribute($key);
    }

    /**
     * Determine if a get accessor exists for an attribute.
     *
     * @param string $key
     * 
     * @return bool
     */
    public function hasGetAccessor($key)
    {
        return method_exists($this, 'get'.Str::studly($key).'Attribute');
    }

    /**
     * Determines if a key resolved a related Model.
     * 
     * @param string $key
     * @param mixed  $model
     * 
     * @return bool
     */
    public function hasRelatedKey($key, $model = false)
    {
        if (!$model) {
            $model = $this->model;
        }

        if (($methodBreaker = strpos($key, '.')) !== false) {
            $method = substr($key, 0, $methodBreaker);
            if (method_exists($model, $method)) {
                return true;
            }
        }

        return false;
    }

    /**
     * Resolves a relation based on the key provided,
     * either on the current model or a provided model instance.
     * 
     * @param string $key
     * @param mixed  $model
     * 
     * @return mixed
     */
    public function relatedKey($key, $model = false)
    {
        if (!$model) {
            $model = $this->model;
        }

        if (($methodBreaker = strpos($key, '.')) !== false) {
            $method = substr($key, 0, $methodBreaker);
            if (method_exists($model, $method)) {
                if (method_exists($model->$method, $submethod = str_replace($method.'.', '', $key))) {
                    return $model->$method->$submethod();
                }

                if (isset($model->$method->$submethod)) {
                    return $model->$method->$submethod;
                }

                return $model->getRelationValue($method);
            }
        }

        return false;
    }

    /**
     * Set a given attribute on the model.
     *
     * @param string $key
     * @param mixed  $value
     */
    public function setAttribute($key, $value)
    {
        if ($this->hasSetMutator($key)) {
            $method = 'set'.Str::studly($key).'Attribute';

            return $this->{$method}($value);
        }

        $this->model->attributes[$key] = $value;
    }

    /**
     * Determine if a set mutator exists for an attribute.
     *
     * @param string $key
     * 
     * @return bool
     */
    public function hasSetMutator($key)
    {
        return method_exists($this, 'set'.Str::studly($key).'Attribute');
    }

    /**
     * Determine if a get mutator exists for an attribute.
     *
     * @param string $key
     * 
     * @return bool
     */
    public function hasGetMutator($key)
    {
        return method_exists($this, 'get'.Str::studly($key).'Attribute');
    }

    /**
     * Returns an array of Attribute Fields ready for output.
     * 
     * @return array
     */
    public function outputFields()
    {
        return $this->getFields();
    }

    /**
     * Gets the Managed Model Mapping.
     * 
     * @return array
     */
    public function getFields()
    {
        $this->setFields($this->fields);

        return $this->fields;
    }

    /**
     * Sets the Managed Model Mapping.
     * 
     * @param array $fields
     */
    public function setFields($fields = [])
    {
        $this->fields = $fields;

        $this->formatFields();
    }

    /**
     * Format the provided Attribute Fields into a more usable format.
     */
    protected function formatFields()
    {
        $fields = $this->fields;

        if (!$fields instanceof AttributeCollection) {
            $fields = new AttributeCollection($fields, $this);
        }

        return $this->fields = $fields->formatFields();

    }

    /**
     * Determine if the Model Admin is sortable in it's list view.
     * 
     * @return bool
     */
    public function isSortable()
    {
        return isset($this->sortable) && $this->sortable ? true : false;
    }

    /**
     * Determine if the Model Admin is sortable by a defined key / column.
     *
     * @param string $key
     * 
     * @return bool
     */
    public function isSortableBy($key)
    {
        // Sorting is not allowed on Model Admin
        if (!$this->isSortable()) {
            return false;
        }

        // Key results are mutated, so sorting is not available
        if ($this->model()->hasGetMutator($key) || $this->hasGetMutator($key)) {
            return false;
        }

        // Key is a relation, so sorting is not available 
        if (strpos($key, '.') !== false) {
            return false;
        }

        return true;
    }

    /**
     * Determine if the Model Admin has Viewing Capabilities.
     * 
     * @return bool
     */
    public function hasViewing()
    {
        return $this->hasTrait(\LaravelFlare\Flare\Admin\Models\Traits\ModelViewing::class);
    }

    /**
     * Determine if the Model Admin has Creating Capabilities.
     * 
     * @return bool
     */
    public function hasCreating()
    {
        return $this->hasTrait(\LaravelFlare\Flare\Admin\Models\Traits\ModelCreating::class);
    }

    /**
     * Determine if the Model Admin has Cloning Capabilities.
     * 
     * @return bool
     */
    public function hasCloning()
    {
        return $this->hasTrait(\LaravelFlare\Flare\Admin\Models\Traits\ModelCloning::class);
    }

    /**
     * Determine if the Model Admin has Editting Capabilities.
     * 
     * @return bool
     */
    public function hasEditting()
    {
        return $this->hasTrait(\LaravelFlare\Flare\Admin\Models\Traits\ModelEditting::class);
    }

    /**
     * Determine if the Model Admin has Deleting Capabilities.
     * 
     * @return bool
     */
    public function hasDeleting()
    {
        return $this->hasTrait(\LaravelFlare\Flare\Admin\Models\Traits\ModelDeleting::class);
    }

    /**
     * Determine if the Managed Model is using the SoftDeletes Trait.
     *
     * This is guarded by hasDeleting, since we shouldn't allow SoftDeleting
     * without the deleting trait (even though it isn't really required).
     *
     * @return bool
     */
    public function hasSoftDeleting()
    {
        if (!$this->hasDeleting()) {
$a = canBeFalseAndNull();

// Instead of
if ( ! $a) { }

// Better use one of the explicit versions:
if ($a !== null) { }
if ($a !== false) { }
if ($a !== null && $a !== false) { }
            return false;
        }

        $managedModelClass = $this->getManagedModel();

        return in_array(
            \Illuminate\Database\Eloquent\SoftDeletes::class, class_uses_recursive(get_class(new $managedModelClass()))
        ) && in_array(
            \LaravelFlare\Flare\Admin\Models\Traits\ModelSoftDeleting::class, class_uses_recursive(get_class($this))
        );
    }

    /**
     * Determine if the Model Admin has Validating Capabilities.
     * 
     * @return bool
     */
    public function hasValidating()
    {
        return $this->hasTrait(\LaravelFlare\Flare\Admin\Models\Traits\ModelValidating::class);
    }

    /**
     * Determine if the Managed Model has a Trait and Contract.
     *
     * @return bool
     */
    public function hasTraitAndContract($trait = null, $contract = null)
    {
        return ($this->hasTrait($trait) && $this->hasContract($contract));
    }

    /**
     * Returns whether the current ModelAdmin has a given trait.
     * 
     * @param string $trait
     * 
     * @return bool
     */
    public function hasTrait($trait = null)
    {
        if (!$trait) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
            return;
        }

        return in_array($trait, class_uses_recursive(get_class($this)));
    }

    /**
     * Returns whether the current ModelAdmin has a given contract.
     * 
     * @param string $contract
     * 
     * @return bool
     */
    public function hasContract($contract = null)

    {
        if (!$trait) {

            return;
        }

        $managedModelClass = $this->getManagedModel();
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
    }
}


1			<?php
2
3			namespace LaravelFlare\Flare\Admin\Models;
4
5			use Illuminate\Support\Str;
6			use LaravelFlare\Flare\Admin\Admin;
7			use LaravelFlare\Flare\Exceptions\ModelAdminException;
8			use LaravelFlare\Flare\Admin\Models\Traits\ModelSaving;
9			use LaravelFlare\Flare\Admin\Models\Traits\ModelQuerying;
10			use LaravelFlare\Flare\Contracts\ModelAdmin\ModelQueryable;
11
12			class ModelAdmin extends Admin implements ModelQueryable
13			{
14			use ModelQuerying;
15			use ModelSaving;
16
17			/**
18			* Class of Model to Manage.
19			*
20			* @var string
21			*/
22			protected $managedModel;
23
24			/**
25			* Entiy Title .
26			*
27			* @var string
28			*/
29			protected $entityTitle;
30
31			/**
32			* Plural Entity Title.
33			*
34			* @var string
35			*/
36			protected $pluralEntityTitle;
37
38			/**
39			* Validation Rules for onCreate, onEdit actions.
40			*
41			* @var array
42			*/
43			protected $rules = [];
44
45			/**
46			* Columns for Model.
47			*
48			* Defines which fields to show in the listing tables output.
49			*
50			* @var array
51			*/
52			protected $columns = [];
53
54			/**
55			* Map Model Attributes to FieldTypes with
56			* additional parameters which will be output
57			* as fields when viewing, editting or adding
58			* a new model entry.
59			*
60			* @var array
61			*/
62			protected $fields = [];
63
64			/**
65			* Columns for Model are Sortable.
66			*
67			* @var bool
68			*/
69			protected $sortable = true;
70
71			/**
72			* The Controller to be used by the Model Admin.
73			*
74			* This defaults to parent::getController()
75			* if it has been left undefined.
76			*
77			* @var string
78			*/
79			protected $controller = '\LaravelFlare\Flare\Admin\Models\ModelAdminController';
80
81			/**
82			* The Policy used for the Model Authorization logic.
83			*
84			* This class should implement the ModelAdminPoliceable which
85			* includes authorization checks for the create, view, edit and delete actions.
86			*
87			* @var string
88			*/
89			protected $policy = '\LaravelFlare\Flare\Permissions\ModelAdminPolicy';
90
91			/**
92			* The current model to be managed.
93			*
94			* @var Model
95			*/
96			public $model;
97
98			/**
99			* __construct.
100			*/
101			public function __construct()
102			{
103			$this->getManagedModel();
104
105			$this->model = $this->model();
106			}
107
108			/**
109			* Returns a Model Instance.
110			*
111			* @return Model
112			*/
113			public function model()
114			{
115			if (!$this->model) {
116			$class = $this->getManagedModel();
117
118			return $this->model = new $class();
119			}
120
121			return $this->model;
122			}
123
124			/**
125			* Returns a New Model Instance.
126			*
127			* @return Model
128			*/
129			public function newModel()
130			{
131			$class = self::getManagedModel();
132
133			return new $class();
134			}
135
136			/**
137			* Returns the Managed Model Class.
138			*
139			* @return string
140			*/
141			public function getManagedModel()
142			{
143			if (!isset($this->managedModel) \|\| $this->managedModel === null) {
144			throw new ModelAdminException('You have a ModelAdmin which does not have a model assigned to it. ModelAdmins must include a model to manage.', 1);
145			}
146
147			return $this->managedModel;
148			}
149
150			/**
151			* Set the Managed Model Class.
152			*
153			* @param string $managedModel
154			*/
155			public function setManagedModel($managedModel = null)
156			{
157			$this->managedModel = $managedModel;
158			}
159
160			/**
161			* Get the Entity Title.
162			*
163			* @return string
164			*/
165			public function getEntityTitle()
166			{
167			if (!isset($this->entityTitle) \|\| !$this->entityTitle) {
168			return $this->getTitle();
169			}
170
171			return $this->entityTitle;
172			}
173
174			/**
175			* Set Entity Title.
176			*
177			* @param string $entityTitle
178			*/
179			public function setTitle($entityTitle = null)
180			{
181			$this->entityTitle = $title;
			0 ignored issues – show Bug introduced 2016-03-02 15:57 UTC by Report Bug Copy Issue Report The variable `$title` does not exist. Did you forget to declare it? This check marks access to variables or properties that have not been declared yet. While PHP has no explicit notion of declaring a variable, accessing it before a value is assigned to it is most likely a bug. Loading history...
182			}
183
184			/**
185			* Plural Entity Title
186			*
187			* @return string
188			*/
189			public function getPluralEntityTitle()
190			{
191			if (!isset($this->pluralEntityTitle) \|\| !$this->pluralEntityTitle) {
192			return Str::plural($this->getEntityTitle());
193			}
194
195			return $this->pluralEntityTitle;
196			}
197
198			/**
199			* Set Plural Title.
200			*
201			* @param string $pluralEntityTitle
202			*/
203			public function setPluralTitle($pluralEntityTitle = null)
204			{
205			$this->pluralEntityTitle = $pluralEntityTitle;
206			}
207
208
209			/**
210			* Returns the Route Paramets.
211			*
212			* @return array
213			*/
214			public function routeParameters()
215			{
216			return array_merge(parent::routeParameters(), [
217			'model' => $this->managedModel,
218			]);
219			}
220
221			/**
222			* Formats and returns the Columns.
223			*
224			* This is really gross, I'm removing it soon.
225			*
226			* @return
227			*/
228			public function getColumns()
229			{
230			$columns = [];
231
232			foreach ($this->columns as $field => $fieldTitle) {
233			if (in_array($field, $this->model->getFillable())) {
234			if (!$field) {
235			$field = $fieldTitle;
236			$fieldTitle = Str::title($fieldTitle);
237			}
238			$columns[$field] = $fieldTitle;
239			continue;
240			}
241
242			// We can replace this with data_get() I believe.
243			if (($methodBreaker = strpos($field, '.')) !== false) {
244			$method = substr($field, 0, $methodBreaker);
245			if (method_exists($this->model, $method)) {
246			if (method_exists($this->model->$method(), $submethod = str_replace($method.'.', '', $field))) {
247			$this->model->$method()->$submethod();
248
249			$columns[$field] = $fieldTitle;
250			continue;
251			}
252			}
253			}
254
255			if (is_numeric($field)) {
256			$field = $fieldTitle;
257			$fieldTitle = Str::title($fieldTitle);
258			}
259
260			$columns[$field] = $fieldTitle;
261			}
262
263			if (count($columns)) {
264			return $columns;
265			}
266
267			return [$this->model->getKeyName() => $this->model->getKeyName()];
268			}
269
270			/**
271			* Gets an Attribute by the provided key
272			* on either the current model or a provided model instance.
273			*
274			* @param string $key
275			* @param mixed $model
276			*
277			* @return mixed
278			*/
279			public function getAttribute($key, $model = false)
280			{
281			if (!$key) {
282			return;
283			}
284
285			if (!$model) {
286			$model = $this->model;
287			}
288
289			if ($this->hasGetAccessor($key)) {
290			$method = 'get'.Str::studly($key).'Attribute';
291
292			return $this->{$method}($model);
293			}
294
295			if ($this->hasRelatedKey($key, $model)) {
296			return $this->relatedKey($key, $model);
297			}
298
299			return $model->getAttribute($key);
300			}
301
302			/**
303			* Determine if a get accessor exists for an attribute.
304			*
305			* @param string $key
306			*
307			* @return bool
308			*/
309			public function hasGetAccessor($key)
310			{
311			return method_exists($this, 'get'.Str::studly($key).'Attribute');
312			}
313
314			/**
315			* Determines if a key resolved a related Model.
316			*
317			* @param string $key
318			* @param mixed $model
319			*
320			* @return bool
321			*/
322			public function hasRelatedKey($key, $model = false)
323			{
324			if (!$model) {
325			$model = $this->model;
326			}
327
328			if (($methodBreaker = strpos($key, '.')) !== false) {
329			$method = substr($key, 0, $methodBreaker);
330			if (method_exists($model, $method)) {
331			return true;
332			}
333			}
334
335			return false;
336			}
337
338			/**
339			* Resolves a relation based on the key provided,
340			* either on the current model or a provided model instance.
341			*
342			* @param string $key
343			* @param mixed $model
344			*
345			* @return mixed
346			*/
347			public function relatedKey($key, $model = false)
348			{
349			if (!$model) {
350			$model = $this->model;
351			}
352
353			if (($methodBreaker = strpos($key, '.')) !== false) {
354			$method = substr($key, 0, $methodBreaker);
355			if (method_exists($model, $method)) {
356			if (method_exists($model->$method, $submethod = str_replace($method.'.', '', $key))) {
357			return $model->$method->$submethod();
358			}
359
360			if (isset($model->$method->$submethod)) {
361			return $model->$method->$submethod;
362			}
363
364			return $model->getRelationValue($method);
365			}
366			}
367
368			return false;
369			}
370
371			/**
372			* Set a given attribute on the model.
373			*
374			* @param string $key
375			* @param mixed $value
376			*/
377			public function setAttribute($key, $value)
378			{
379			if ($this->hasSetMutator($key)) {
380			$method = 'set'.Str::studly($key).'Attribute';
381
382			return $this->{$method}($value);
383			}
384
385			$this->model->attributes[$key] = $value;
386			}
387
388			/**
389			* Determine if a set mutator exists for an attribute.
390			*
391			* @param string $key
392			*
393			* @return bool
394			*/
395			public function hasSetMutator($key)
396			{
397			return method_exists($this, 'set'.Str::studly($key).'Attribute');
398			}
399
400			/**
401			* Determine if a get mutator exists for an attribute.
402			*
403			* @param string $key
404			*
405			* @return bool
406			*/
407			public function hasGetMutator($key)
408			{
409			return method_exists($this, 'get'.Str::studly($key).'Attribute');
410			}
411
412			/**
413			* Returns an array of Attribute Fields ready for output.
414			*
415			* @return array
416			*/
417			public function outputFields()
418			{
419			return $this->getFields();
420			}
421
422			/**
423			* Gets the Managed Model Mapping.
424			*
425			* @return array
426			*/
427			public function getFields()
428			{
429			$this->setFields($this->fields);
430
431			return $this->fields;
432			}
433
434			/**
435			* Sets the Managed Model Mapping.
436			*
437			* @param array $fields
438			*/
439			public function setFields($fields = [])
440			{
441			$this->fields = $fields;
442
443			$this->formatFields();
444			}
445
446			/**
447			* Format the provided Attribute Fields into a more usable format.
448			*/
449			protected function formatFields()
450			{
451			$fields = $this->fields;
452
453			if (!$fields instanceof AttributeCollection) {
454			$fields = new AttributeCollection($fields, $this);
455			}
456
457			return $this->fields = $fields->formatFields();
			0 ignored issues – show Documentation Bug introduced 2016-02-19 13:54 UTC by Report Bug Copy Issue Report It seems like `$fields->formatFields()` of type `object<LaravelFlare\Flar...ls\AttributeCollection>` is incompatible with the declared type `array` of property `$fields`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
458			}
459
460			/**
461			* Determine if the Model Admin is sortable in it's list view.
462			*
463			* @return bool
464			*/
465			public function isSortable()
466			{
467			return isset($this->sortable) && $this->sortable ? true : false;
468			}
469
470			/**
471			* Determine if the Model Admin is sortable by a defined key / column.
472			*
473			* @param string $key
474			*
475			* @return bool
476			*/
477			public function isSortableBy($key)
478			{
479			// Sorting is not allowed on Model Admin
480			if (!$this->isSortable()) {
481			return false;
482			}
483
484			// Key results are mutated, so sorting is not available
485			if ($this->model()->hasGetMutator($key) \|\| $this->hasGetMutator($key)) {
486			return false;
487			}
488
489			// Key is a relation, so sorting is not available
490			if (strpos($key, '.') !== false) {
491			return false;
492			}
493
494			return true;
495			}
496
497			/**
498			* Determine if the Model Admin has Viewing Capabilities.
499			*
500			* @return bool
501			*/
502			public function hasViewing()
503			{
504			return $this->hasTrait(\LaravelFlare\Flare\Admin\Models\Traits\ModelViewing::class);
505			}
506
507			/**
508			* Determine if the Model Admin has Creating Capabilities.
509			*
510			* @return bool
511			*/
512			public function hasCreating()
513			{
514			return $this->hasTrait(\LaravelFlare\Flare\Admin\Models\Traits\ModelCreating::class);
515			}
516
517			/**
518			* Determine if the Model Admin has Cloning Capabilities.
519			*
520			* @return bool
521			*/
522			public function hasCloning()
523			{
524			return $this->hasTrait(\LaravelFlare\Flare\Admin\Models\Traits\ModelCloning::class);
525			}
526
527			/**
528			* Determine if the Model Admin has Editting Capabilities.
529			*
530			* @return bool
531			*/
532			public function hasEditting()
533			{
534			return $this->hasTrait(\LaravelFlare\Flare\Admin\Models\Traits\ModelEditting::class);
535			}
536
537			/**
538			* Determine if the Model Admin has Deleting Capabilities.
539			*
540			* @return bool
541			*/
542			public function hasDeleting()
543			{
544			return $this->hasTrait(\LaravelFlare\Flare\Admin\Models\Traits\ModelDeleting::class);
545			}
546
547			/**
548			* Determine if the Managed Model is using the SoftDeletes Trait.
549			*
550			* This is guarded by hasDeleting, since we shouldn't allow SoftDeleting
551			* without the deleting trait (even though it isn't really required).
552			*
553			* @return bool
554			*/
555			public function hasSoftDeleting()
556			{
557			if (!$this->hasDeleting()) {
			0 ignored issues – show Bug Best Practice introduced 2016-02-09 11:27 UTC by Report Bug Copy Issue Report The expression `$this->hasDeleting()` of type `null\|boolean` is loosely compared to `false`; this is ambiguous if the boolean can be false. You might want to explicitly use `!== null` instead. If an expression can have both `false`, and `null` as possible values. It is generally a good practice to always use strict comparison to clearly distinguish between those two values. $a = canBeFalseAndNull(); // Instead of if ( ! $a) { } // Better use one of the explicit versions: if ($a !== null) { } if ($a !== false) { } if ($a !== null && $a !== false) { } Loading history...
558			return false;
559			}
560
561			$managedModelClass = $this->getManagedModel();
562
563			return in_array(
564			\Illuminate\Database\Eloquent\SoftDeletes::class, class_uses_recursive(get_class(new $managedModelClass()))
565			) && in_array(
566			\LaravelFlare\Flare\Admin\Models\Traits\ModelSoftDeleting::class, class_uses_recursive(get_class($this))
567			);
568			}
569
570			/**
571			* Determine if the Model Admin has Validating Capabilities.
572			*
573			* @return bool
574			*/
575			public function hasValidating()
576			{
577			return $this->hasTrait(\LaravelFlare\Flare\Admin\Models\Traits\ModelValidating::class);
578			}
579
580			/**
581			* Determine if the Managed Model has a Trait and Contract.
582			*
583			* @return bool
584			*/
585			public function hasTraitAndContract($trait = null, $contract = null)
586			{
587			return ($this->hasTrait($trait) && $this->hasContract($contract));
588			}
589
590			/**
591			* Returns whether the current ModelAdmin has a given trait.
592			*
593			* @param string $trait
594			*
595			* @return bool
596			*/
597			public function hasTrait($trait = null)
598			{
599			if (!$trait) {
			0 ignored issues – show Bug Best Practice introduced 2016-02-09 11:27 UTC by Report Bug Copy Issue Report The expression `$trait` of type `string\|null` is loosely compared to `false`; this is ambiguous if the string can be empty. You might want to explicitly use `=== null` instead. In PHP, under loose comparison (like `==`, or `!=`, or `switch` conditions), values of different types might be equal. For `string` values, the empty string `''` is a special case, in particular the following results might be unexpected: '' == false // true '' == null // true 'ab' == false // false 'ab' == null // false // It is often better to use strict comparison '' === false // false '' === null // false Loading history...
600			return;
601			}
602
603			return in_array($trait, class_uses_recursive(get_class($this)));
604			}
605
606			/**
607			* Returns whether the current ModelAdmin has a given contract.
608			*
609			* @param string $contract
610			*
611			* @return bool
612			*/
613			public function hasContract($contract = null)
			0 ignored issues – show Unused Code introduced 2016-02-09 11:27 UTC by Report Bug Copy Issue Report The parameter `$contract` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
614			{
615			if (!$trait) {
			0 ignored issues – show Bug introduced 2016-02-09 11:27 UTC by Report Bug Copy Issue Report The variable `$trait` does not exist. Did you forget to declare it? This check marks access to variables or properties that have not been declared yet. While PHP has no explicit notion of declaring a variable, accessing it before a value is assigned to it is most likely a bug. Loading history...
616			return;
617			}
618
619			$managedModelClass = $this->getManagedModel();
			0 ignored issues – show Unused Code introduced 2016-02-09 11:27 UTC by Report Bug Copy Issue Report `$managedModelClass` is not used, you could remove the assignment. This check looks for variable assignements that are either overwritten by other assignments or where the variable is not used subsequently. $myVar = 'Value'; $higher = false; if (rand(1, 6) > 3) { $higher = true; } else { $higher = false; } Both the `$myVar` assignment in line 1 and the `$higher` assignment in line 2 are dead. The first because `$myVar` is never used and the second because `$higher` is always overwritten for every possible time line. Loading history...
620			}
621			}
622

laravelflare / flare

GitHub Access Token became invalid

Push — master ( 32da41...f25af1 )

ModelAdmin::routeParameters() A

Complexity

Size

Duplication

Duplication Side-by-Side

Filter issues like