AbstractResponse::populateDto() - Code Metrics - Sf4/Api - Measure and Improve Code Quality continuously with Scrutinizer

AbstractResponse::populateDto() A
last analyzed 2019-04-05 06:55 UTC

↳ Parent: AbstractResponse

Complexity

Conditions	3
Paths	3

Size

Total Lines	10
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	3
eloc	6
nc	3
nop	2
dl	0
loc	10
rs	10
c	0
b	0
f	0

<?php
/**
 * Created by PhpStorm.
 * User: siim
 * Date: 17.01.19
 * Time: 9:19
 */

namespace Sf4\Api\Response;

use ReflectionException;
use Sf4\Api\Dto\DtoInterface;
use Sf4\Api\Dto\Response\EmptyDto;
use Sf4\Api\Dto\Response\ErrorDto;
use Sf4\Api\Dto\Traits\CreateErrorDtoTrait;
use Sf4\Api\Dto\Traits\DtoTrait;
use Sf4\Api\Repository\AbstractRepository;
use Sf4\Api\Repository\RepositoryInterface;
use Sf4\Api\Request\RequestTrait;
use Sf4\Api\RequestHandler\RequestHandlerInterface;
use Sf4\Api\Utils\Traits\TranslatorTrait;
use Symfony\Component\HttpFoundation\JsonResponse;

abstract class AbstractResponse implements ResponseInterface
{

    use DtoTrait;
    use RequestTrait;
    use CreateErrorDtoTrait;
    use TranslatorTrait;

    /** @var DtoInterface $responseDto */
    protected $responseDto;

    /** @var int $responseStatus */
    protected $responseStatus;

    /** @var array $responseHeaders */
    protected $responseHeaders;

    /** @var JsonResponse $jsonResponse */
    protected $jsonResponse;

    public function __construct()
    {
        $this->addTranslator();
        $this->createJsonResponse(new EmptyDto(), 200, static::HEADERS);
    }

    protected function addTranslator(): void
    {
        $requestHandler = $this->getRequestHandler();
        if ($requestHandler) {
            $translator = $requestHandler->getTranslator();
            $this->setTranslator($translator);
        }
    }

    /**
     * @return RequestHandlerInterface|null
     */
    public function getRequestHandler(): ?RequestHandlerInterface
    {
        $request = $this->getRequest();
        if ($request) {
            return $request->getRequestHandler();
        }

        return null;
    }

    /**
     * @param DtoInterface $data
     * @param int $status
     * @param array $headers
     */
    protected function createJsonResponse(DtoInterface $data, int $status = 200, array $headers = self::HEADERS): void
    {
        $this->setResponseDto($data);
        $this->setResponseStatus($status);
        $this->setResponseHeaders($headers);
    }

    abstract public function init();

    /**
     * @return JsonResponse
     */
    public function getJsonResponse(): JsonResponse
    {
        if (!$this->jsonResponse) {
            $response = new JsonResponse(
                $this->getResponseDto()->toArray(),
                $this->getResponseStatus(),
                $this->getResponseHeaders()
            );
        } else {
            $response = $this->jsonResponse;
        }
        $request = $this->getRequest();
        if ($request) {
            $httpRequest = $request->getRequest();
            if ($httpRequest) {
                $response->headers->set(
                    'Access-Control-Allow-Origin',
                    $httpRequest->headers->get('Origin')
                );
            }
        }
        return $response;
    }

    /**
     * @param JsonResponse $jsonResponse
     */
    public function setJsonResponse(JsonResponse $jsonResponse)
    {
        $this->jsonResponse = $jsonResponse;
    }

    /**
     * @return DtoInterface
     */
    public function getResponseDto(): DtoInterface
    {
        return $this->responseDto;
    }

    /**
     * @param DtoInterface $responseDto
     */
    public function setResponseDto(DtoInterface $responseDto): void
    {
        $this->responseDto = $responseDto;
    }

    /**
     * @return int
     */
    public function getResponseStatus(): int
    {
        return $this->responseStatus;
    }

    /**
     * @param int $responseStatus
     */
    public function setResponseStatus($responseStatus): void
    {
        $this->responseStatus = $responseStatus;
    }

    /**
     * @return array
     */
    public function getResponseHeaders(): array
    {
        return $this->responseHeaders;
    }

    /**
     * @param array $responseHeaders
     */
    public function setResponseHeaders(array $responseHeaders): void
    {
        $this->responseHeaders = $responseHeaders;
    }

    /**
     * @param string $tableName
     * @return AbstractRepository|null
     */
    public function getRepository(string $tableName): ?RepositoryInterface
    {
        $requestHandler = $this->getRequestHandler();
        if ($requestHandler) {
            $repositoryFactory = $requestHandler->getRepositoryFactory();
            return $repositoryFactory->create($tableName);
        }

        return null;
    }

    /**
     * @param DtoInterface $dto
     * @param array $data |null
     * @return DtoInterface|ErrorDto
     */
    protected function populateDto(DtoInterface $dto, ?array $data)
    {
        if ($data) {

            try {
                $dto->populate($data);
            } catch (ReflectionException $e) {
                $dto = $this->createErrorDto($e);
            }
        }
        return $dto;
    }
}


