FormatMapping::lookUp() - Code Metrics - Inspection of "Mapping function rest entity" - KLYgarage/onesdk - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#21)

by kenny

created 2018-07-06 04:45 UTC

FormatMapping::lookUp() A

↳ Parent: FormatMapping

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
nc	1
nop	1
dl	0
loc	12
rs	9.8666
c	0
b	0
f	0

<?php

namespace one;

use One\Model\Article;
use one\Model\Gallery;
use One\Model\Page;
use one\Model\Photo;
use One\Model\Video;

class FormatMapping
{

    /**
     * Possible attributes of JSON data
     * @var array
     */
    private $listAttributes;

    /**
     * JSON field constants
     */
    const JSON_PHOTO_FIELD = "photos";

    const JSON_PAGE_FIELD = "pages";

    const JSON_GALLERY_FIELD = "galleries";

    const JSON_VIDEO_FIELD = "videos";

    /**
     * Construct JSON attributes
     */
    public function __construct()
    {
        $this->listAttributes = array(
            Article::ATTACHMENT_FIELD_PHOTO   => array(
                '_id', '_url', '_ratio', '_description', '_information',
            ),
            Article::ATTACHMENT_FIELD_PAGE    => array(
                '_id', '_title', '_lead', '_body', '_source', '_order', '_cover',
            ),
            Article::ATTACHMENT_FIELD_GALLERY => array(
                '_id', '_lead', '_body', '_source', '_order', '_photo',
            ),
            Article::ATTACHMENT_FIELD_VIDEO   => array(
                '_id', '_lead', '_body', '_source', '_order', '_cover',
            ),
        );
    }

    /**
     * map a single article to main attributes in Article Class
     * @param  string $singleJsonArticle JSON response
     * @return Article
     * @throws Exception
     */
    public function article($singleJsonArticle)
    {
        if (json_decode($singleJsonArticle, true)) {
            $dataArticle = json_decode($singleJsonArticle, true)['data'];

            $article = new Article(

                $this->filterString(
                    $this->getValue('title', $dataArticle)
                ),

                $this->filterString(
                    $this->getValue('body', $dataArticle)
                ),

                $this->filterString(
                    $this->getValue('source', $dataArticle)
                ),

                $this->getValue('unique_id', $dataArticle),

                $this->filterInteger(
                    $this->getValue('type_id', $dataArticle['type'])
                ),

                $this->filterInteger(
                    $this->getValue(
                        'category_id',
                        $dataArticle['category']
                    )
                ),

                $this->getValue('reporter', $dataArticle),

                $this->filterString(
                    $this->getValue('lead', $dataArticle)
                ),

                $this->getValue('tag_name', $dataArticle['tags']),

                $this->filterString(
                    $this->getValue('published_at', $dataArticle)
                ),

                $this->filterInteger(
                    $this->getValue('id', $dataArticle)
                )

            );

            $attachmentConstants = array(
                Article::ATTACHMENT_FIELD_PHOTO, Article::ATTACHMENT_FIELD_PAGE,
                Article::ATTACHMENT_FIELD_GALLERY, Article::ATTACHMENT_FIELD_VIDEO,
            );

            $attachmentTypes = array(
                self::JSON_PHOTO_FIELD, self::JSON_PAGE_FIELD,
                self::JSON_GALLERY_FIELD, self::JSON_VIDEO_FIELD,
            );

            $attachmentAttributes = $this->lookUp($attachmentConstants);

            $article = $this->generalAttachment($article, $attachmentConstants, $attachmentTypes, $attachmentAttributes, $dataArticle);
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
$object = $a->getObject();

            return $article;

        }

        throw new \Exception("Empty or invalid JSON Response", 1);
    }

    /**
     * Create list attributes based on Article attachment type
     * @param  array $articleConstant
     * @return array
     */
    private function lookUp($articleConstant)
    {
        $copyListAttributes = $this->listAttributes;

        $lists = array_map(function ($singleConst) use ($copyListAttributes) {
            $res = $copyListAttributes[$singleConst];
            return array_map(function ($str) use ($singleConst) {
                return $singleConst . $str;
            }, $res);
        }, $articleConstant);

        return $lists;
    }

    /**
     * Attach attachments to article
     * @param  Article $article
     * @param  array $attachmentConst
     * @param  array $attachmentype
     * @param  array $attributes
     * @param  array $dataArticle
     * @return void
     */
    private function generalAttachment(
        $article,
        $attachmentConst,
        $attachmentype,
        $attributes,
        $dataArticle
    ) {
        $numOfAttachments = count($attachmentConst);

        for ($i = 0; $i < $numOfAttachments; $i++) {
            $attachments = $this->attachment($attachmentype[$i], $attributes[$i], $dataArticle);

            for ($j = 0; $j < $attachments['numberOfItems']; $j++) {
                $attachment = $attachments['attachments'][$j];

                $article->attach($attachmentConst[$i], $attachment);
            }
        }

        return $article;

    }

