Issues in CrudApi.php (master) - Issues in master - taskforcedev/crud-api - Measure and Improve Code Quality continuously with Scrutinizer

Issues (32)

Security Analysis not enabled

Cross-Site Scripting

Cross-Site Scripting enables an attacker to inject code into the response of a web-request that is viewed by other users. It can for example be used to bypass access controls, or even to take over other users' accounts.

File Exposure

File Exposure allows an attacker to gain access to local files that he should not be able to access. These files can for example include database credentials, or other configuration files.

File Manipulation

File Manipulation enables an attacker to write custom data to files. This potentially leads to injection of arbitrary code on the server.

Object Injection

Object Injection enables an attacker to inject an object into PHP code, and can lead to arbitrary code execution, file exposure, or file manipulation attacks.

Code Injection

Code Injection enables an attacker to execute arbitrary code on the server.

Response Splitting

Response Splitting can be used to send arbitrary responses.

File Inclusion

File Inclusion enables an attacker to inject custom files into PHP's file loading mechanism, either explicitly passed to include, or for example via PHP's auto-loading mechanism.

Command Injection

Command Injection enables an attacker to inject a shell command that is execute with the privileges of the web-server. This can be used to expose sensitive data, or gain access of your server.

SQL Injection

SQL Injection enables an attacker to execute arbitrary SQL code on your database server gaining access to user data, or manipulating user data.

XPath Injection

XPath Injection enables an attacker to modify the parts of XML document that are read. If that XML document is for example used for authentication, this can lead to further vulnerabilities similar to SQL Injection.

LDAP Injection

LDAP Injection enables an attacker to inject LDAP statements potentially granting permission to run unauthorized queries, or modify content inside the LDAP tree.

Header Injection

Other Vulnerability

This category comprises other attack vectors such as manipulating the PHP runtime, loading custom extensions, freezing the runtime, or similar.

Regex Injection

Regex Injection enables an attacker to execute arbitrary code in your PHP process.

XML Injection

XML Injection enables an attacker to read files on your local filesystem including configuration files, or can be abused to freeze your web-server process.

Variable Injection

Variable Injection enables an attacker to overwrite program variables with custom data, and can lead to further vulnerabilities.

Unfortunately, the security analysis is currently not available for your project. If you are a non-commercial open-source project, please contact support to gain access.

src/Helpers/CrudApi.php (9 issues)

Labels

Severity

Upgrade to new PHP Analysis Engine

These results are based on our legacy PHP analysis, consider migrating to our new PHP analysis engine instead. Learn more

<?php

namespace Taskforcedev\CrudApi\Helpers;

use Illuminate\Console\DetectsApplicationNamespace;

class CrudApi
{
    use DetectsApplicationNamespace;

    public $model;
    public $instance;
    public $namespace;
    public $modelHelper;
    public $fieldHelper;

    /**
     * CrudApi Helper.
     * @param array $options
     */
    public function __construct($options = [])
    {
        /* Set the namespace */
        if (array_key_exists('namespace', $options)) {
            $this->namespace = $options['namespace'];
        } else {
            $this->namespace = $this->getAppNamespace();
        }

        /* Set the model */
        if (array_key_exists('model', $options)) {
            $this->model = $options['model'];
        }

        $this->modelHelper = new Model($this);
        $this->fieldHelper = new Field($this);
    }

    /**
     * Set the Crud API Model Helper.
     * @param object $modelHelper Model Helper Object.
     */
    public function setModelHelper($modelHelper)
    {
        $this->modelHelper = $modelHelper;
    }

    /**
     * Set the namespace to search within.
     *
     * @param string $namespace
     */
    public function setNamespace($namespace)
    {
        $this->namespace = $namespace;
    }

    /**
     * Set the model to work with.
     *
     * @param string $model Model name.
     *
     * @return $this
     */
    public function setModel($model)
    {
        $this->model = $model;

        return $this;
    }

    /**
     * Set a model instance from which to work.
     *
     * @param Object $item Model instance
     *
     * @return $this
     */
    public function setInstance($item)
    {
        $this->instance = $item;

        return $this;
    }

