HashIdTrait::decodeArray() - Code Metrics - Porto-SAP/Hello-API - Measure and Improve Code Quality continuously with Scrutinizer

HashIdTrait::decodeArray() A
last analyzed 2017-03-23 00:40 UTC

↳ Parent: HashIdTrait

Complexity

Conditions	2
Paths	2

Size

Total Lines	9
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
c	0
b	0
f	0
dl	0
loc	9
rs	9.6666
cc	2
eloc	5
nc	2
nop	1

<?php

namespace App\Ship\Engine\Traits;

use App\Ship\Features\Exceptions\IncorrectIdException;
use Illuminate\Support\Facades\Config;
use Route;
use Vinkla\Hashids\Facades\Hashids;

/**
 * Class HashIdTrait.
 *
 * @author  Mahmoud Zalt <[email protected]>
 */
trait HashIdTrait
{

    /**
     * endpoint to be skipped from decoding their ID's (example for external ID's)
     * @var  array
     */
    private $skippedEndpoints = [
//        'orders/{id}/external',
    ];

    /**
     * Will be used by the Eloquent Models (since it's used as trait there).
     *
     * @param null $key
     *
     * @return  mixed
     */
    public function getHashedKey($key = null)
    {
        // hash the ID only if hash-id enabled in the config
        if (Config::get('hello.hash-id')) {
            return $this->encoder(($key) ? : $this->getKey());
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
        }

        return $this->getKey();
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
    }

    /**
     * without decoding the encoded ID's you won't be able to use
     * validation features like `exists:table,id`
     *
     * @param array $requestData
     *
     * @return  array
     */
    protected function decodeHashedIdsBeforeValidation(Array $requestData)
    {
        // the hash ID feature must be enabled to use this decoder feature.
        if (Config::get('hello.hash-id') && isset($this->decode) && !empty($this->decode)) {
            // iterate over each key (ID that needs to be decoded) and call keys locator to decode them
            foreach ($this->decode as $key) {
class MyClass { }

$x = new MyClass();
$x->foo = true;
                $requestData = $this->locateAndDecodeIds($requestData, $key);
            }
        }

        return $requestData;
    }

    /**
     * Expected Keys formats:
     *
     * Type 1:
     *   A
     * Type 2:
     *   A.*.B
     *   A.*.B.*.C
     * Type 3:
     *   A.*
     *   A.*.B.*
     *
     * @param $requestData
     * @param $key
     *
     * @return  mixed
     */
    private function locateAndDecodeIds($requestData, $key)
    {
        if ($this->stringEndsWithChars('.*', $key)) {
            // if the key of Type 3:
            $this->decodeType3Key($requestData, $key);
        } elseif (str_contains($key, '.*.')) {
            // if the key of Type 2:
            $this->decodeType2Key($requestData, $key);
        } else {
            // if the key of Type 1:
            $this->decodeType1Key($requestData, $key);
        }

        return $requestData;
    }

    /**
     * @param $requestData
     * @param $key
     */
    private function decodeType1Key(&$requestData, $key)
    {
        // decode single key
        if (isset($requestData[$key])) {
            $requestData[$key] = $this->decode($requestData[$key], $key);
        }
    }

    /**
     * @param $requestData
     * @param $key
     */
    private function decodeType2Key(&$requestData, $key)
    {
        // get the last part of the key, which should be the ID that needs decoding
        $idToDecode = substr($key, strrpos($key, '.*.') + 3);

        array_walk_recursive($requestData, function (&$value, $key) use ($idToDecode) {

            if ($key == $idToDecode) {
                $value = $this->decode($value, $key);
            }

        });
    }

