Article::setComponents() - Code Metrics - Inspection of "Added more metadata options plus validation on met..." - flatplanapp/flatplan-sdk - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 7e18cf...d0fe56 )

by Jon

created 2018-07-05 15:23 UTC

Article::setComponents() A

↳ Parent: Article

Complexity

Conditions	5
Paths	5

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	5
nc	5
nop	1
dl	0
loc	14
rs	9.4888
c	0
b	0
f	0

<?php namespace FlatPlan;

use FlatPlan\Components\AbstractComponent;

class Article {

    private $components = array();
    private $status;
    private $articleId;
    private $title;
    private $subTitle;
    private $language = 'en';
    private $category;
    private $template;
    private $metaData;
    private $allowedMetaKeys = array(
        'authors' => 'string',
        'canonicalURL' => 'uri',
        'coverArt' => 'array',
        'dateCreated' => 'datetime',
        'dateModified' => 'datetime',
        'datePublished' => 'datetime',
        'excerpt' => 'string',
        'keywords' => 'string',
        'links' => 'array',
        'thumbnailURL' => 'uri',
        'transparentToolbar' => 'boolean',
        'videoURL' => 'uri',
        'accessoryText' => 'string',
        'isCandidateToBeFeatured' => 'boolean',
        'isHidden' => 'boolean',
        'isPreview' => 'boolean',
        'isSponsored' => 'boolean',
        'maturityRating' => 'string'
    );

    public function __construct($articleId, $status = 'draft')
    {
        $this->articleId = $articleId;
        $this->status    = $status;
    }

    public function setTitle($title) {
        $this->title = $title;
    }

    public function getTitle()
    {
        return $this->title;
    }

    public function setSubTitle($subTitle) {
        $this->subTitle = $subTitle;
    }

    public function getSubTitle()
    {
        return $this->subTitle;
    }

    public function setLanguage($language)
    {
        $this->language = $language;
    }

    public function getLanguage()
    {
        return $this->language;
    }

    public function setCategory($category)
    {
        $this->category = $category;
    }

    public function getCategory()
    {
        return $this->category;
    }

    public function setTemplate($template)
    {
        $this->template = $template;
    }

    public function getTemplate()
    {
        return $this->template;
    }

    public function setMetaData($metaData)
    {
        $metaObj = new \stdClass();
        $errors  = array();
        if (is_array($metaData)) {
            foreach ($metaData as $key => $value) {
                if (isset($this->allowedMetaKeys[$key])) {
                    $type = gettype($value);
                    switch ($this->allowedMetaKeys[$key]) {
                        case 'uri':
                            if (filter_var($value, FILTER_VALIDATE_URL)) {
                                $metaObj->{$key} = $value;
                            } else {
                                $errors[] = array(
                                    'key' => $key,
                                    'message' => 'Not a valid URI'
                                );
                            }
                            break;

                        case 'datetime':
                            if ($value instanceof \DateTime) {
                                $metaObj->{$key} = $value;
                            } else {
                                $errors[] = array(
                                    'key' => $key,
                                    'message' => 'Not a valid DateTime object'
                                );
                            }
                            break;

                        default:
                            if ($type === $this->allowedMetaKeys[$key]) {
                                $metaObj->{$key} = $value;
                            } else {
                                $errors[] = array(
                                    'key' => $key,
                                    'message' => 'Expected ' . $this->allowedMetaKeys[$key] . '; received ' . $type
                                );
                            }
                            break;
                    }
                } else {
                    $errors[] = array(
                        'key' => $key,
                        'message' => 'Not a valid MetaData key'
                    );
                }
            }
        }

        if (!empty($errors)) {
            throw new \ErrorException('Invalid MetaData: ' . print_r($errors, true));
        }

        $this->metaData = $metaObj;
    }

    public function getMetaData()
    {
        return $this->metaData;
    }

    public function getJson()
    {
        $article             = new \stdClass();
        $article->articleId  = $this->articleId;
        $article->language   = $this->getLanguage();
        $article->status     = $this->status;
        $article->title      = $this->getTitle();
        $article->subTitle   = $this->getSubTitle();
        $article->category   = $this->getCategory();
        $article->template   = $this->getTemplate();
        $article->metaData   = $this->getMetaData();
        $article->components = $this->getComponents();

        return json_encode($article);
    }

    public function getComponents($format = null)
    {
        $output = array();
        foreach ($this->components as $component) {
            array_push($output, $component->getComponent());
        }

        if ($format === 'json') {
            return json_encode($output);
        }

        return $output;
    }

    /**
     * @param AbstractComponent $component
     * @throws \ErrorException
     * @return void
     */
    public function setComponents($components)
    {
        if (is_array($components)) {
            foreach ($components as $component) {
                if ($component instanceof AbstractComponent) {
                    $component->updateStyles('root');
                    array_push($this->components, $component);
                }
            }
        } else if ($components instanceof AbstractComponent) {
            $components->updateStyles('root');
            array_push($this->components, $components);
        } else {
            throw new \ErrorException('Invalid component supplied.');
        }
    }
}