    /**
     * Get Fields
     *
     * Get a models fillable fields.
     *
     * @return array
     */
    public function getFields()
    {
        $model = $this->getModelInstance();
        $fields = $model->getFillable();
        $filtered_fields = [];

        foreach ($fields as $f) {
            if ($f !== 'password' && $f !== 'Password') {
                $filtered_fields[] = $f;
            }
        }

        return $filtered_fields;
    }

    /**
     * Get a models display name.
     * @return string
     */
    public function getModelDisplayName()
    {
        $instance = $this->getModelInstance();
        $display = isset($instance->display) ? $instance->display : ucfirst($this->model);

        return $display;
    }

    /**
     * Get an instance of a model.
     * @return bool
     */
    public function getModelInstance()
    {
        if ($this->instance !== null) {
            return $this->instance;
        }
        $model = $this->getModel();
        if ($model === false) {
            return false;
        }
        $instance = new $model();

        return $instance;
    }

    /**
     * Generate a modal for a model.
     * @param string $type Modal type (edit, create, delete).
     * @return object
     */
    public function modal($type)
    {
        $trimmed_item = $this->trimmedModel();

        $modalId = $type.$trimmed_item.'Modal';

        $display = $this->getModelDisplayName();

        $modal = (object) [
            'id' => $modalId,
            'title' => ucfirst($type).' '.$display,
            'url' => $this->modalUrl($type),
        ];

        return $modal;
    }

    /**
     * Get the modals url.
     *
     * @param $type
     *
     * @return string
     */
    private function modalUrl($type)

    {
        switch ($type) {
        case 'edit':
            $action = 'update';
            break;
        default:
            $action = $type;
            break;
        }

        return route('crudapi.'.$action.'.item', $this->model);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    /**
     * Get the name of the javascript method for a model.
     *
     * @param $method
     *
     * @return string
     */
    public function jsMethodName($method)
    {
        // Method == create
        $jsMethod = $method.$this->trimmedModel();

        return $jsMethod;
    }

    /**
     * Render fields.
     * @param $type
     * @param array $fields
     */
    public function renderFields($type, $fields = [])
    {
        if (empty($fields)) {
            $fields = $this->getFields();
        }
        $output = '';

        switch ($type) {
        case 'form-create':
            $output .= $this->fieldHelper->formCreate($fields);
            break;
        case 'form-edit':
            $output .= $this->fieldHelper->formEdit($fields);
            break;
        case 'table-headings':
            $output .= $this->fieldHelper->tableHeadings($fields);
            break;
        case 'table-content':
            $output .= $this->fieldHelper->tableContent($fields, $this->instance);
            break;
            // JavaScript Variables
        case 'js-var':
            foreach ($fields as $f) {
                $output .= 'var '.$f.' = '.$this->instance->$f.'; ';
            }
            break;
        case 'js-modal-create':
            foreach ($fields as $f) {
                $output .= '"'.$f.'": $(\'#createItem'.$f.'\').val(), ';
            }
            break;
        default:
            break;
        }

        echo $output;
    }

    public function trimmedModel()
    {
        return strpos($this->model, ' ') !== false ? implode('', explode(' ', $this->model)) : $this->model;
    }

    public function getRelatedOptions($relation)
    {
        $output = '';

        if (!method_exists($relation, 'toOptions')) {
            $relationItems = $relation::all();
            foreach ($relationItems as $item) {
                if (isset($item->name)) {
                    $output .= '<option value="'.$item->id.'">'.$item->name.'</option>';
                }
            }
        } else {
            $output .= $relation->toOptions();
        }

        return $output;
    }

    public function getRelatedModel($f)
    {
        $field = $this->getRelatedField($f);
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
        $model = $this->getModel($field);


        $modelAliases = [
            'author' => 'user',
        ];

        // If class doesn't exist, check if is in aliases array.
        if (!class_exists($model)) {
            if (array_key_exists($field, $modelAliases)) {
                $aliasedModel = $modelAliases[$field];
                $model = $this->getModel($aliasedModel);

            }
        }

        // Model could not be found, try via it's converted name.
        if (!class_exists($model)) {
            // Convert from DB format to Pascal
            $words = explode('_', $field);
            foreach ($words as $i => $w) {
                $words[$i] = ucfirst($w);
            }
            $formatted = implode('', $words);
            $model = 'App\\'.$formatted;
            if (!class_exists($model)) {
                return false;
            }
        }

        return new $model();
    }

    public function getRelatedDisplay($f)
    {
        $related_field = $this->getRelatedField($f);
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }

        $field = $this->instance->$related_field;

        $class = get_class($field);

        switch ($class) {
        case 'App\\Helpers\\CrudApi':
            break;
        case 'App\\Indicator':
            return $field->indicator;
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
        case 'Taskforcedev\\CrudApi\\Helpers\\CrudApi':
            return false;
        default:
            return $field->name;
        }
    }