1			<?php
2			/**
3			* Created by PhpStorm.
4			* User: siim
5			* Date: 17.01.19
6			* Time: 9:19
7			*/
8
9			namespace Sf4\Api\Response;
10
11			use ReflectionException;
12			use Sf4\Api\Dto\DtoInterface;
13			use Sf4\Api\Dto\Response\EmptyDto;
14			use Sf4\Api\Dto\Response\ErrorDto;
15			use Sf4\Api\Dto\Traits\CreateErrorDtoTrait;
16			use Sf4\Api\Dto\Traits\DtoTrait;
17			use Sf4\Api\Repository\AbstractRepository;
18			use Sf4\Api\Repository\RepositoryInterface;
19			use Sf4\Api\Request\RequestTrait;
20			use Sf4\Api\RequestHandler\RequestHandlerInterface;
21			use Sf4\Api\Utils\Traits\TranslatorTrait;
22			use Symfony\Component\HttpFoundation\JsonResponse;
23
24			abstract class AbstractResponse implements ResponseInterface
25			{
26
27			use DtoTrait;
28			use RequestTrait;
29			use CreateErrorDtoTrait;
30			use TranslatorTrait;
31
32			/** @var DtoInterface $responseDto */
33			protected $responseDto;
34
35			/** @var int $responseStatus */
36			protected $responseStatus;
37
38			/** @var array $responseHeaders */
39			protected $responseHeaders;
40
41			/** @var JsonResponse $jsonResponse */
42			protected $jsonResponse;
43
44			public function __construct()
45			{
46			$this->addTranslator();
47			$this->createJsonResponse(new EmptyDto(), 200, static::HEADERS);
48			}
49
50			protected function addTranslator(): void
51			{
52			$requestHandler = $this->getRequestHandler();
53			if ($requestHandler) {
54			$translator = $requestHandler->getTranslator();
55			$this->setTranslator($translator);
56			}
57			}
58
59			/**
60			* @return RequestHandlerInterface\|null
61			*/
62			public function getRequestHandler(): ?RequestHandlerInterface
63			{
64			$request = $this->getRequest();
65			if ($request) {
66			return $request->getRequestHandler();
67			}
68
69			return null;
70			}
71
72			/**
73			* @param DtoInterface $data
74			* @param int $status
75			* @param array $headers
76			*/
77			protected function createJsonResponse(DtoInterface $data, int $status = 200, array $headers = self::HEADERS): void
78			{
79			$this->setResponseDto($data);
80			$this->setResponseStatus($status);
81			$this->setResponseHeaders($headers);
82			}
83
84			abstract public function init();
85
86			/**
87			* @return JsonResponse
88			*/
89			public function getJsonResponse(): JsonResponse
90			{
91			if (!$this->jsonResponse) {
92			$response = new JsonResponse(
93			$this->getResponseDto()->toArray(),
94			$this->getResponseStatus(),
95			$this->getResponseHeaders()
96			);
97			} else {
98			$response = $this->jsonResponse;
99			}
100			$request = $this->getRequest();
101			if ($request) {
102			$httpRequest = $request->getRequest();
103			if ($httpRequest) {
104			$response->headers->set(
105			'Access-Control-Allow-Origin',
106			$httpRequest->headers->get('Origin')
107			);
108			}
109			}
110			return $response;
111			}
112
113			/**
114			* @param JsonResponse $jsonResponse
115			*/
116			public function setJsonResponse(JsonResponse $jsonResponse)
117			{
118			$this->jsonResponse = $jsonResponse;
119			}
120
121			/**
122			* @return DtoInterface
123			*/
124			public function getResponseDto(): DtoInterface
125			{
126			return $this->responseDto;
127			}
128
129			/**
130			* @param DtoInterface $responseDto
131			*/
132			public function setResponseDto(DtoInterface $responseDto): void
133			{
134			$this->responseDto = $responseDto;
135			}
136
137			/**
138			* @return int
139			*/
140			public function getResponseStatus(): int
141			{
142			return $this->responseStatus;
143			}
144
145			/**
146			* @param int $responseStatus
147			*/
148			public function setResponseStatus($responseStatus): void
149			{
150			$this->responseStatus = $responseStatus;
151			}
152
153			/**
154			* @return array
155			*/
156			public function getResponseHeaders(): array
157			{
158			return $this->responseHeaders;
159			}
160
161			/**
162			* @param array $responseHeaders
163			*/
164			public function setResponseHeaders(array $responseHeaders): void
165			{
166			$this->responseHeaders = $responseHeaders;
167			}
168
169			/**
170			* @param string $tableName
171			* @return AbstractRepository\|null
172			*/
173			public function getRepository(string $tableName): ?RepositoryInterface
174			{
175			$requestHandler = $this->getRequestHandler();
176			if ($requestHandler) {
177			$repositoryFactory = $requestHandler->getRepositoryFactory();
178			return $repositoryFactory->create($tableName);
179			}
180
181			return null;
182			}
183
184			/**
185			* @param DtoInterface $dto
186			* @param array $data \|null
187			* @return DtoInterface\|ErrorDto
188			*/
189			protected function populateDto(DtoInterface $dto, ?array $data)
190			{
191			if ($data) {
			0 ignored issues – show Bug Best Practice introduced 2019-01-24 14:59 UTC by Report Bug Copy Issue Report The expression `$data` of type `array` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `! empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
192			try {
193			$dto->populate($data);
194			} catch (ReflectionException $e) {
195			$dto = $this->createErrorDto($e);
196			}
197			}
198			return $dto;
199			}
200			}
201

Sf4 / Api

AbstractResponse::populateDto() A last analyzed 2019-04-05 06:55 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

AbstractResponse::populateDto() A
last analyzed 2019-04-05 06:55 UTC