AbstractRoutingQuery::getLanguage() - Code Metrics - Inspection of "Generalized language support across provider and f..." - DamienHarper/NavigationBundle - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 4b5c0b...5361e0 )

by Damien

created 2019-08-14 12:36 UTC

AbstractRoutingQuery::getLanguage() A

↳ Parent: AbstractRoutingQuery

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php

namespace DH\NavigationBundle\Contract\Routing;

use DH\NavigationBundle\Exception\ResponseException;
use DH\NavigationBundle\Exception\WaypointException;
use DH\NavigationBundle\Provider\ProviderInterface;
use Psr\Http\Message\ResponseInterface;

abstract class AbstractRoutingQuery implements RoutingQueryInterface
{
    /**
     * @var ProviderInterface
     */
    private $provider;

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

    /**
     * @var \DateTime
     */
    private $departure_time;

    /**
     * @var \DateTime
     */
    private $arrival_time;

    /**
     * @var string
     */
    private $language;

    /**
     * RoutingQuery constructor.
     *
     * @param ProviderInterface $provider
     */
    public function __construct(ProviderInterface $provider)
    {
        $this->provider = $provider;
    }

    public function getProvider(): ProviderInterface
    {
        return $this->provider;
    }

    /**
     * @return ?\DateTime
     */
    public function getDepartureTime(): ?\DateTime
    {
        return $this->departure_time;
    }

    /**
     * @param \DateTime $departureTime
     *
     * @return RoutingQueryInterface
     */
    public function setDepartureTime(\DateTime $departureTime): RoutingQueryInterface
    {
        $this->departure_time = $departureTime;

        return $this;
    }

    /**
     * @return ?\DateTime
     */
    public function getArrivalTime(): ?\DateTime
    {
        return $this->arrival_time;
    }

    /**
     * @param \DateTime $arrivalTime
     *
     * @return RoutingQueryInterface
     */
    public function setArrivalTime(\DateTime $arrivalTime): RoutingQueryInterface
    {
        $this->arrival_time = $arrivalTime;

        return $this;
    }

    /**
     * @param string $language
     *
     * @return RoutingQueryInterface
     */
    public function setLanguage(string $language): RoutingQueryInterface
    {
        $this->language = $language;

        return $this;
    }

    /**
     * @return string
     */
    public function getLanguage(): string
    {
        return $this->language ?? 'en-US';
    }

    /**
     * @param string $waypoint
     *
     * @return RoutingQueryInterface
     */
    public function addWaypoint($waypoint): RoutingQueryInterface
    {
        $this->waypoints[] = $waypoint;

        return $this;
    }

    /**
     * @return ?array
     */
    public function getWaypoints(): ?array
    {
        return $this->waypoints;
    }

    /**
     * @throws OriginException
     * @throws ResponseException
     * @throws WaypointException
     * @throws \GuzzleHttp\Exception\GuzzleException
     *
     * @return RoutingResponseInterface
     */
    public function execute(): RoutingResponseInterface
    {
        $this->validateRequest();
        $request = $this->buildRequest();
        $rawResponse = $this->request('GET', $request);
        $response = $this->buildResponse($rawResponse);
        $this->validateResponse($response);

        return $response;
    }

    /**
     * @return string
     */
    abstract protected function buildRequest(): string;

    /**
     * @param ResponseInterface $response
     *
     * @return RoutingResponseInterface
     */
    abstract protected function buildResponse(ResponseInterface $response): RoutingResponseInterface;

    /**
     * @param string $method
     * @param string $url
     *
     * @throws \GuzzleHttp\Exception\GuzzleException
     *
     * @return ResponseInterface
     */
    private function request(string $method, string $url): ResponseInterface
    {
        $client = $this->getProvider()->getClient();
        $response = $client->request($method, $url);

        if (200 !== $response->getStatusCode()) {
            throw new \Exception('Response with status code '.$response->getStatusCode());
        }

        return $response;
    }