    /**
     * Attachment(s) of a single article
     * @param  string $attachmentType
     * @param  array $attributes
     * @param  assoc array $dataArticle
     * @return array attachments
     */
    private function attachment($attachmentType, $attributes, $dataArticle)
    {
        $data = $dataArticle[$attachmentType];

        $encoded = json_encode($data);

        $attachments = array();

        if ($this->filterArray($data)) {
            $decodedData = json_decode($encoded, true);

            $numberOfItems = count($decodedData);

            for ($i = 0; $i < $numberOfItems; $i++) {
                $item = $decodedData[$i];

                $attachment = $this->filterAttachmentObject(
                    $this->makeAttachmentObject(
                        $attachmentType,
                        $attributes,
                        $item
                    )
                );

                array_push($attachments, $attachment);
            }
        }

        $structure = array(
            'numberOfItems' => count($attachments),
            'attachments'   => $attachments,
        );

        return $structure;
    }

    /**
     * Make attachment object
     * @param  string $attachmentType json field of attachment
     * @param  array  $attributes     attributes of attachment
     * @param  assoc array $item
     * @return object
     */
    private function makeAttachmentObject($attachmentType, $attrReferences, $item)
    {
        $attrValues = array();

        foreach ($attrReferences as $attrReference) {
            $attrValues[$attrReference] = $this->getValue($attrReference, $item);
        }

        switch ($attachmentType) {
            case self::JSON_PHOTO_FIELD:
                return $this->createPhoto(
                    $attrValues['photo_url'],
                    $attrValues['photo_ratio'],
                    '',
                    ''
                );
            case self::JSON_PAGE_FIELD:
                return $this->createPage(
                    $attrValues['page_title'],
                    $attrValues['page_body'],
                    $attrValues['page_source'],
                    $attrValues['page_order'],
                    $attrValues['page_cover'],
                    $attrValues['page_lead']
                );
            case self::JSON_GALLERY_FIELD:
                return $this->createGallery(
                    $attrValues['gallery_body'],
                    $attrValues['gallery_order'],
                    $attrValues['gallery_photo'],
                    $attrValues['gallery_source'],
                    $attrValues['gallery_lead']
                );
            case self::JSON_VIDEO_FIELD:
                return $this->createVideo(
                    $attrValues['video_body'],
                    $attrValues['video_source'],
                    $attrValues['video_order'],
                    $attrValues['video_cover'],
                    $attrValues['video_lead']
                );
            default:
                return null;
        }
    }

    /**
     * Create photo object
     * @param  array $values
     * @return Photo
     */
    private function createPhoto($url, $ratio, $desc, $info)
    {
        return new Photo(
            $url,
            $this->photoRatio($ratio),
            $desc,
            $info
        );
    }

    /**
     * Create page object
     * @param  array $values
     * @return Page
     */
    private function createPage($title, $body, $source, $order, $cover, $lead)
    {
        return new Page(
            $title,
            $body,
            $source,
            $order,
            $cover,
            $lead
        );
    }

    /**
     * Create Gallery object
     * @param  array $values
     * @return Gallery
     */
    private function createGallery($body, $order, $photo, $source, $lead)
    {
        return new Gallery(
            $body,
            $order,
            $photo,
            $source,
            $lead
        );
    }

    /**
     * Create Video object
     * @param  array $values
     * @return Video
     */
    private function createVideo($body, $source, $order, $cover, $lead)
    {
        return new Video(

            $body,
            $source,
            $order,
            $cover,
            $lead
        );
    }

    /**
     * Map ratio to photo ratio constants
     * @param   string $ratio
     * @return   string
     * @throws Exception
     */
    private function photoRatio($ratio)
    {
        if ($ratio == "1:1") {
            return Photo::RATIO_SQUARE;
        } elseif ($ratio == "2:1") {
            return Photo::RATIO_RECTANGLE;
        } elseif ($ratio == "3:2") {
            return Photo::RATIO_HEADLINE;
        } elseif ($ratio == "9:16") {
            return Photo::RATIO_VERTICAL;
        } elseif ($ratio == 'cover') {
            return Photo::RATIO_COVER;
        } else {
            throw new \Exception("Unknown ratio", 1);
        }
    }

