Issues in HasUrl.php (master) - Issues in master - Neurony/laravel-url - Measure and Improve Code Quality continuously with Scrutinizer

Issues (27)

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/Traits/HasUrl.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 Neurony\Url\Traits;

use Exception;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\MorphOne;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Str;
use Neurony\Url\Exceptions\UrlException;
use Neurony\Url\Models\Url;
use Neurony\Url\Options\SlugOptions;
use Neurony\Url\Options\UrlOptions;

trait HasUrl
{
    use HasSlug;

    /**
     * The container for all the options necessary for this trait.
     * Options can be viewed in the Neurony\Url\Options\UrlOptions file.
     *
     * @var UrlOptions
     */
    protected $urlOptions;

    /**
     * Flag to manually enable/disable the url generation only for the current request.
     *
     * @var bool
     */
    protected static $generateUrl = true;

    /**
     * Set the options for the HasUrl trait.
     *
     * @return UrlOptions
     */
    abstract public function getUrlOptions(): UrlOptions;

    /**
     * Boot the trait.
     *
     * Check if the "getUrlOptions" method has been implemented on the underlying model class.
     * Eager load urls through anonymous global scope.
     * Trigger eloquent events to create, update, delete url.
     *
     * @return void
     */
    public static function bootHasUrl(): void
    {
        static::addGlobalScope('url', function (Builder $builder) {
            $builder->with('url');
        });

        static::created(function (Model $model) {
            if (self::$generateUrl === true) {
                $model->createUrl();
            }
        });

        static::updated(function (Model $model) {
            if (self::$generateUrl === true) {
                $model->updateUrl();
            }
        });

        static::saved(function (Model $model) {

            if (self::$generateUrl === false) {
                self::$generateUrl = true;
            }
        });

        static::deleted(function (Model $model) {
            if ($model->forceDeleting !== false) {
                $model->deleteUrl();
            }
        });
    }

    /**
     * Get the model's url.
     *
     * @return MorphOne
     */
    public function url(): MorphOne
    {
        return $this->morphOne(Url::class, 'urlable');
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
    }

    /**
     * Get the model's direct url string.
     *
     * @param bool|null $secure
     * @return \Illuminate\Contracts\Routing\UrlGenerator|string|null
     */
    public function getUrl(?bool $secure = null): ?string
    {
        if ($this->url && $this->url->exists) {
            return url($this->url->url, [], $secure);
class MyClass { }

$x = new MyClass();
$x->foo = true;
        }

        return null;
    }

    /**
     * Get the model's direct uri string.
     *
     * @return string|null
     */
    public function getUri(): ?string
    {
        return optional($this->url)->url ?: null;
    }

    /**
     * Disable the url generation manually only for the current request.
     *
     * @return static
     */
    public function doNotGenerateUrl(): self
    {
        self::$generateUrl = false;

        return $this;
    }

    /**
     * Get the options for the HasSlug trait.
     *
     * @return SlugOptions
     * @throws Exception
     */
    public function getSlugOptions(): SlugOptions
    {
        $this->initUrlOptions();

        return SlugOptions::instance()
            ->generateSlugFrom($this->urlOptions->fromField)
            ->saveSlugTo($this->urlOptions->toField);
    }

    /**
     * @return void
     * @throws Exception
     */
    public function saveUrl(): void
    {
        $this->initUrlOptions();

        if ($this->url && $this->url->exists) {
            $this->updateUrl();
        } else {
            $this->createUrl();
        }
    }

    /**
     * Create a new url for the model.
     *
     * @return void
     * @throws Exception
     */
    public function createUrl(): void
    {
        $this->initUrlOptions();

        if (! $this->getAttribute($this->urlOptions->toField)) {
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            return;
        }

        try {
            $this->url()->create([
                'url' => $this->buildFullUrl(),
            ]);
        } catch (Exception $e) {
            throw UrlException::createFailed();
        }
    }

    /**
     * Update the existing url for the model.
     *
     * @return void
     * @throws Exception
     */
    public function updateUrl(): void
    {
        $this->initUrlOptions();

        if (! $this->getAttribute($this->urlOptions->toField)) {
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            return;
        }

        try {
            DB::transaction(function () {
                if ($this->url()->count() == 0) {
                    $this->createUrl();
                }

                $this->url()->update([

                    'url' => $this->buildFullUrl(),
                ]);

                if ($this->urlOptions->cascadeUpdate === true) {
                    $this->updateUrlsInCascade();
                }
            });
        } catch (Exception $e) {
            throw UrlException::updateFailed();
        }
    }