    /**
     * @param $requestData
     * @param $key
     */
    private function decodeType3Key(&$requestData, $key)
    {
        $idToDecode = $this->removeLastOccurrenceFromString($key, '.*');

        $this->findKeyAndReturnValue($requestData, $idToDecode, function ($ids) use ($key) {

            if (!is_array($ids)) {
                throw new IncorrectIdException('Expected ID\'s to be in array. Please wrap your ID\'s in an Array and send them back.');
            }

            $decodedIds = [];

            foreach ($ids as $id) {
                $decodedIds[] = $this->decode($id, $key);
            }

            // callback return
            return $decodedIds;
        });
    }

    /**
     * @param $subject
     * @param $findKey
     * @param $callback
     *
     * @return  array
     */
    public function findKeyAndReturnValue(&$subject, $findKey, $callback)
    {
        // if the value is not an array, then you have reached the deepest point of the branch, so return the value.
        if (!is_array($subject)) {
            return $subject;
        }

        foreach ($subject as $key => $value) {

            if ($key == $findKey && isset($subject[$findKey])) {
                $subject[$key] = $callback($subject[$findKey]);
                break;
            }

            // add the value with the recursive call
            $this->findKeyAndReturnValue($value, $findKey, $callback);
        }
    }

    /**
     * @param $search
     * @param $subject
     *
     * @return  mixed
     */
    private function removeLastOccurrenceFromString($subject, $search)
    {
        $replace = '';

        $pos = strrpos($subject, $search);

        if ($pos !== false) {
            $subject = substr_replace($subject, $replace, $pos, strlen($search));
        }

        return $subject;
    }

    /**
     * @param $needle
     * @param $haystack
     *
     * @return  int
     */
    private function stringEndsWithChars($needle, $haystack)
    {
        return preg_match('/' . preg_quote($needle, '/') . '$/', $haystack);
    }

    /**
     * @param array $ids
     *
     * @return  array
     */
    public function decodeArray(array $ids)
    {
        $result = [];
        foreach ($ids as $id) {
            $result[] = $this->decode($id);
        }

        return $result;
    }

    /**
     * @param      $id
     * @param null $parameter
     *
     * @return  array
     */
    public function decode($id, $parameter = null)
    {
        if (is_numeric($id)) {
            throw new IncorrectIdException('Only Hashed ID\'s allowed' . (!is_null($parameter) ? " ($parameter)." : '.'));
        }

        return empty($this->decoder($id)) ? [] : $this->decoder($id)[0];
    }

    /**
     * @param $id
     *
     * @return  mixed
     */
    public function encode($id)
    {
        return $this->encoder($id);
    }

    /**
     * @param $id
     *
     * @return  mixed
     */
    private function decoder($id)
    {
        return Hashids::decode($id);
    }

    /**
     * @param $id
     *
     * @return  mixed
     */
    public function encoder($id)
    {
        return Hashids::encode($id);
    }