    /**
     * @param DistanceMatrixResponseInterface $response
filter:
    dependency_paths: ["lib/*"]
     *
     * @throws ResponseException
     */
    private function validateResponse(RoutingResponseInterface $response): void
    {
        switch ($response->getStatus()) {
            case RoutingResponseInterface::RESPONSE_STATUS_OK:
                break;
            case RoutingResponseInterface::RESPONSE_STATUS_INVALID_REQUEST:
                throw new ResponseException('Invalid request.', 1);

                break;
            case RoutingResponseInterface::RESPONSE_STATUS_MAX_ELEMENTS_EXCEEDED:
                throw new ResponseException('The product of the origin and destination exceeds the limit per request.', 2);

                break;
            case RoutingResponseInterface::RESPONSE_STATUS_OVER_QUERY_LIMIT:
                throw new ResponseException('The service has received too many requests from your application in the allowed time range.', 3);

                break;
            case RoutingResponseInterface::RESPONSE_STATUS_REQUEST_DENIED:
                throw new ResponseException('The service denied the use of the Distance Matrix API service by your application.', 4);

                break;
            case RoutingResponseInterface::RESPONSE_STATUS_UNKNOWN_ERROR:
                throw new ResponseException('Unknown error.', 5);

                break;
            default:
                throw new ResponseException(sprintf('Unknown status code: %s', $response->getStatus()), 6);

                break;
        }
    }

    /**
     * @throws WaypointException
     */
    private function validateRequest(): void
    {
        if (empty($this->getWaypoints()) || \count($this->getWaypoints()) < 2) {
            throw new WaypointException('At least two waypoints must be set.');
        }

        if (null !== $this->getDepartureTime() && null !== $this->getArrivalTime()) {
            throw new WaypointException('departure_time and arrival_time cannot be both specified at the same time.');
        }
    }
}