    /**
     * Allow certain methods to be passed through to the specified
     * helper in order to make methods easier to remember.
     *
     * @param $method
     * @param $args
     *
     * @method string getRelatedField
     * @method string getPrimaryField
     * @method bool isIdField
     * @method mixed getModel
     *
     * @return bool
     */
    public function __call($method, $args)
    {
        switch ($method) {
            case 'getRelatedField':
                return $this->fieldHelper->getRelatedField($args[0]);
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
            case 'getPrimaryField':
                return $this->fieldHelper->getPrimaryField($args[0]);
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
            case 'isIdField':
                return $this->fieldHelper->isIdField($args[0]);
            case 'getModel':
                if (isset($args[0])) {
                    return $this->modelHelper->getModel($args[0]);
                }
                return $this->modelHelper->getModel();
            default:
                break;
        }
    }
}


1			<?php
2
3			namespace Taskforcedev\CrudApi\Helpers;
4
5			use Illuminate\Console\DetectsApplicationNamespace;
6
7			class CrudApi
8			{
9			use DetectsApplicationNamespace;
10
11			public $model;
12			public $instance;
13			public $namespace;
14			public $modelHelper;
15			public $fieldHelper;
16
17			/**
18			* CrudApi Helper.
19			* @param array $options
20			*/
21			public function __construct($options = [])
22			{
23			/* Set the namespace */
24			if (array_key_exists('namespace', $options)) {
25			$this->namespace = $options['namespace'];
26			} else {
27			$this->namespace = $this->getAppNamespace();
28			}
29
30			/* Set the model */
31			if (array_key_exists('model', $options)) {
32			$this->model = $options['model'];
33			}
34
35			$this->modelHelper = new Model($this);
36			$this->fieldHelper = new Field($this);
37			}
38
39			/**
40			* Set the Crud API Model Helper.
41			* @param object $modelHelper Model Helper Object.
42			*/
43			public function setModelHelper($modelHelper)
44			{
45			$this->modelHelper = $modelHelper;
46			}
47
48			/**
49			* Set the namespace to search within.
50			*
51			* @param string $namespace
52			*/
53			public function setNamespace($namespace)
54			{
55			$this->namespace = $namespace;
56			}
57
58			/**
59			* Set the model to work with.
60			*
61			* @param string $model Model name.
62			*
63			* @return $this
64			*/
65			public function setModel($model)
66			{
67			$this->model = $model;
68
69			return $this;
70			}
71
72			/**
73			* Set a model instance from which to work.
74			*
75			* @param Object $item Model instance
76			*
77			* @return $this
78			*/
79			public function setInstance($item)
80			{
81			$this->instance = $item;
82
83			return $this;
84			}
85
86			/**
87			* Get Fields
88			*
89			* Get a models fillable fields.
90			*
91			* @return array
92			*/
93			public function getFields()
94			{
95			$model = $this->getModelInstance();
96			$fields = $model->getFillable();
97			$filtered_fields = [];
98
99			foreach ($fields as $f) {
100			if ($f !== 'password' && $f !== 'Password') {
101			$filtered_fields[] = $f;
102			}
103			}
104
105			return $filtered_fields;
106			}
107
108			/**
109			* Get a models display name.
110			* @return string
111			*/
112			public function getModelDisplayName()
113			{
114			$instance = $this->getModelInstance();
115			$display = isset($instance->display) ? $instance->display : ucfirst($this->model);
116
117			return $display;
118			}
119
120			/**
121			* Get an instance of a model.
122			* @return bool
123			*/
124			public function getModelInstance()
125			{
126			if ($this->instance !== null) {
127			return $this->instance;
128			}
129			$model = $this->getModel();
130			if ($model === false) {
131			return false;
132			}
133			$instance = new $model();
134
135			return $instance;
136			}
137
138			/**
139			* Generate a modal for a model.
140			* @param string $type Modal type (edit, create, delete).
141			* @return object
142			*/
143			public function modal($type)
144			{
145			$trimmed_item = $this->trimmedModel();
146
147			$modalId = $type.$trimmed_item.'Modal';
148
149			$display = $this->getModelDisplayName();
150
151			$modal = (object) [
152			'id' => $modalId,
153			'title' => ucfirst($type).' '.$display,
154			'url' => $this->modalUrl($type),
155			];
156
157			return $modal;
158			}
159
160			/**
161			* Get the modals url.
162			*
163			* @param $type
164			*
165			* @return string
166			*/
167			private function modalUrl($type)
			0 ignored issues – show Unused Code introduced 2017-09-01 15:14 UTC by Report Bug Copy Issue Report Show Similar Issues like this This method is not used, and could be removed. Loading history...
168			{
169			switch ($type) {
170			case 'edit':
171			$action = 'update';
172			break;
173			default:
174			$action = $type;
175			break;
176			}
177
178			return route('crudapi.'.$action.'.item', $this->model);
			0 ignored issues – show Documentation introduced 2017-02-02 13:22 UTC by Report Bug Copy Issue Report Show Similar Issues like this `$this->model` is of type `string`, but the function expects a `array`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
179			}
180
181			/**
182			* Get the name of the javascript method for a model.
183			*
184			* @param $method
185			*
186			* @return string
187			*/
188			public function jsMethodName($method)
189			{
190			// Method == create
191			$jsMethod = $method.$this->trimmedModel();
192
193			return $jsMethod;
194			}
195
196			/**
197			* Render fields.
198			* @param $type
199			* @param array $fields
200			*/
201			public function renderFields($type, $fields = [])
202			{
203			if (empty($fields)) {
204			$fields = $this->getFields();
205			}
206			$output = '';
207
208			switch ($type) {
209			case 'form-create':
210			$output .= $this->fieldHelper->formCreate($fields);
211			break;
212			case 'form-edit':
213			$output .= $this->fieldHelper->formEdit($fields);
214			break;
215			case 'table-headings':
216			$output .= $this->fieldHelper->tableHeadings($fields);
217			break;
218			case 'table-content':
219			$output .= $this->fieldHelper->tableContent($fields, $this->instance);
220			break;
221			// JavaScript Variables
222			case 'js-var':
223			foreach ($fields as $f) {
224			$output .= 'var '.$f.' = '.$this->instance->$f.'; ';
225			}
226			break;
227			case 'js-modal-create':
228			foreach ($fields as $f) {
229			$output .= '"'.$f.'": $(\'#createItem'.$f.'\').val(), ';
230			}
231			break;
232			default:
233			break;
234			}
235
236			echo $output;
237			}
238
239			public function trimmedModel()
240			{
241			return strpos($this->model, ' ') !== false ? implode('', explode(' ', $this->model)) : $this->model;
242			}
243
244			public function getRelatedOptions($relation)
245			{
246			$output = '';
247
248			if (!method_exists($relation, 'toOptions')) {
249			$relationItems = $relation::all();
250			foreach ($relationItems as $item) {
251			if (isset($item->name)) {
252			$output .= '<option value="'.$item->id.'">'.$item->name.'</option>';
253			}
254			}
255			} else {
256			$output .= $relation->toOptions();
257			}
258
259			return $output;
260			}
261
262			public function getRelatedModel($f)
263			{
264			$field = $this->getRelatedField($f);
			0 ignored issues – show Documentation Bug introduced 2016-11-17 13:52 UTC by Report Bug Copy Issue Report Show Similar Issues like this The method `getRelatedField` does not exist on `object<Taskforcedev\CrudApi\Helpers\CrudApi>`? Since you implemented `__call`, maybe consider adding a @method annotation. If you implement `__call` and you know which methods are available, you can improve IDE auto-completion and static analysis by adding a @method annotation to the class. This is often the case, when `__call` is implemented by a parent class and only the child class knows which methods exist: class ParentClass { private $data = array(); public function __call($method, array $args) { if (0 === strpos($method, 'get')) { return $this->data[strtolower(substr($method, 3))]; } throw new \LogicException(sprintf('Unsupported method: %s', $method)); } } /** * If this class knows which fields exist, you can specify the methods here: * * @method string getName() */ class SomeClass extends ParentClass { } Loading history...
265			$model = $this->getModel($field);
			0 ignored issues – show Bug introduced 2016-11-17 13:05 UTC by Report Bug Copy Issue Report Show Similar Issues like this The method `getModel()` does not exist on `Taskforcedev\CrudApi\Helpers\CrudApi`. Did you maybe mean `getModelDisplayName()`? This check marks calls to methods that do not seem to exist on an object. This is most likely the result of a method being renamed without all references to it being renamed likewise. Loading history...
266
267			$modelAliases = [
268			'author' => 'user',
269			];
270
271			// If class doesn't exist, check if is in aliases array.
272			if (!class_exists($model)) {
273			if (array_key_exists($field, $modelAliases)) {
274			$aliasedModel = $modelAliases[$field];
275			$model = $this->getModel($aliasedModel);
			0 ignored issues – show Bug introduced 2016-12-29 22:01 UTC by Report Bug Copy Issue Report Show Similar Issues like this The method `getModel()` does not exist on `Taskforcedev\CrudApi\Helpers\CrudApi`. Did you maybe mean `getModelDisplayName()`? This check marks calls to methods that do not seem to exist on an object. This is most likely the result of a method being renamed without all references to it being renamed likewise. Loading history...
276			}
277			}
278
279			// Model could not be found, try via it's converted name.
280			if (!class_exists($model)) {
281			// Convert from DB format to Pascal
282			$words = explode('_', $field);
283			foreach ($words as $i => $w) {
284			$words[$i] = ucfirst($w);
285			}
286			$formatted = implode('', $words);
287			$model = 'App\\'.$formatted;
288			if (!class_exists($model)) {
289			return false;
290			}
291			}
292
293			return new $model();
294			}
295
296			public function getRelatedDisplay($f)
297			{
298			$related_field = $this->getRelatedField($f);
			0 ignored issues – show Documentation Bug introduced 2016-11-17 13:52 UTC by Report Bug Copy Issue Report Show Similar Issues like this The method `getRelatedField` does not exist on `object<Taskforcedev\CrudApi\Helpers\CrudApi>`? Since you implemented `__call`, maybe consider adding a @method annotation. If you implement `__call` and you know which methods are available, you can improve IDE auto-completion and static analysis by adding a @method annotation to the class. This is often the case, when `__call` is implemented by a parent class and only the child class knows which methods exist: class ParentClass { private $data = array(); public function __call($method, array $args) { if (0 === strpos($method, 'get')) { return $this->data[strtolower(substr($method, 3))]; } throw new \LogicException(sprintf('Unsupported method: %s', $method)); } } /** * If this class knows which fields exist, you can specify the methods here: * * @method string getName() */ class SomeClass extends ParentClass { } Loading history...
299
300			$field = $this->instance->$related_field;
301
302			$class = get_class($field);
303
304			switch ($class) {
305			case 'App\\Helpers\\CrudApi':
306			break;
307			case 'App\\Indicator':
308			return $field->indicator;
309			break;
			0 ignored issues – show Unused Code introduced 2017-03-20 13:49 UTC by Report Bug Copy Issue Report Show Similar Issues like this `break` is not strictly necessary here and could be removed. The `break` statement is not necessary if it is preceded for example by a `return` statement: switch ($x) { case 1: return 'foo'; break; // This break is not necessary and can be left off. } If you would like to keep this construct to be consistent with other `case` statements, you can safely mark this issue as a false-positive. Loading history...
310			case 'Taskforcedev\\CrudApi\\Helpers\\CrudApi':
311			return false;
312			default:
313			return $field->name;
314			}
315			}
316
317			/**
318			* Allow certain methods to be passed through to the specified
319			* helper in order to make methods easier to remember.
320			*
321			* @param $method
322			* @param $args
323			*
324			* @method string getRelatedField
325			* @method string getPrimaryField
326			* @method bool isIdField
327			* @method mixed getModel
328			*
329			* @return bool
330			*/
331			public function __call($method, $args)
332			{
333			switch ($method) {
334			case 'getRelatedField':
335			return $this->fieldHelper->getRelatedField($args[0]);
			0 ignored issues – show Bug Best Practice introduced 2016-12-29 19:07 UTC by Report Bug Copy Issue Report Show Similar Issues like this The return type of `return $this->fieldHelpe...RelatedField($args[0]);` (`string`) is incompatible with the return type documented by `Taskforcedev\CrudApi\Helpers\CrudApi::__call` of type `boolean`. If you return a value from a function or method, it should be a sub-type of the type that is given by the parent type f.e. an interface, or abstract method. This is more formally defined by the Lizkov substitution principle, and guarantees that classes that depend on the parent type can use any instance of a child type interchangably. This principle also belongs to the SOLID principles for object oriented design. Let’s take a look at an example: class Author { private $name; public function __construct($name) { $this->name = $name; } public function getName() { return $this->name; } } abstract class Post { public function getAuthor() { return 'Johannes'; } } class BlogPost extends Post { public function getAuthor() { return new Author('Johannes'); } } class ForumPost extends Post { /* ... */ } function my_function(Post $post) { echo strtoupper($post->getAuthor()); } Our function `my_function` expects a `Post` object, and outputs the author of the post. The base class `Post` returns a simple string and outputting a simple string will work just fine. However, the child class `BlogPost` which is a sub-type of `Post` instead decided to return an `object`, and is therefore violating the SOLID principles. If a `BlogPost` were passed to `my_function`, PHP would not complain, but ultimately fail when executing the `strtoupper` call in its body. Loading history...
336			case 'getPrimaryField':
337			return $this->fieldHelper->getPrimaryField($args[0]);
			0 ignored issues – show Bug Best Practice introduced 2016-12-29 19:07 UTC by Report Bug Copy Issue Report Show Similar Issues like this The return type of `return $this->fieldHelpe...PrimaryField($args[0]);` (`string`) is incompatible with the return type documented by `Taskforcedev\CrudApi\Helpers\CrudApi::__call` of type `boolean`. If you return a value from a function or method, it should be a sub-type of the type that is given by the parent type f.e. an interface, or abstract method. This is more formally defined by the Lizkov substitution principle, and guarantees that classes that depend on the parent type can use any instance of a child type interchangably. This principle also belongs to the SOLID principles for object oriented design. Let’s take a look at an example: class Author { private $name; public function __construct($name) { $this->name = $name; } public function getName() { return $this->name; } } abstract class Post { public function getAuthor() { return 'Johannes'; } } class BlogPost extends Post { public function getAuthor() { return new Author('Johannes'); } } class ForumPost extends Post { /* ... */ } function my_function(Post $post) { echo strtoupper($post->getAuthor()); } Our function `my_function` expects a `Post` object, and outputs the author of the post. The base class `Post` returns a simple string and outputting a simple string will work just fine. However, the child class `BlogPost` which is a sub-type of `Post` instead decided to return an `object`, and is therefore violating the SOLID principles. If a `BlogPost` were passed to `my_function`, PHP would not complain, but ultimately fail when executing the `strtoupper` call in its body. Loading history...
338			case 'isIdField':
339			return $this->fieldHelper->isIdField($args[0]);
340			case 'getModel':
341			if (isset($args[0])) {
342			return $this->modelHelper->getModel($args[0]);
343			}
344			return $this->modelHelper->getModel();
345			default:
346			break;
347			}
348			}
349			}
350

taskforcedev / crud-api

Issues (32)

Security Analysis not enabled

src/Helpers/CrudApi.php (9 issues)

Labels

Severity

Introduced By

Upgrade to new PHP Analysis Engine

Duplication Side-by-Side

Filter issues like