    /**
     * Automatically decode any found `id` in the URL, no need to be used anymore.
     * Since now the user will define what needs to be decoded in the request.
     *
     * All ID's passed with all endpoints will be decoded before entering the Application
     */
    public function runHashedIdsDecoder()
    {
        if (Config::get('hello.hash-id')) {
            Route::bind('id', function ($id, $route) {
                // skip decoding some endpoints
                if (!in_array($route->uri(), $this->skippedEndpoints)) {

                    // decode the ID in the URL
                    $decoded = $this->decoder($id);

                    if (empty($decoded)) {
                        throw new IncorrectIdException('ID (' . $id . ') is incorrect, consider using the hashed ID
                        instead of the numeric ID.');
                    }

                    return $decoded[0];
                }
            });
        }
    }

}


1			<?php
2
3			namespace App\Ship\Engine\Traits;
4
5			use App\Ship\Features\Exceptions\IncorrectIdException;
6			use Illuminate\Support\Facades\Config;
7			use Route;
8			use Vinkla\Hashids\Facades\Hashids;
9
10			/**
11			* Class HashIdTrait.
12			*
13			* @author Mahmoud Zalt <[email protected]>
14			*/
15			trait HashIdTrait
16			{
17
18			/**
19			* endpoint to be skipped from decoding their ID's (example for external ID's)
20			* @var array
21			*/
22			private $skippedEndpoints = [
23			// 'orders/{id}/external',
24			];
25
26			/**
27			* Will be used by the Eloquent Models (since it's used as trait there).
28			*
29			* @param null $key
30			*
31			* @return mixed
32			*/
33			public function getHashedKey($key = null)
34			{
35			// hash the ID only if hash-id enabled in the config
36			if (Config::get('hello.hash-id')) {
37			return $this->encoder(($key) ? : $this->getKey());
			0 ignored issues – show Bug introduced 2016-12-01 19:55 UTC by Report Bug Copy Issue Report It seems like `getKey()` 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...
38			}
39
40			return $this->getKey();
			0 ignored issues – show Bug introduced 2016-12-01 19:55 UTC by Report Bug Copy Issue Report It seems like `getKey()` 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...
41			}
42
43			/**
44			* without decoding the encoded ID's you won't be able to use
45			* validation features like `exists:table,id`
46			*
47			* @param array $requestData
48			*
49			* @return array
50			*/
51			protected function decodeHashedIdsBeforeValidation(Array $requestData)
52			{
53			// the hash ID feature must be enabled to use this decoder feature.
54			if (Config::get('hello.hash-id') && isset($this->decode) && !empty($this->decode)) {
55			// iterate over each key (ID that needs to be decoded) and call keys locator to decode them
56			foreach ($this->decode as $key) {
			0 ignored issues – show Bug introduced 2017-02-09 23:45 UTC by Report Bug Copy Issue Report The property `decode` 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...
57			$requestData = $this->locateAndDecodeIds($requestData, $key);
58			}
59			}
60
61			return $requestData;
62			}
63
64			/**
65			* Expected Keys formats:
66			*
67			* Type 1:
68			* A
69			* Type 2:
70			* A.*.B
71			* A..B..C
72			* Type 3:
73			* A.*
74			* A..B.
75			*
76			* @param $requestData
77			* @param $key
78			*
79			* @return mixed
80			*/
81			private function locateAndDecodeIds($requestData, $key)
82			{
83			if ($this->stringEndsWithChars('.*', $key)) {
84			// if the key of Type 3:
85			$this->decodeType3Key($requestData, $key);
86			} elseif (str_contains($key, '.*.')) {
87			// if the key of Type 2:
88			$this->decodeType2Key($requestData, $key);
89			} else {
90			// if the key of Type 1:
91			$this->decodeType1Key($requestData, $key);
92			}
93
94			return $requestData;
95			}
96
97			/**
98			* @param $requestData
99			* @param $key
100			*/
101			private function decodeType1Key(&$requestData, $key)
102			{
103			// decode single key
104			if (isset($requestData[$key])) {
105			$requestData[$key] = $this->decode($requestData[$key], $key);
106			}
107			}
108
109			/**
110			* @param $requestData
111			* @param $key
112			*/
113			private function decodeType2Key(&$requestData, $key)
114			{
115			// get the last part of the key, which should be the ID that needs decoding
116			$idToDecode = substr($key, strrpos($key, '.*.') + 3);
117
118			array_walk_recursive($requestData, function (&$value, $key) use ($idToDecode) {
119
120			if ($key == $idToDecode) {
121			$value = $this->decode($value, $key);
122			}
123
124			});
125			}
126
127			/**
128			* @param $requestData
129			* @param $key
130			*/
131			private function decodeType3Key(&$requestData, $key)
132			{
133			$idToDecode = $this->removeLastOccurrenceFromString($key, '.*');
134
135			$this->findKeyAndReturnValue($requestData, $idToDecode, function ($ids) use ($key) {
136
137			if (!is_array($ids)) {
138			throw new IncorrectIdException('Expected ID\'s to be in array. Please wrap your ID\'s in an Array and send them back.');
139			}
140
141			$decodedIds = [];
142
143			foreach ($ids as $id) {
144			$decodedIds[] = $this->decode($id, $key);
145			}
146
147			// callback return
148			return $decodedIds;
149			});
150			}
151
152			/**
153			* @param $subject
154			* @param $findKey
155			* @param $callback
156			*
157			* @return array
158			*/
159			public function findKeyAndReturnValue(&$subject, $findKey, $callback)
160			{
161			// if the value is not an array, then you have reached the deepest point of the branch, so return the value.
162			if (!is_array($subject)) {
163			return $subject;
164			}
165
166			foreach ($subject as $key => $value) {
167
168			if ($key == $findKey && isset($subject[$findKey])) {
169			$subject[$key] = $callback($subject[$findKey]);
170			break;
171			}
172
173			// add the value with the recursive call
174			$this->findKeyAndReturnValue($value, $findKey, $callback);
175			}
176			}
177
178			/**
179			* @param $search
180			* @param $subject
181			*
182			* @return mixed
183			*/
184			private function removeLastOccurrenceFromString($subject, $search)
185			{
186			$replace = '';
187
188			$pos = strrpos($subject, $search);
189
190			if ($pos !== false) {
191			$subject = substr_replace($subject, $replace, $pos, strlen($search));
192			}
193
194			return $subject;
195			}
196
197			/**
198			* @param $needle
199			* @param $haystack
200			*
201			* @return int
202			*/
203			private function stringEndsWithChars($needle, $haystack)
204			{
205			return preg_match('/' . preg_quote($needle, '/') . '$/', $haystack);
206			}
207
208			/**
209			* @param array $ids
210			*
211			* @return array
212			*/
213			public function decodeArray(array $ids)
214			{
215			$result = [];
216			foreach ($ids as $id) {
217			$result[] = $this->decode($id);
218			}
219
220			return $result;
221			}
222
223			/**
224			* @param $id
225			* @param null $parameter
226			*
227			* @return array
228			*/
229			public function decode($id, $parameter = null)
230			{
231			if (is_numeric($id)) {
232			throw new IncorrectIdException('Only Hashed ID\'s allowed' . (!is_null($parameter) ? " ($parameter)." : '.'));
233			}
234
235			return empty($this->decoder($id)) ? [] : $this->decoder($id)[0];
236			}
237
238			/**
239			* @param $id
240			*
241			* @return mixed
242			*/
243			public function encode($id)
244			{
245			return $this->encoder($id);
246			}
247
248			/**
249			* @param $id
250			*
251			* @return mixed
252			*/
253			private function decoder($id)
254			{
255			return Hashids::decode($id);
256			}
257
258			/**
259			* @param $id
260			*
261			* @return mixed
262			*/
263			public function encoder($id)
264			{
265			return Hashids::encode($id);
266			}
267
268			/**
269			* Automatically decode any found `id` in the URL, no need to be used anymore.
270			* Since now the user will define what needs to be decoded in the request.
271			*
272			* All ID's passed with all endpoints will be decoded before entering the Application
273			*/
274			public function runHashedIdsDecoder()
275			{
276			if (Config::get('hello.hash-id')) {
277			Route::bind('id', function ($id, $route) {
278			// skip decoding some endpoints
279			if (!in_array($route->uri(), $this->skippedEndpoints)) {
280
281			// decode the ID in the URL
282			$decoded = $this->decoder($id);
283
284			if (empty($decoded)) {
285			throw new IncorrectIdException('ID (' . $id . ') is incorrect, consider using the hashed ID
286			instead of the numeric ID.');
287			}
288
289			return $decoded[0];
290			}
291			});
292			}
293			}
294
295			}
296

Porto-SAP / Hello-API

HashIdTrait::decodeArray() A last analyzed 2017-03-23 00:40 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

HashIdTrait::decodeArray() A
last analyzed 2017-03-23 00:40 UTC