1			<?php namespace FlatPlan;
2
3			use FlatPlan\Components\AbstractComponent;
4
5			class Article {
6
7			private $components = array();
8			private $status;
9			private $articleId;
10			private $title;
11			private $subTitle;
12			private $language = 'en';
13			private $category;
14			private $template;
15			private $metaData;
16			private $allowedMetaKeys = array(
17			'authors' => 'string',
18			'canonicalURL' => 'uri',
19			'coverArt' => 'array',
20			'dateCreated' => 'datetime',
21			'dateModified' => 'datetime',
22			'datePublished' => 'datetime',
23			'excerpt' => 'string',
24			'keywords' => 'string',
25			'links' => 'array',
26			'thumbnailURL' => 'uri',
27			'transparentToolbar' => 'boolean',
28			'videoURL' => 'uri',
29			'accessoryText' => 'string',
30			'isCandidateToBeFeatured' => 'boolean',
31			'isHidden' => 'boolean',
32			'isPreview' => 'boolean',
33			'isSponsored' => 'boolean',
34			'maturityRating' => 'string'
35			);
36
37			public function __construct($articleId, $status = 'draft')
38			{
39			$this->articleId = $articleId;
40			$this->status = $status;
41			}
42
43			public function setTitle($title) {
44			$this->title = $title;
45			}
46
47			public function getTitle()
48			{
49			return $this->title;
50			}
51
52			public function setSubTitle($subTitle) {
53			$this->subTitle = $subTitle;
54			}
55
56			public function getSubTitle()
57			{
58			return $this->subTitle;
59			}
60
61			public function setLanguage($language)
62			{
63			$this->language = $language;
64			}
65
66			public function getLanguage()
67			{
68			return $this->language;
69			}
70
71			public function setCategory($category)
72			{
73			$this->category = $category;
74			}
75
76			public function getCategory()
77			{
78			return $this->category;
79			}
80
81			public function setTemplate($template)
82			{
83			$this->template = $template;
84			}
85
86			public function getTemplate()
87			{
88			return $this->template;
89			}
90
91			public function setMetaData($metaData)
92			{
93			$metaObj = new \stdClass();
94			$errors = array();
95			if (is_array($metaData)) {
96			foreach ($metaData as $key => $value) {
97			if (isset($this->allowedMetaKeys[$key])) {
98			$type = gettype($value);
99			switch ($this->allowedMetaKeys[$key]) {
100			case 'uri':
101			if (filter_var($value, FILTER_VALIDATE_URL)) {
102			$metaObj->{$key} = $value;
103			} else {
104			$errors[] = array(
105			'key' => $key,
106			'message' => 'Not a valid URI'
107			);
108			}
109			break;
110
111			case 'datetime':
112			if ($value instanceof \DateTime) {
113			$metaObj->{$key} = $value;
114			} else {
115			$errors[] = array(
116			'key' => $key,
117			'message' => 'Not a valid DateTime object'
118			);
119			}
120			break;
121
122			default:
123			if ($type === $this->allowedMetaKeys[$key]) {
124			$metaObj->{$key} = $value;
125			} else {
126			$errors[] = array(
127			'key' => $key,
128			'message' => 'Expected ' . $this->allowedMetaKeys[$key] . '; received ' . $type
129			);
130			}
131			break;
132			}
133			} else {
134			$errors[] = array(
135			'key' => $key,
136			'message' => 'Not a valid MetaData key'
137			);
138			}
139			}
140			}
141
142			if (!empty($errors)) {
143			throw new \ErrorException('Invalid MetaData: ' . print_r($errors, true));
144			}
145
146			$this->metaData = $metaObj;
147			}
148
149			public function getMetaData()
150			{
151			return $this->metaData;
152			}
153
154			public function getJson()
155			{
156			$article = new \stdClass();
157			$article->articleId = $this->articleId;
158			$article->language = $this->getLanguage();
159			$article->status = $this->status;
160			$article->title = $this->getTitle();
161			$article->subTitle = $this->getSubTitle();
162			$article->category = $this->getCategory();
163			$article->template = $this->getTemplate();
164			$article->metaData = $this->getMetaData();
165			$article->components = $this->getComponents();
166
167			return json_encode($article);
168			}
169
170			public function getComponents($format = null)
171			{
172			$output = array();
173			foreach ($this->components as $component) {
174			array_push($output, $component->getComponent());
175			}
176
177			if ($format === 'json') {
178			return json_encode($output);
179			}
180
181			return $output;
182			}
183
184			/**
185			* @param AbstractComponent $component
186			* @throws \ErrorException
187			* @return void
188			*/
189			public function setComponents($components)
190			{
191			if (is_array($components)) {
192			foreach ($components as $component) {
193			if ($component instanceof AbstractComponent) {
194			$component->updateStyles('root');
195			array_push($this->components, $component);
196			}
197			}
198			} else if ($components instanceof AbstractComponent) {
199			$components->updateStyles('root');
200			array_push($this->components, $components);
201			} else {
202			throw new \ErrorException('Invalid component supplied.');
203			}
204			}
205			}
206

flatplanapp / flatplan-sdk

Push — master ( 7e18cf...d0fe56 )

Article::setComponents() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like