    /**
     * Delete the url for the just deleted model.
     *
     * @return void
     * @throws UrlException
     */
    public function deleteUrl(): void
    {
        try {
            $this->url()->delete();
        } catch (Exception $e) {
            throw UrlException::deleteFailed();
        }
    }

    /**
     * Synchronize children urls for the actual model's url.
     * Saves all children urls of the model in use with the new parent model's slug.
     *
     * @return void
     */
    protected function updateUrlsInCascade(): void
    {
        $old = trim($this->getOriginal($this->urlOptions->toField), '/');
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
        $new = trim($this->getAttribute($this->urlOptions->toField), '/');
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}

        $children = URL::where('urlable_type', static::class)->where(function ($query) use ($old) {
            $query->where('url', 'like', "{$old}/%")->orWhere('url', 'like', "%/{$old}/%");
        })->get();

        foreach ($children as $child) {
            $child->update([
                'url' => str_replace($old.'/', $new.'/', $child->url),
            ]);
        }
    }

    /**
     * Get the full relative url.
     * The full url will also include the prefix and suffix if any was provided.
     *
     * @return string
     */
    protected function buildFullUrl(): string
    {
        $prefix = $this->buildUrlSegment('prefix');
        $suffix = $this->buildUrlSegment('suffix');

        return
            (Str::is('/', $prefix) ? '' : ($prefix ? $prefix.$this->urlOptions->urlGlue : '')).
            $this->getAttribute($this->urlOptions->toField).
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            (Str::is('/', $suffix) ? '' : ($suffix ? $this->urlOptions->urlGlue.$suffix : ''));
    }

    /**
     * Build the url segment.
     * This can be either "prefix" or "suffix".
     * The accepted parameter $type accepts only "prefix" and "suffix" as it's value.
     * Otherwise, the method will return an empty string.
     *
     * @param string $type
     * @return string
     */
    protected function buildUrlSegment(string $type): string
    {
        if ($type != 'prefix' && $type != 'suffix') {
            return '';
        }

        $segment = $this->urlOptions->{'url'.ucwords($type)};

        if (is_callable($segment)) {
            return call_user_func_array($segment, [[], $this]);
        } elseif (is_array($segment)) {
            return implode($this->urlOptions->urlGlue, $segment);
        } elseif (is_string($segment)) {
            return $segment;
        } else {
            return '';
        }
    }

    /**
     * Both instantiate the url options as well as validate their contents.
     *
     * @return void
     * @throws Exception
     */
    protected function initUrlOptions(): void
    {
        if ($this->urlOptions === null) {
            $this->urlOptions = $this->getUrlOptions();
        }

        $this->validateUrlOptions();
    }

    /**
     * Check if mandatory slug options have been properly set from the model.
     * Check if $fromField and $toField have been set.
     *
     * @return void
     * @throws UrlException
     */
    protected function validateUrlOptions(): void
    {
        if (! $this->urlOptions->routeController || ! $this->urlOptions->routeAction) {
            throw UrlException::mandatoryRouting(static::class);
        }

        if (! $this->urlOptions->fromField) {
            throw UrlException::mandatoryFromField(static::class);
        }

        if (! $this->urlOptions->toField) {
            throw UrlException::mandatoryToField(static::class);
        }
    }
}


