AbstractModel::parseValue() - Code Metrics - pagantis/orders-api-client - Measure and Improve Code Quality continuously with Scrutinizer

AbstractModel::parseValue() C
last analyzed 2020-11-06 09:32 UTC

↳ Parent: AbstractModel

Complexity

Conditions	12
Paths	6

Size

Total Lines	21
Code Lines	13

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	12
eloc	13
nc	6
nop	2
dl	0
loc	21
rs	6.9666
c	0
b	0
f	0

How to fix Complexity

<?php

namespace Pagantis\OrdersApiClient\Model;

use Nayjest\StrCaseConverter\Str;

/**
 * Class AbstractModel
 *
 * @package Pagantis\OrdersApiClient\Model
 */
abstract class AbstractModel implements ModelInterface
{
    /**
     * Export as Array the object recursively
     *
     * @param bool $validation
     *
     * @return \stdClass
     */
    public function export($validation = true)
    {
        $result = new \StdClass();
        foreach ($this as $key => $value) {
            if (!is_null($value)) {
                $result->{Str::toSnakeCase($key)} = $this->parseValue($value, $validation);
            }
        }

        return $result;
interface HasName {
    /** @return string */
    public function getName();
}

class Name {
    public $name;
}

class User implements HasName {
    /** @return string|Name */
    public function getName() {
        return new Name('foo'); // This is a violation of the ``HasName`` interface
                                // which only allows a string value to be returned.
    }
}
    }

    /**
     * Parse the value of the object depending of type.
     *
     * @param $value
     * @param $validation
     *
     * @return array|string
     */
    protected function parseValue($value, $validation)
    {
        if (is_array($value) && !empty($value)) {
            $valueArray = array();
            foreach ($value as $subKey => $subValue) {
                if (is_object($subValue) && $subValue instanceof AbstractModel) {
                    $valueArray[Str::toSnakeCase($subKey)] = $subValue->export($validation);
                } else {
                    $valueArray[Str::toSnakeCase($subKey)] = $subValue;
                }
            }
            return $valueArray;
        }
        if (is_object($value) && $value instanceof AbstractModel && !empty($value)) {
            return $value->export();

        }
        if (is_object($value) && $value instanceof \DateTime && !empty($value)) {
            return $value->format('Y-m-d\Th:i:s');
        }

        return $value;
    }

    /**
     * Fill Up the Order from the json_decode(false) result of the API response.
     *
     * @param \stdClass $object
     *
     * @throws \Exception
     */
    public function import($object)
    {
        if (is_object($object)) {
            $properties = get_object_vars($object);
            foreach ($properties as $key => $value) {
                if (property_exists($this, lcfirst(Str::toCamelCase($key)))) {
                    if (is_object($value)) {
                        $objectProperty = $this->{lcfirst(Str::toCamelCase($key))};
                        if ($objectProperty instanceof AbstractModel) {
                            $objectProperty->import($value);
                        }
                    } else {
                        if (is_string($value) && $this->validateDate($value)) {
                            $this->{lcfirst(Str::toCamelCase($key))} = new \DateTime($value);
                        } else {
                            $this->{lcfirst(Str::toCamelCase($key))} = $value;
                        }
                    }
                }
            }
        }
    }

    /**
     * @param $date
     *
     * @return bool
     */
    private function validateDate($date)
    {
        try {
            $dateTime = new \DateTime($date);
        } catch (\Exception $exception) {
            return false;
        }

        if ($dateTime && substr($dateTime->format('c'), 0, 19) === substr($date, 0, 19)) {
            return true;
        }

        return false;
    }

    /**
     * @param null $date

     * @return null | String
     */
    protected function checkDateFormat($date = null)
    {
        if (empty($date) || $date == '0000-00-00') {
            return null;
        }
        if ($date instanceof \DateTime) {
            return $date->format('Y-m-d');
        }
        try {
            $dateTime = new \DateTime(trim($date));
            $today = new \DateTime('tomorrow');
            if ($dateTime >= $today) {
                return null;
            }
            return $dateTime->format('Y-m-d');
        } catch (\Exception $exception) {
            return null;
        }
    }

}