    /**
     * Make sure value is integer
     * @param  mixed $int
     * @return int
     * @throws Exception
     */
    private function filterInteger($int)
    {
        if (is_int($int)) {
            return $int;
        }
        throw new \Exception("Invalid Integer", 1);
    }

    /**
     * Make sure string is not null or empty
     * @param   mixed $str
     * @return string if it is valid or exception
     * @throws Exception
     */
    private function filterString($str)
    {
        if (is_string($str) && strlen($str) > 0 && !is_null($str)) {
            return $str;
        }
        throw new \Exception("String required", 1);
    }

    /**
     * Make sure variable is type of array
     * @param  mixed $array
     * @return array
     * @throws Exception
     */
    private function filterArray($array)
    {
        if (is_array($array)) {
            return $array;
        }
        throw new \Exception("Array required", 1);
    }

    /**
     * Make sure attachment object not null
     * @param  mixed $object
     * @return object
     * @throws Exception
     */
    private function filterAttachmentObject($object)
    {
        if (!is_null($object)) {
            return $object;
        }
        throw new \Exception("Attachment object required", 1);
    }

    /**
     * Get value of array based on attributes(keys)
     * @param  mixed $attribute
     * @param  array $data
     * @return mixed
     */
    private function getValue($attribute, $data)
    {
        return isset($data[$attribute]) ? $data[$attribute] : null;
    }
}