1			<?php
2
3			namespace DH\NavigationBundle\Contract\Routing;
4
5			use DH\NavigationBundle\Exception\ResponseException;
6			use DH\NavigationBundle\Exception\WaypointException;
7			use DH\NavigationBundle\Provider\ProviderInterface;
8			use Psr\Http\Message\ResponseInterface;
9
10			abstract class AbstractRoutingQuery implements RoutingQueryInterface
11			{
12			/**
13			* @var ProviderInterface
14			*/
15			private $provider;
16
17			/**
18			* @var array
19			*/
20			protected $waypoints;
21
22			/**
23			* @var \DateTime
24			*/
25			private $departure_time;
26
27			/**
28			* @var \DateTime
29			*/
30			private $arrival_time;
31
32			/**
33			* @var string
34			*/
35			private $language;
36
37			/**
38			* RoutingQuery constructor.
39			*
40			* @param ProviderInterface $provider
41			*/
42			public function __construct(ProviderInterface $provider)
43			{
44			$this->provider = $provider;
45			}
46
47			public function getProvider(): ProviderInterface
48			{
49			return $this->provider;
50			}
51
52			/**
53			* @return ?\DateTime
54			*/
55			public function getDepartureTime(): ?\DateTime
56			{
57			return $this->departure_time;
58			}
59
60			/**
61			* @param \DateTime $departureTime
62			*
63			* @return RoutingQueryInterface
64			*/
65			public function setDepartureTime(\DateTime $departureTime): RoutingQueryInterface
66			{
67			$this->departure_time = $departureTime;
68
69			return $this;
70			}
71
72			/**
73			* @return ?\DateTime
74			*/
75			public function getArrivalTime(): ?\DateTime
76			{
77			return $this->arrival_time;
78			}
79
80			/**
81			* @param \DateTime $arrivalTime
82			*
83			* @return RoutingQueryInterface
84			*/
85			public function setArrivalTime(\DateTime $arrivalTime): RoutingQueryInterface
86			{
87			$this->arrival_time = $arrivalTime;
88
89			return $this;
90			}
91
92			/**
93			* @param string $language
94			*
95			* @return RoutingQueryInterface
96			*/
97			public function setLanguage(string $language): RoutingQueryInterface
98			{
99			$this->language = $language;
100
101			return $this;
102			}
103
104			/**
105			* @return string
106			*/
107			public function getLanguage(): string
108			{
109			return $this->language ?? 'en-US';
110			}
111
112			/**
113			* @param string $waypoint
114			*
115			* @return RoutingQueryInterface
116			*/
117			public function addWaypoint($waypoint): RoutingQueryInterface
118			{
119			$this->waypoints[] = $waypoint;
120
121			return $this;
122			}
123
124			/**
125			* @return ?array
126			*/
127			public function getWaypoints(): ?array
128			{
129			return $this->waypoints;
130			}
131
132			/**
133			* @throws OriginException
134			* @throws ResponseException
135			* @throws WaypointException
136			* @throws \GuzzleHttp\Exception\GuzzleException
137			*
138			* @return RoutingResponseInterface
139			*/
140			public function execute(): RoutingResponseInterface
141			{
142			$this->validateRequest();
143			$request = $this->buildRequest();
144			$rawResponse = $this->request('GET', $request);
145			$response = $this->buildResponse($rawResponse);
146			$this->validateResponse($response);
147
148			return $response;
149			}
150
151			/**
152			* @return string
153			*/
154			abstract protected function buildRequest(): string;
155
156			/**
157			* @param ResponseInterface $response
158			*
159			* @return RoutingResponseInterface
160			*/
161			abstract protected function buildResponse(ResponseInterface $response): RoutingResponseInterface;
162
163			/**
164			* @param string $method
165			* @param string $url
166			*
167			* @throws \GuzzleHttp\Exception\GuzzleException
168			*
169			* @return ResponseInterface
170			*/
171			private function request(string $method, string $url): ResponseInterface
172			{
173			$client = $this->getProvider()->getClient();
174			$response = $client->request($method, $url);
175
176			if (200 !== $response->getStatusCode()) {
177			throw new \Exception('Response with status code '.$response->getStatusCode());
178			}
179
180			return $response;
181			}
182
183			/**
184			* @param DistanceMatrixResponseInterface $response
			0 ignored issues – show Bug introduced 2019-08-13 16:38 UTC by Report Bug Copy Issue Report The type `DH\NavigationBundle\Cont...MatrixResponseInterface` 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...
185			*
186			* @throws ResponseException
187			*/
188			private function validateResponse(RoutingResponseInterface $response): void
189			{
190			switch ($response->getStatus()) {
191			case RoutingResponseInterface::RESPONSE_STATUS_OK:
192			break;
193			case RoutingResponseInterface::RESPONSE_STATUS_INVALID_REQUEST:
194			throw new ResponseException('Invalid request.', 1);
195
196			break;
197			case RoutingResponseInterface::RESPONSE_STATUS_MAX_ELEMENTS_EXCEEDED:
198			throw new ResponseException('The product of the origin and destination exceeds the limit per request.', 2);
199
200			break;
201			case RoutingResponseInterface::RESPONSE_STATUS_OVER_QUERY_LIMIT:
202			throw new ResponseException('The service has received too many requests from your application in the allowed time range.', 3);
203
204			break;
205			case RoutingResponseInterface::RESPONSE_STATUS_REQUEST_DENIED:
206			throw new ResponseException('The service denied the use of the Distance Matrix API service by your application.', 4);
207
208			break;
209			case RoutingResponseInterface::RESPONSE_STATUS_UNKNOWN_ERROR:
210			throw new ResponseException('Unknown error.', 5);
211
212			break;
213			default:
214			throw new ResponseException(sprintf('Unknown status code: %s', $response->getStatus()), 6);
215
216			break;
217			}
218			}
219
220			/**
221			* @throws WaypointException
222			*/
223			private function validateRequest(): void
224			{
225			if (empty($this->getWaypoints()) \|\| \count($this->getWaypoints()) < 2) {
226			throw new WaypointException('At least two waypoints must be set.');
227			}
228
229			if (null !== $this->getDepartureTime() && null !== $this->getArrivalTime()) {
230			throw new WaypointException('departure_time and arrival_time cannot be both specified at the same time.');
231			}
232			}
233			}
234

DamienHarper / NavigationBundle

Push — master ( 4b5c0b...5361e0 )

AbstractRoutingQuery::getLanguage() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like