1			<?php
2
3			namespace Pagantis\OrdersApiClient\Model;
4
5			use Nayjest\StrCaseConverter\Str;
6
7			/**
8			* Class AbstractModel
9			*
10			* @package Pagantis\OrdersApiClient\Model
11			*/
12			abstract class AbstractModel implements ModelInterface
13			{
14			/**
15			* Export as Array the object recursively
16			*
17			* @param bool $validation
18			*
19			* @return \stdClass
20			*/
21			public function export($validation = true)
22			{
23			$result = new \StdClass();
24			foreach ($this as $key => $value) {
25			if (!is_null($value)) {
26			$result->{Str::toSnakeCase($key)} = $this->parseValue($value, $validation);
27			}
28			}
29
30			return $result;
			0 ignored issues – show Bug Best Practice introduced 2019-03-13 10:34 UTC by Report Bug Copy Issue Report The expression `return $result` returns the type `StdClass` which is incompatible with the return type mandated by `Pagantis\OrdersApiClient...odelInterface::export()` of `array`. In the issue above, the returned value is violating the contract defined by the mentioned interface. Let's take a look at an example: interface HasName { /** @return string / public function getName(); } class Name { public $name; } class User implements HasName { /* @return string\|Name */ public function getName() { return new Name('foo'); // This is a violation of the ``HasName`` interface // which only allows a string value to be returned. } } Loading history...
31			}
32
33			/**
34			* Parse the value of the object depending of type.
35			*
36			* @param $value
37			* @param $validation
38			*
39			* @return array\|string
40			*/
41			protected function parseValue($value, $validation)
42			{
43			if (is_array($value) && !empty($value)) {
44			$valueArray = array();
45			foreach ($value as $subKey => $subValue) {
46			if (is_object($subValue) && $subValue instanceof AbstractModel) {
47			$valueArray[Str::toSnakeCase($subKey)] = $subValue->export($validation);
48			} else {
49			$valueArray[Str::toSnakeCase($subKey)] = $subValue;
50			}
51			}
52			return $valueArray;
53			}
54			if (is_object($value) && $value instanceof AbstractModel && !empty($value)) {
55			return $value->export();
			0 ignored issues – show Bug Best Practice introduced 2018-10-31 16:47 UTC by Report Bug Copy Issue Report The expression `return $value->export()` returns the type `stdClass` which is incompatible with the documented return type `array\|string`. Loading history...
56			}
57			if (is_object($value) && $value instanceof \DateTime && !empty($value)) {
58			return $value->format('Y-m-d\Th:i:s');
59			}
60
61			return $value;
62			}
63
64			/**
65			* Fill Up the Order from the json_decode(false) result of the API response.
66			*
67			* @param \stdClass $object
68			*
69			* @throws \Exception
70			*/
71			public function import($object)
72			{
73			if (is_object($object)) {
74			$properties = get_object_vars($object);
75			foreach ($properties as $key => $value) {
76			if (property_exists($this, lcfirst(Str::toCamelCase($key)))) {
77			if (is_object($value)) {
78			$objectProperty = $this->{lcfirst(Str::toCamelCase($key))};
79			if ($objectProperty instanceof AbstractModel) {
80			$objectProperty->import($value);
81			}
82			} else {
83			if (is_string($value) && $this->validateDate($value)) {
84			$this->{lcfirst(Str::toCamelCase($key))} = new \DateTime($value);
85			} else {
86			$this->{lcfirst(Str::toCamelCase($key))} = $value;
87			}
88			}
89			}
90			}
91			}
92			}
93
94			/**
95			* @param $date
96			*
97			* @return bool
98			*/
99			private function validateDate($date)
100			{
101			try {
102			$dateTime = new \DateTime($date);
103			} catch (\Exception $exception) {
104			return false;
105			}
106
107			if ($dateTime && substr($dateTime->format('c'), 0, 19) === substr($date, 0, 19)) {
108			return true;
109			}
110
111			return false;
112			}
113
114			/**
115			* @param null $date
			0 ignored issues – show Documentation Bug introduced 2019-05-27 14:38 UTC by Report Bug Copy Issue Report Are you sure the doc-type for parameter `$date` is correct as it would always require `null` to be passed? Loading history...
116			* @return null \| String
117			*/
118			protected function checkDateFormat($date = null)
119			{
120			if (empty($date) \|\| $date == '0000-00-00') {
121			return null;
122			}
123			if ($date instanceof \DateTime) {
124			return $date->format('Y-m-d');
125			}
126			try {
127			$dateTime = new \DateTime(trim($date));
128			$today = new \DateTime('tomorrow');
129			if ($dateTime >= $today) {
130			return null;
131			}
132			return $dateTime->format('Y-m-d');
133			} catch (\Exception $exception) {
134			return null;
135			}
136			}
137
138			}
139

pagantis / orders-api-client

AbstractModel::parseValue() C last analyzed 2020-11-06 09:32 UTC

Complexity

Size

Duplication

Importance

How to fix Complexity

Long Method

Duplication Side-by-Side

Filter issues like

AbstractModel::parseValue() C
last analyzed 2020-11-06 09:32 UTC