1			<?php
2
3			namespace one;
4
5			use One\Model\Article;
6			use one\Model\Gallery;
7			use One\Model\Page;
8			use one\Model\Photo;
9			use One\Model\Video;
10
11			class FormatMapping
12			{
13
14			/**
15			* Possible attributes of JSON data
16			* @var array
17			*/
18			private $listAttributes;
19
20			/**
21			* JSON field constants
22			*/
23			const JSON_PHOTO_FIELD = "photos";
24
25			const JSON_PAGE_FIELD = "pages";
26
27			const JSON_GALLERY_FIELD = "galleries";
28
29			const JSON_VIDEO_FIELD = "videos";
30
31			/**
32			* Construct JSON attributes
33			*/
34			public function __construct()
35			{
36			$this->listAttributes = array(
37			Article::ATTACHMENT_FIELD_PHOTO => array(
38			'_id', '_url', '_ratio', '_description', '_information',
39			),
40			Article::ATTACHMENT_FIELD_PAGE => array(
41			'_id', '_title', '_lead', '_body', '_source', '_order', '_cover',
42			),
43			Article::ATTACHMENT_FIELD_GALLERY => array(
44			'_id', '_lead', '_body', '_source', '_order', '_photo',
45			),
46			Article::ATTACHMENT_FIELD_VIDEO => array(
47			'_id', '_lead', '_body', '_source', '_order', '_cover',
48			),
49			);
50			}
51
52			/**
53			* map a single article to main attributes in Article Class
54			* @param string $singleJsonArticle JSON response
55			* @return Article
56			* @throws Exception
57			*/
58			public function article($singleJsonArticle)
59			{
60			if (json_decode($singleJsonArticle, true)) {
61			$dataArticle = json_decode($singleJsonArticle, true)['data'];
62
63			$article = new Article(
64
65			$this->filterString(
66			$this->getValue('title', $dataArticle)
67			),
68
69			$this->filterString(
70			$this->getValue('body', $dataArticle)
71			),
72
73			$this->filterString(
74			$this->getValue('source', $dataArticle)
75			),
76
77			$this->getValue('unique_id', $dataArticle),
78
79			$this->filterInteger(
80			$this->getValue('type_id', $dataArticle['type'])
81			),
82
83			$this->filterInteger(
84			$this->getValue(
85			'category_id',
86			$dataArticle['category']
87			)
88			),
89
90			$this->getValue('reporter', $dataArticle),
91
92			$this->filterString(
93			$this->getValue('lead', $dataArticle)
94			),
95
96			$this->getValue('tag_name', $dataArticle['tags']),
97
98			$this->filterString(
99			$this->getValue('published_at', $dataArticle)
100			),
101
102			$this->filterInteger(
103			$this->getValue('id', $dataArticle)
104			)
105
106			);
107
108			$attachmentConstants = array(
109			Article::ATTACHMENT_FIELD_PHOTO, Article::ATTACHMENT_FIELD_PAGE,
110			Article::ATTACHMENT_FIELD_GALLERY, Article::ATTACHMENT_FIELD_VIDEO,
111			);
112
113			$attachmentTypes = array(
114			self::JSON_PHOTO_FIELD, self::JSON_PAGE_FIELD,
115			self::JSON_GALLERY_FIELD, self::JSON_VIDEO_FIELD,
116			);
117
118			$attachmentAttributes = $this->lookUp($attachmentConstants);
119
120			$article = $this->generalAttachment($article, $attachmentConstants, $attachmentTypes, $attachmentAttributes, $dataArticle);
			0 ignored issues – show Bug introduced 2018-07-06 04:47 UTC by Report Bug Copy Issue Report Are you sure the assignment to `$article` is correct as `$this->generalAttachment...tributes, $dataArticle)` targeting `one\FormatMapping::generalAttachment()` seems to always return null. This check looks for function or method calls that always return null and whose return value is assigned to a variable. class A { function getObject() { return null; } } $a = new A(); $object = $a->getObject(); The method `getObject()` can return nothing but null, so it makes no sense to assign that value to a variable. The reason is most likely that a function or method is imcomplete or has been reduced for debug purposes. Loading history...
121
122			return $article;
			0 ignored issues – show Bug Best Practice introduced 2018-07-06 04:47 UTC by Report Bug Copy Issue Report The expression `return $article` returns the type `void` which is incompatible with the documented return type `One\Model\Article`. Loading history...
123			}
124
125			throw new \Exception("Empty or invalid JSON Response", 1);
126			}
127
128			/**
129			* Create list attributes based on Article attachment type
130			* @param array $articleConstant
131			* @return array
132			*/
133			private function lookUp($articleConstant)
134			{
135			$copyListAttributes = $this->listAttributes;
136
137			$lists = array_map(function ($singleConst) use ($copyListAttributes) {
138			$res = $copyListAttributes[$singleConst];
139			return array_map(function ($str) use ($singleConst) {
140			return $singleConst . $str;
141			}, $res);
142			}, $articleConstant);
143
144			return $lists;
145			}
146
147			/**
148			* Attach attachments to article
149			* @param Article $article
150			* @param array $attachmentConst
151			* @param array $attachmentype
152			* @param array $attributes
153			* @param array $dataArticle
154			* @return void
155			*/
156			private function generalAttachment(
157			$article,
158			$attachmentConst,
159			$attachmentype,
160			$attributes,
161			$dataArticle
162			) {
163			$numOfAttachments = count($attachmentConst);
164
165			for ($i = 0; $i < $numOfAttachments; $i++) {
166			$attachments = $this->attachment($attachmentype[$i], $attributes[$i], $dataArticle);
167
168			for ($j = 0; $j < $attachments['numberOfItems']; $j++) {
169			$attachment = $attachments['attachments'][$j];
170
171			$article->attach($attachmentConst[$i], $attachment);
172			}
173			}
174
175			return $article;
			0 ignored issues – show Bug Best Practice introduced 2018-07-06 04:47 UTC by Report Bug Copy Issue Report The expression `return $article` returns the type `One\Model\Article` which is incompatible with the documented return type `void`. Loading history...
176			}
177
178			/**
179			* Attachment(s) of a single article
180			* @param string $attachmentType
181			* @param array $attributes
182			* @param assoc array $dataArticle
183			* @return array attachments
184			*/
185			private function attachment($attachmentType, $attributes, $dataArticle)
186			{
187			$data = $dataArticle[$attachmentType];
188
189			$encoded = json_encode($data);
190
191			$attachments = array();
192
193			if ($this->filterArray($data)) {
194			$decodedData = json_decode($encoded, true);
195
196			$numberOfItems = count($decodedData);
197
198			for ($i = 0; $i < $numberOfItems; $i++) {
199			$item = $decodedData[$i];
200
201			$attachment = $this->filterAttachmentObject(
202			$this->makeAttachmentObject(
203			$attachmentType,
204			$attributes,
205			$item
206			)
207			);
208
209			array_push($attachments, $attachment);
210			}
211			}
212
213			$structure = array(
214			'numberOfItems' => count($attachments),
215			'attachments' => $attachments,
216			);
217
218			return $structure;
219			}
220
221			/**
222			* Make attachment object
223			* @param string $attachmentType json field of attachment
224			* @param array $attributes attributes of attachment
225			* @param assoc array $item
226			* @return object
227			*/
228			private function makeAttachmentObject($attachmentType, $attrReferences, $item)
229			{
230			$attrValues = array();
231
232			foreach ($attrReferences as $attrReference) {
233			$attrValues[$attrReference] = $this->getValue($attrReference, $item);
234			}
235
236			switch ($attachmentType) {
237			case self::JSON_PHOTO_FIELD:
238			return $this->createPhoto(
239			$attrValues['photo_url'],
240			$attrValues['photo_ratio'],
241			'',
242			''
243			);
244			case self::JSON_PAGE_FIELD:
245			return $this->createPage(
246			$attrValues['page_title'],
247			$attrValues['page_body'],
248			$attrValues['page_source'],
249			$attrValues['page_order'],
250			$attrValues['page_cover'],
251			$attrValues['page_lead']
252			);
253			case self::JSON_GALLERY_FIELD:
254			return $this->createGallery(
255			$attrValues['gallery_body'],
256			$attrValues['gallery_order'],
257			$attrValues['gallery_photo'],
258			$attrValues['gallery_source'],
259			$attrValues['gallery_lead']
260			);
261			case self::JSON_VIDEO_FIELD:
262			return $this->createVideo(
263			$attrValues['video_body'],
264			$attrValues['video_source'],
265			$attrValues['video_order'],
266			$attrValues['video_cover'],
267			$attrValues['video_lead']
268			);
269			default:
270			return null;
271			}
272			}
273
274			/**
275			* Create photo object
276			* @param array $values
277			* @return Photo
278			*/
279			private function createPhoto($url, $ratio, $desc, $info)
280			{
281			return new Photo(
282			$url,
283			$this->photoRatio($ratio),
284			$desc,
285			$info
286			);
287			}
288
289			/**
290			* Create page object
291			* @param array $values
292			* @return Page
293			*/
294			private function createPage($title, $body, $source, $order, $cover, $lead)
295			{
296			return new Page(
297			$title,
298			$body,
299			$source,
300			$order,
301			$cover,
302			$lead
303			);
304			}
305
306			/**
307			* Create Gallery object
308			* @param array $values
309			* @return Gallery
310			*/
311			private function createGallery($body, $order, $photo, $source, $lead)
312			{
313			return new Gallery(
314			$body,
315			$order,
316			$photo,
317			$source,
318			$lead
319			);
320			}
321
322			/**
323			* Create Video object
324			* @param array $values
325			* @return Video
326			*/
327			private function createVideo($body, $source, $order, $cover, $lead)
328			{
329			return new Video(
330
331			$body,
332			$source,
333			$order,
334			$cover,
335			$lead
336			);
337			}
338
339			/**
340			* Map ratio to photo ratio constants
341			* @param string $ratio
342			* @return string
343			* @throws Exception
344			*/
345			private function photoRatio($ratio)
346			{
347			if ($ratio == "1:1") {
348			return Photo::RATIO_SQUARE;
349			} elseif ($ratio == "2:1") {
350			return Photo::RATIO_RECTANGLE;
351			} elseif ($ratio == "3:2") {
352			return Photo::RATIO_HEADLINE;
353			} elseif ($ratio == "9:16") {
354			return Photo::RATIO_VERTICAL;
355			} elseif ($ratio == 'cover') {
356			return Photo::RATIO_COVER;
357			} else {
358			throw new \Exception("Unknown ratio", 1);
359			}
360			}
361
362			/**
363			* Make sure value is integer
364			* @param mixed $int
365			* @return int
366			* @throws Exception
367			*/
368			private function filterInteger($int)
369			{
370			if (is_int($int)) {
371			return $int;
372			}
373			throw new \Exception("Invalid Integer", 1);
374			}
375
376			/**
377			* Make sure string is not null or empty
378			* @param mixed $str
379			* @return string if it is valid or exception
380			* @throws Exception
381			*/
382			private function filterString($str)
383			{
384			if (is_string($str) && strlen($str) > 0 && !is_null($str)) {
385			return $str;
386			}
387			throw new \Exception("String required", 1);
388			}
389
390			/**
391			* Make sure variable is type of array
392			* @param mixed $array
393			* @return array
394			* @throws Exception
395			*/
396			private function filterArray($array)
397			{
398			if (is_array($array)) {
399			return $array;
400			}
401			throw new \Exception("Array required", 1);
402			}
403
404			/**
405			* Make sure attachment object not null
406			* @param mixed $object
407			* @return object
408			* @throws Exception
409			*/
410			private function filterAttachmentObject($object)
411			{
412			if (!is_null($object)) {
413			return $object;
414			}
415			throw new \Exception("Attachment object required", 1);
416			}
417
418			/**
419			* Get value of array based on attributes(keys)
420			* @param mixed $attribute
421			* @param array $data
422			* @return mixed
423			*/
424			private function getValue($attribute, $data)
425			{
426			return isset($data[$attribute]) ? $data[$attribute] : null;
427			}
428			}
429

KLYgarage / onesdk

Pull Request — master (#21)

FormatMapping::lookUp() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like