FormatMapping::attachment() - 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-05 07:18 UTC

FormatMapping::attachment() A

↳ Parent: FormatMapping

Complexity

Conditions	3
Paths	2

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	3
nc	2
nop	3
dl	0
loc	28
rs	9.472
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
{

    /**
     * Json Attributes of Photo
     * @var array
     */
    private $photoAttributes;

    /**
     * Json Attributes of Page
     * @var array
     */
    private $pageAttributes;

    /**
     * Json Attributes of gallery
     * @var array
     */
    private $galleryAttributes;

    /**
     * Json Attributes of video
     * @var array
     */
    private $videoAttributes;

    /**
     * Construct Json attribute variables
     */
    public function __construct()
    {
        $this->photoAttributes = array(
            "photo_id",
            "photo_url",
            "photo_ratio",
            "photo_description",
            "photo_information",
        );

        $this->pageAttributes = array(
            "page_id",
            "page_title",
            "page_lead",
            "page_body",
            "page_source",
            "page_order",
            "page_cover",
        );

        $this->galleryAttributes = array(
            "gallery_id",
            "gallery_lead",
            "gallery_body",
            "gallery_source",
            "gallery_order",
            "gallery_photo",
        );

        $this->videoAttributes = array(
            "video_id",
            "video_lead",
            "video_body",
            "video_source",
            "video_order",
            "video_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(

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

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

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

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

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

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

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

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

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

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

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

            );

            $photo_attachments = $this->attachment('photos', $this->photoAttributes, $dataArticle);

            $page_attachments = $this->attachment('pages', $this->pageAttributes, $dataArticle);

            $gallery_attachments = $this->attachment('galleries', $this->galleryAttributes, $dataArticle);

            $video_attachments = $this->attachment('videos', $this->videoAttributes, $dataArticle);

            for ($i = 0; $i < $photo_attachments['numberOfItems']; $i++) {
                $article->attachPhoto($photo_attachments['attachments'][$i]);
            }

            for ($i = 0; $i < $page_attachments['numberOfItems']; $i++) {
                $article->attachPage($page_attachments['attachments'][$i]);
            }

            for ($i = 0; $i < $gallery_attachments['numberOfItems']; $i++) {
                $article->attachGallery($gallery_attachments['attachments'][$i]);
            }

            for ($i = 0; $i < $video_attachments['numberOfItems']; $i++) {
                $article->attachVideo($video_attachments['attachments'][$i]);
            }

            return $article;
        }

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

    /**
     * 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->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, $attributes, $item)
    {
        $numOfAttributes = count($attributes);

        $values = array();

        $object = null;

        for ($i = 0; $i < $numOfAttributes; $i++) {
            $val = $this->getValue($attributes[$i], $item);
            $values[$attributes[$i]] = $val;
        }

        extract($values);

        if ($attachmentType == 'photos') {
            $object = new Photo(
                $photo_url,
                $this->photoRatio($photo_ratio),
                '',
                ''
            );
        } elseif ($attachmentType == 'pages') {
            $object = new Page(
                $page_title,
                $page_body,
                $page_source,
                $page_order,
                $page_cover,
                $page_lead
            );
        } elseif ($attachmentType == 'galleries') {
            $object = new Gallery(
                $gallery_body,
                $gallery_order,
                $gallery_photo,
                $gallery_source,
                $gallery_lead
            );
        } elseif ($attachmentType == 'videos') {
            $object = new Video(

                $video_body,
                $video_source,
                $video_order,
                $video_cover,
                $video_lead
            );
        }

        return $this->filterAttachmentObject($object);
    }

    /**
     * Map ratio to photo ratio constants
     * @param   string $ratio
     * @return  constant ratio
filter:
    dependency_paths: ["lib/*"]
     * @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) $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  supported php variables $attribute
filter:
    dependency_paths: ["lib/*"]
     * @param  array $data
     * @return supported php variables
filter:
    dependency_paths: ["lib/*"]
     */
    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			* Json Attributes of Photo
16			* @var array
17			*/
18			private $photoAttributes;
19
20			/**
21			* Json Attributes of Page
22			* @var array
23			*/
24			private $pageAttributes;
25
26			/**
27			* Json Attributes of gallery
28			* @var array
29			*/
30			private $galleryAttributes;
31
32			/**
33			* Json Attributes of video
34			* @var array
35			*/
36			private $videoAttributes;
37
38			/**
39			* Construct Json attribute variables
40			*/
41			public function __construct()
42			{
43			$this->photoAttributes = array(
44			"photo_id",
45			"photo_url",
46			"photo_ratio",
47			"photo_description",
48			"photo_information",
49			);
50
51			$this->pageAttributes = array(
52			"page_id",
53			"page_title",
54			"page_lead",
55			"page_body",
56			"page_source",
57			"page_order",
58			"page_cover",
59			);
60
61			$this->galleryAttributes = array(
62			"gallery_id",
63			"gallery_lead",
64			"gallery_body",
65			"gallery_source",
66			"gallery_order",
67			"gallery_photo",
68			);
69
70			$this->videoAttributes = array(
71			"video_id",
72			"video_lead",
73			"video_body",
74			"video_source",
75			"video_order",
76			"video_cover",
77			);
78			}
79			/**
80			* map a single article to main attributes in Article Class
81			* @param string $singleJsonArticle JSON response
82			* @return Article
83			* @throws Exception
84			*/
85			public function article($singleJsonArticle)
86			{
87			if (json_decode($singleJsonArticle, true)) {
88			$dataArticle = json_decode($singleJsonArticle, true)['data'];
89
90			$article = new Article(
91
92			$title = $this->filterString($this->getValue('title', $dataArticle)),
93
94			$body = $this->filterString($this->getValue('body', $dataArticle)),
95
96			$source = $this->filterString($this->getValue('source', $dataArticle)),
97
98			$uniqueId = $this->getValue('unique_id', $dataArticle),
99
100			$typeId = $this->filterInteger($this->getValue('type_id', $dataArticle['type'])),
101
102			$categoryId = $this->filterInteger($this->getValue(
103			'category_id',
104			$dataArticle['category']
105			)),
106
107			$reporter = $this->getValue('reporter', $dataArticle),
108
109			$lead = $this->filterString($this->getValue('lead', $dataArticle)),
110
111			$tags = $this->getValue('tag_name', $dataArticle['tags']),
112
113			$publishedAt = $this->filterString($this->getValue('published_at', $dataArticle)),
114
115			$identifier = $this->filterInteger($this->getValue('id', $dataArticle))
116
117			);
118
119			$photo_attachments = $this->attachment('photos', $this->photoAttributes, $dataArticle);
120
121			$page_attachments = $this->attachment('pages', $this->pageAttributes, $dataArticle);
122
123			$gallery_attachments = $this->attachment('galleries', $this->galleryAttributes, $dataArticle);
124
125			$video_attachments = $this->attachment('videos', $this->videoAttributes, $dataArticle);
126
127			for ($i = 0; $i < $photo_attachments['numberOfItems']; $i++) {
128			$article->attachPhoto($photo_attachments['attachments'][$i]);
129			}
130
131			for ($i = 0; $i < $page_attachments['numberOfItems']; $i++) {
132			$article->attachPage($page_attachments['attachments'][$i]);
133			}
134
135			for ($i = 0; $i < $gallery_attachments['numberOfItems']; $i++) {
136			$article->attachGallery($gallery_attachments['attachments'][$i]);
137			}
138
139			for ($i = 0; $i < $video_attachments['numberOfItems']; $i++) {
140			$article->attachVideo($video_attachments['attachments'][$i]);
141			}
142
143			return $article;
144			}
145
146			throw new \Exception("Empty or invalid JSON Response", 1);
147			}
148
149			/**
150			* Attachment(s) of a single article
151			* @param string $attachmentType
152			* @param array $attributes
153			* @param assoc array $dataArticle
154			* @return array attachments
155			*/
156			private function attachment($attachmentType, $attributes, $dataArticle)
157			{
158			$data = $dataArticle[$attachmentType];
159
160			$encoded = json_encode($data);
161
162			$attachments = array();
163
164			if ($this->filterArray($data)) {
165			$decodedData = json_decode($encoded, true);
166
167			$numberOfItems = count($decodedData);
168
169			for ($i = 0; $i < $numberOfItems; $i++) {
170			$item = $decodedData[$i];
171
172			$attachment = $this->makeAttachmentObject($attachmentType, $attributes, $item);
173
174			array_push($attachments, $attachment);
175			}
176			}
177
178			$structure = array(
179			'numberOfItems' => count($attachments),
180			'attachments' => $attachments,
181			);
182
183			return $structure;
184			}
185
186			/**
187			* Make attachment object
188			* @param string $attachmentType json field of attachment
189			* @param array $attributes attributes of attachment
190			* @param assoc array $item
191			* @return object
192			*/
193			private function makeAttachmentObject($attachmentType, $attributes, $item)
194			{
195			$numOfAttributes = count($attributes);
196
197			$values = array();
198
199			$object = null;
200
201			for ($i = 0; $i < $numOfAttributes; $i++) {
202			$val = $this->getValue($attributes[$i], $item);
203			$values[$attributes[$i]] = $val;
204			}
205
206			extract($values);
207
208			if ($attachmentType == 'photos') {
209			$object = new Photo(
210			$photo_url,
211			$this->photoRatio($photo_ratio),
212			'',
213			''
214			);
215			} elseif ($attachmentType == 'pages') {
216			$object = new Page(
217			$page_title,
218			$page_body,
219			$page_source,
220			$page_order,
221			$page_cover,
222			$page_lead
223			);
224			} elseif ($attachmentType == 'galleries') {
225			$object = new Gallery(
226			$gallery_body,
227			$gallery_order,
228			$gallery_photo,
229			$gallery_source,
230			$gallery_lead
231			);
232			} elseif ($attachmentType == 'videos') {
233			$object = new Video(
234
235			$video_body,
236			$video_source,
237			$video_order,
238			$video_cover,
239			$video_lead
240			);
241			}
242
243			return $this->filterAttachmentObject($object);
244			}
245
246			/**
247			* Map ratio to photo ratio constants
248			* @param string $ratio
249			* @return constant ratio
			0 ignored issues – show Bug introduced 2018-07-05 07:14 UTC by Report Bug Copy Issue Report The type `one\constant` was not found. Maybe you did not declare it correctly or list all dependencies? The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g. `excluded_paths: ["lib/"]`, you can move it to the dependency path list as follows: filter: dependency_paths: ["lib/"] For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths Loading history...
250			* @throws Exception
251			*/
252			private function photoRatio($ratio)
253			{
254			if ($ratio == "1:1") {
255			return Photo::RATIO_SQUARE;
			0 ignored issues – show Bug Best Practice introduced 2018-07-05 07:14 UTC by Report Bug Copy Issue Report The expression `return one\Model\Photo::RATIO_SQUARE` returns the type `string` which is incompatible with the documented return type `one\constant`. Loading history...
256			} elseif ($ratio == "2:1") {
257			return Photo::RATIO_RECTANGLE;
			0 ignored issues – show Bug Best Practice introduced 2018-07-05 07:14 UTC by Report Bug Copy Issue Report The expression `return one\Model\Photo::RATIO_RECTANGLE` returns the type `string` which is incompatible with the documented return type `one\constant`. Loading history...
258			} elseif ($ratio == "3:2") {
259			return Photo::RATIO_HEADLINE;
			0 ignored issues – show Bug Best Practice introduced 2018-07-05 07:14 UTC by Report Bug Copy Issue Report The expression `return one\Model\Photo::RATIO_HEADLINE` returns the type `string` which is incompatible with the documented return type `one\constant`. Loading history...
260			} elseif ($ratio == "9:16") {
261			return Photo::RATIO_VERTICAL;
			0 ignored issues – show Bug Best Practice introduced 2018-07-05 07:14 UTC by Report Bug Copy Issue Report The expression `return one\Model\Photo::RATIO_VERTICAL` returns the type `string` which is incompatible with the documented return type `one\constant`. Loading history...
262			} elseif ($ratio == 'cover') {
263			return Photo::RATIO_COVER;
			0 ignored issues – show Bug Best Practice introduced 2018-07-05 07:14 UTC by Report Bug Copy Issue Report The expression `return one\Model\Photo::RATIO_COVER` returns the type `string` which is incompatible with the documented return type `one\constant`. Loading history...
264			} else {
265			throw new \Exception("Unknown ratio", 1);
266			}
267			}
268
269			/**
270			* Make sure value is integer
271			* @param mixed $int
272			* @return int
273			* @throws Exception
274			*/
275			private function filterInteger($int)
276			{
277			if (is_int((int) $int)) {
			0 ignored issues – show introduced 2018-07-05 07:14 UTC by Report Bug Copy Issue Report The condition `is_int((int)$int)` is always `true`. Loading history...
278			return $int;
279			}
280			throw new \Exception("Invalid Integer", 1);
281			}
282
283			/**
284			* Make sure string is not null or empty
285			* @param mixed $str
286			* @return string if it is valid or exception
287			* @throws Exception
288			*/
289			private function filterString($str)
290			{
291			if (is_string($str) && strlen($str) > 0 && !is_null($str)) {
292			return $str;
293			}
294			throw new \Exception("String required", 1);
295			}
296
297			/**
298			* Make sure variable is type of array
299			* @param mixed $array
300			* @return array
301			* @throws Exception
302			*/
303			private function filterArray($array)
304			{
305			if (is_array($array)) {
306			return $array;
307			}
308			throw new \Exception("Array required", 1);
309			}
310
311			/**
312			* Make sure attachment object not null
313			* @param mixed $object
314			* @return object
315			* @throws Exception
316			*/
317			private function filterAttachmentObject($object)
318			{
319			if (!is_null($object)) {
320			return $object;
321			}
322			throw new \Exception("Attachment object required", 1);
323			}
324
325			/**
326			* Get value of array based on attributes(keys)
327			* @param supported php variables $attribute
			0 ignored issues – show Bug introduced 2018-07-05 07:14 UTC by Report Bug Copy Issue Report The type `one\php` was not found. Maybe you did not declare it correctly or list all dependencies? The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g. `excluded_paths: ["lib/"]`, you can move it to the dependency path list as follows: filter: dependency_paths: ["lib/"] For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths Loading history...
328			* @param array $data
329			* @return supported php variables
			0 ignored issues – show Bug introduced 2018-07-05 07:14 UTC by Report Bug Copy Issue Report The type `one\supported` was not found. Maybe you did not declare it correctly or list all dependencies? The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g. `excluded_paths: ["lib/"]`, you can move it to the dependency path list as follows: filter: dependency_paths: ["lib/"] For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths Loading history...
330			*/
331			private function getValue($attribute, $data)
332			{
333			return isset($data[$attribute]) ? $data[$attribute] : null;
334			}
335			}
336

KLYgarage / onesdk

Pull Request — master (#21)

FormatMapping::attachment() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like