1			<?php
2
3			namespace Neurony\Url\Traits;
4
5			use Exception;
6			use Illuminate\Database\Eloquent\Builder;
7			use Illuminate\Database\Eloquent\Model;
8			use Illuminate\Database\Eloquent\Relations\MorphOne;
9			use Illuminate\Support\Facades\DB;
10			use Illuminate\Support\Str;
11			use Neurony\Url\Exceptions\UrlException;
12			use Neurony\Url\Models\Url;
13			use Neurony\Url\Options\SlugOptions;
14			use Neurony\Url\Options\UrlOptions;
15
16			trait HasUrl
17			{
18			use HasSlug;
19
20			/**
21			* The container for all the options necessary for this trait.
22			* Options can be viewed in the Neurony\Url\Options\UrlOptions file.
23			*
24			* @var UrlOptions
25			*/
26			protected $urlOptions;
27
28			/**
29			* Flag to manually enable/disable the url generation only for the current request.
30			*
31			* @var bool
32			*/
33			protected static $generateUrl = true;
34
35			/**
36			* Set the options for the HasUrl trait.
37			*
38			* @return UrlOptions
39			*/
40			abstract public function getUrlOptions(): UrlOptions;
41
42			/**
43			* Boot the trait.
44			*
45			* Check if the "getUrlOptions" method has been implemented on the underlying model class.
46			* Eager load urls through anonymous global scope.
47			* Trigger eloquent events to create, update, delete url.
48			*
49			* @return void
50			*/
51			public static function bootHasUrl(): void
52			{
53			static::addGlobalScope('url', function (Builder $builder) {
54			$builder->with('url');
55			});
56
57			static::created(function (Model $model) {
58			if (self::$generateUrl === true) {
59			$model->createUrl();
60			}
61			});
62
63			static::updated(function (Model $model) {
64			if (self::$generateUrl === true) {
65			$model->updateUrl();
66			}
67			});
68
69			static::saved(function (Model $model) {
			0 ignored issues – show Unused Code introduced 2019-03-22 09:39 UTC by Report Bug Copy Issue Report Show Similar Issues like this The parameter `$model` 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...
70			if (self::$generateUrl === false) {
71			self::$generateUrl = true;
72			}
73			});
74
75			static::deleted(function (Model $model) {
76			if ($model->forceDeleting !== false) {
77			$model->deleteUrl();
78			}
79			});
80			}
81
82			/**
83			* Get the model's url.
84			*
85			* @return MorphOne
86			*/
87			public function url(): MorphOne
88			{
89			return $this->morphOne(Url::class, 'urlable');
			0 ignored issues – show Bug introduced 2019-03-22 09:39 UTC by Report Bug Copy Issue Report Show Similar Issues like this It seems like `morphOne()` must be provided by classes using this trait. How about adding it as abstract method to this trait? This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable { public function equalIds(Idable $other) { return $this->getId() === $other->getId(); } } The trait `Idable` provides a method `equalsId` that in turn relies on the method `getId()`. If this method does not exist on a class mixing in this trait, the method will fail. Adding the `getId()` as an abstract method to the trait will make sure it is available. Loading history...
90			}
91
92			/**
93			* Get the model's direct url string.
94			*
95			* @param bool\|null $secure
96			* @return \Illuminate\Contracts\Routing\UrlGenerator\|string\|null
97			*/
98			public function getUrl(?bool $secure = null): ?string
99			{
100			if ($this->url && $this->url->exists) {
101			return url($this->url->url, [], $secure);
			0 ignored issues – show Bug introduced 2019-03-22 09:39 UTC by Report Bug Copy Issue Report Show Similar Issues like this The property `url` does not exist. Did you maybe forget to declare it? In PHP it is possible to write to properties without declaring them. For example, the following is perfectly valid PHP code: class MyClass { } $x = new MyClass(); $x->foo = true; Generally, it is a good practice to explictly declare properties to avoid accidental typos and provide IDE auto-completion: class MyClass { public $foo; } $x = new MyClass(); $x->foo = true; Loading history...
102			}
103
104			return null;
105			}
106
107			/**
108			* Get the model's direct uri string.
109			*
110			* @return string\|null
111			*/
112			public function getUri(): ?string
113			{
114			return optional($this->url)->url ?: null;
115			}
116
117			/**
118			* Disable the url generation manually only for the current request.
119			*
120			* @return static
121			*/
122			public function doNotGenerateUrl(): self
123			{
124			self::$generateUrl = false;
125
126			return $this;
127			}
128
129			/**
130			* Get the options for the HasSlug trait.
131			*
132			* @return SlugOptions
133			* @throws Exception
134			*/
135			public function getSlugOptions(): SlugOptions
136			{
137			$this->initUrlOptions();
138
139			return SlugOptions::instance()
140			->generateSlugFrom($this->urlOptions->fromField)
141			->saveSlugTo($this->urlOptions->toField);
142			}
143
144			/**
145			* @return void
146			* @throws Exception
147			*/
148			public function saveUrl(): void
149			{
150			$this->initUrlOptions();
151
152			if ($this->url && $this->url->exists) {
153			$this->updateUrl();
154			} else {
155			$this->createUrl();
156			}
157			}
158
159			/**
160			* Create a new url for the model.
161			*
162			* @return void
163			* @throws Exception
164			*/
165			public function createUrl(): void
166			{
167			$this->initUrlOptions();
168
169			if (! $this->getAttribute($this->urlOptions->toField)) {
			0 ignored issues – show Bug introduced 2019-03-22 09:39 UTC by Report Bug Copy Issue Report Show Similar Issues like this It seems like `getAttribute()` must be provided by classes using this trait. How about adding it as abstract method to this trait? This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable { public function equalIds(Idable $other) { return $this->getId() === $other->getId(); } } The trait `Idable` provides a method `equalsId` that in turn relies on the method `getId()`. If this method does not exist on a class mixing in this trait, the method will fail. Adding the `getId()` as an abstract method to the trait will make sure it is available. Loading history...
170			return;
171			}
172
173			try {
174			$this->url()->create([
175			'url' => $this->buildFullUrl(),
176			]);
177			} catch (Exception $e) {
178			throw UrlException::createFailed();
179			}
180			}
181
182			/**
183			* Update the existing url for the model.
184			*
185			* @return void
186			* @throws Exception
187			*/
188			public function updateUrl(): void
189			{
190			$this->initUrlOptions();
191
192			if (! $this->getAttribute($this->urlOptions->toField)) {
			0 ignored issues – show Bug introduced 2019-03-22 09:39 UTC by Report Bug Copy Issue Report Show Similar Issues like this It seems like `getAttribute()` must be provided by classes using this trait. How about adding it as abstract method to this trait? This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable { public function equalIds(Idable $other) { return $this->getId() === $other->getId(); } } The trait `Idable` provides a method `equalsId` that in turn relies on the method `getId()`. If this method does not exist on a class mixing in this trait, the method will fail. Adding the `getId()` as an abstract method to the trait will make sure it is available. Loading history...
193			return;
194			}
195
196			try {
197			DB::transaction(function () {
198			if ($this->url()->count() == 0) {
199			$this->createUrl();
200			}
201
202			$this->url()->update([
			0 ignored issues – show Bug introduced 2019-03-22 09:39 UTC by Report Bug Copy Issue Report Show Similar Issues like this The method `update()` does not exist on `Illuminate\Database\Eloquent\Relations\MorphOne`. Did you maybe mean `rawUpdate()`? 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...
203			'url' => $this->buildFullUrl(),
204			]);
205
206			if ($this->urlOptions->cascadeUpdate === true) {
207			$this->updateUrlsInCascade();
208			}
209			});
210			} catch (Exception $e) {
211			throw UrlException::updateFailed();
212			}
213			}
214
215			/**
216			* Delete the url for the just deleted model.
217			*
218			* @return void
219			* @throws UrlException
220			*/
221			public function deleteUrl(): void
222			{
223			try {
224			$this->url()->delete();
225			} catch (Exception $e) {
226			throw UrlException::deleteFailed();
227			}
228			}
229
230			/**
231			* Synchronize children urls for the actual model's url.
232			* Saves all children urls of the model in use with the new parent model's slug.
233			*
234			* @return void
235			*/
236			protected function updateUrlsInCascade(): void
237			{
238			$old = trim($this->getOriginal($this->urlOptions->toField), '/');
			0 ignored issues – show Bug introduced 2019-03-22 09:39 UTC by Report Bug Copy Issue Report Show Similar Issues like this It seems like `getOriginal()` must be provided by classes using this trait. How about adding it as abstract method to this trait? This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable { public function equalIds(Idable $other) { return $this->getId() === $other->getId(); } } The trait `Idable` provides a method `equalsId` that in turn relies on the method `getId()`. If this method does not exist on a class mixing in this trait, the method will fail. Adding the `getId()` as an abstract method to the trait will make sure it is available. Loading history...
239			$new = trim($this->getAttribute($this->urlOptions->toField), '/');
			0 ignored issues – show Bug introduced 2019-03-22 09:39 UTC by Report Bug Copy Issue Report Show Similar Issues like this It seems like `getAttribute()` must be provided by classes using this trait. How about adding it as abstract method to this trait? This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable { public function equalIds(Idable $other) { return $this->getId() === $other->getId(); } } The trait `Idable` provides a method `equalsId` that in turn relies on the method `getId()`. If this method does not exist on a class mixing in this trait, the method will fail. Adding the `getId()` as an abstract method to the trait will make sure it is available. Loading history...
240
241			$children = URL::where('urlable_type', static::class)->where(function ($query) use ($old) {
242			$query->where('url', 'like', "{$old}/%")->orWhere('url', 'like', "%/{$old}/%");
243			})->get();
244
245			foreach ($children as $child) {
246			$child->update([
247			'url' => str_replace($old.'/', $new.'/', $child->url),
248			]);
249			}
250			}
251
252			/**
253			* Get the full relative url.
254			* The full url will also include the prefix and suffix if any was provided.
255			*
256			* @return string
257			*/
258			protected function buildFullUrl(): string
259			{
260			$prefix = $this->buildUrlSegment('prefix');
261			$suffix = $this->buildUrlSegment('suffix');
262
263			return
264			(Str::is('/', $prefix) ? '' : ($prefix ? $prefix.$this->urlOptions->urlGlue : '')).
265			$this->getAttribute($this->urlOptions->toField).
			0 ignored issues – show Bug introduced 2019-03-22 09:39 UTC by Report Bug Copy Issue Report Show Similar Issues like this It seems like `getAttribute()` must be provided by classes using this trait. How about adding it as abstract method to this trait? This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable { public function equalIds(Idable $other) { return $this->getId() === $other->getId(); } } The trait `Idable` provides a method `equalsId` that in turn relies on the method `getId()`. If this method does not exist on a class mixing in this trait, the method will fail. Adding the `getId()` as an abstract method to the trait will make sure it is available. Loading history...
266			(Str::is('/', $suffix) ? '' : ($suffix ? $this->urlOptions->urlGlue.$suffix : ''));
267			}
268
269			/**
270			* Build the url segment.
271			* This can be either "prefix" or "suffix".
272			* The accepted parameter $type accepts only "prefix" and "suffix" as it's value.
273			* Otherwise, the method will return an empty string.
274			*
275			* @param string $type
276			* @return string
277			*/
278			protected function buildUrlSegment(string $type): string
279			{
280			if ($type != 'prefix' && $type != 'suffix') {
281			return '';
282			}
283
284			$segment = $this->urlOptions->{'url'.ucwords($type)};
285
286			if (is_callable($segment)) {
287			return call_user_func_array($segment, [[], $this]);
288			} elseif (is_array($segment)) {
289			return implode($this->urlOptions->urlGlue, $segment);
290			} elseif (is_string($segment)) {
291			return $segment;
292			} else {
293			return '';
294			}
295			}
296
297			/**
298			* Both instantiate the url options as well as validate their contents.
299			*
300			* @return void
301			* @throws Exception
302			*/
303			protected function initUrlOptions(): void
304			{
305			if ($this->urlOptions === null) {
306			$this->urlOptions = $this->getUrlOptions();
307			}
308
309			$this->validateUrlOptions();
310			}
311
312			/**
313			* Check if mandatory slug options have been properly set from the model.
314			* Check if $fromField and $toField have been set.
315			*
316			* @return void
317			* @throws UrlException
318			*/
319			protected function validateUrlOptions(): void
320			{
321			if (! $this->urlOptions->routeController \|\| ! $this->urlOptions->routeAction) {
322			throw UrlException::mandatoryRouting(static::class);
323			}
324
325			if (! $this->urlOptions->fromField) {
326			throw UrlException::mandatoryFromField(static::class);
327			}
328
329			if (! $this->urlOptions->toField) {
330			throw UrlException::mandatoryToField(static::class);
331			}
332			}
333			}
334

Neurony / laravel-url

Issues (27)

Security Analysis not enabled

src/Traits/HasUrl.php (9 issues)

Labels

Severity

Introduced By

Upgrade to new PHP Analysis Engine

Duplication Side-by-Side

Filter issues like