GoogleMaps::updateAddressComponent() - Code Metrics - Inspection of "[Fix] NominatimProvider: do not throw error when c..." - geocoder-php/Geocoder - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 691675...503bab )

by Tobias

created 2017-09-16 09:32 UTC

GoogleMaps::updateAddressComponent() D

↳ Parent: GoogleMaps

Complexity

Conditions	31
Paths	31

Size

Total Lines	79
Code Lines	57

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
c	0
b	0
f	0
dl	0
loc	79
rs	4.9882
cc	31
eloc	57
nc	31
nop	3

How to fix Long Method Complexity

<?php

declare(strict_types=1);

/*
 * This file is part of the Geocoder package.
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * @license    MIT License
 */

namespace Geocoder\Provider\GoogleMaps;

use Geocoder\Collection;
use Geocoder\Exception\InvalidCredentials;
use Geocoder\Exception\InvalidServerResponse;
use Geocoder\Exception\QuotaExceeded;
use Geocoder\Exception\UnsupportedOperation;
use Geocoder\Model\AddressCollection;
use Geocoder\Model\AddressBuilder;
use Geocoder\Query\GeocodeQuery;
use Geocoder\Query\ReverseQuery;
use Geocoder\Http\Provider\AbstractHttpProvider;
use Geocoder\Provider\GoogleMaps\Model\GoogleAddress;
use Geocoder\Provider\Provider;
use Http\Client\HttpClient;

/**
 * @author William Durand <[email protected]>
 */
final class GoogleMaps extends AbstractHttpProvider implements Provider
{
    /**
     * @var string
     */
    const GEOCODE_ENDPOINT_URL_SSL = 'https://maps.googleapis.com/maps/api/geocode/json?address=%s';

    /**
     * @var string
     */
    const REVERSE_ENDPOINT_URL_SSL = 'https://maps.googleapis.com/maps/api/geocode/json?latlng=%F,%F';

    /**
     * @var string|null
     */
    private $region;

    /**
     * @var string|null
     */
    private $apiKey;

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

    /**
     * @var string|null
     */
    private $privateKey;

    /**
     * Google Maps for Business
     * https://developers.google.com/maps/documentation/business/.
     *
     * @param HttpClient $client     An HTTP adapter
     * @param string     $clientId   Your Client ID
     * @param string     $privateKey Your Private Key (optional)

     * @param string     $region     Region biasing (optional)

     * @param string     $apiKey     Google Geocoding API key (optional)

     *
     * @return GoogleMaps
     */
    public static function business(HttpClient $client, string  $clientId, string $privateKey = null, string $region = null, string $apiKey = null)
    {
        $provider = new self($client, $region, $apiKey);
        $provider->clientId = $clientId;
        $provider->privateKey = $privateKey;

        return $provider;
    }

    /**
     * @param HttpClient $client An HTTP adapter
     * @param string     $region Region biasing (optional)

     * @param string     $apiKey Google Geocoding API key (optional)

     */
    public function __construct(HttpClient $client, string $region = null, string $apiKey = null)
    {
        parent::__construct($client);

        $this->region = $region;
        $this->apiKey = $apiKey;
    }

    public function geocodeQuery(GeocodeQuery $query): Collection
    {
        // Google API returns invalid data if IP address given
        // This API doesn't handle IPs
        if (filter_var($query->getText(), FILTER_VALIDATE_IP)) {
            throw new UnsupportedOperation('The GoogleMaps provider does not support IP addresses, only street addresses.');
        }

        $url = sprintf(self::GEOCODE_ENDPOINT_URL_SSL, rawurlencode($query->getText()));
        if (null !== $bounds = $query->getBounds()) {
            $url .= sprintf('&bounds=%s,%s|%s,%s', $bounds->getSouth(), $bounds->getWest(), $bounds->getNorth(), $bounds->getEast());
        }

        return $this->fetchUrl($url, $query->getLocale(), $query->getLimit(), $query->getData('region', $this->region));
    }

    public function reverseQuery(ReverseQuery $query): Collection
    {
        $coordinate = $query->getCoordinates();
        $url = sprintf(self::REVERSE_ENDPOINT_URL_SSL, $coordinate->getLatitude(), $coordinate->getLongitude());

        if (null !== $locationType = $query->getData('location_type')) {
            $url .= '&location_type='.urlencode($locationType);
        }

        if (null !== $resultType = $query->getData('result_type')) {
            $url .= '&result_type='.urlencode($resultType);
        }

        return $this->fetchUrl($url, $query->getLocale(), $query->getLimit(), $query->getData('region', $this->region));
    }

    /**
     * {@inheritdoc}
     */
    public function getName(): string
    {
        return 'google_maps';
    }

    /**
     * @param string $url
     * @param string $locale

     *
     * @return string query with extra params
     */
    private function buildQuery(string $url, string $locale = null, string $region = null)
    {
        if (null !== $locale) {
            $url = sprintf('%s&language=%s', $url, $locale);
        }

        if (null !== $region) {
            $url = sprintf('%s&region=%s', $url, $region);
        }

        if (null !== $this->apiKey) {
            $url = sprintf('%s&key=%s', $url, $this->apiKey);
        }

        if (null !== $this->clientId) {
            $url = sprintf('%s&client=%s', $url, $this->clientId);

            if (null !== $this->privateKey) {
                $url = $this->signQuery($url);
            }
        }

        return $url;
    }

    /**
     * @param string $url
     * @param string $locale

     * @param int    $limit
     * @param string $region

     *
     * @return AddressCollection
     *
     * @throws InvalidServerResponse
     * @throws InvalidCredentials
     */
    private function fetchUrl(string $url, string $locale = null, int $limit, string $region = null): AddressCollection
    {
        $url = $this->buildQuery($url, $locale, $region);
        $content = $this->getUrlContents($url);
        $json = $this->validateResponse($url, $content);

        // no result
        if (!isset($json->results) || !count($json->results) || 'OK' !== $json->status) {
            return new AddressCollection([]);
        }

        $results = [];
        foreach ($json->results as $result) {
            $builder = new AddressBuilder($this->getName());
            $this->parseCoordinates($builder, $result);

            // set official Google place id
            if (isset($result->place_id)) {
                $builder->setValue('id', $result->place_id);
            }

            // update address components
            foreach ($result->address_components as $component) {
                foreach ($component->types as $type) {
                    $this->updateAddressComponent($builder, $type, $component);
                }
            }

            /** @var GoogleAddress $address */
            $address = $builder->build(GoogleAddress::class);
            $address = $address->withId($builder->getValue('id'));
            if (isset($result->geometry->location_type)) {
                $address = $address->withLocationType($result->geometry->location_type);
            }
            if (isset($result->types)) {
                $address = $address->withResultType($result->types);
            }
            if (isset($result->formatted_address)) {
                $address = $address->withFormattedAddress($result->formatted_address);
            }
            $address = $address->withStreetAddress($builder->getValue('street_address'));
            $address = $address->withIntersection($builder->getValue('intersection'));
            $address = $address->withPolitical($builder->getValue('political'));
            $address = $address->withColloquialArea($builder->getValue('colloquial_area'));
            $address = $address->withWard($builder->getValue('ward'));
            $address = $address->withNeighborhood($builder->getValue('neighborhood'));
            $address = $address->withPremise($builder->getValue('premise'));
            $address = $address->withSubpremise($builder->getValue('subpremise'));
            $address = $address->withNaturalFeature($builder->getValue('natural_feature'));
            $address = $address->withAirport($builder->getValue('airport'));
            $address = $address->withPark($builder->getValue('park'));
            $address = $address->withPointOfInterest($builder->getValue('point_of_interest'));
            $address = $address->withEstablishment($builder->getValue('establishment'));
            $address = $address->withSubLocalityLevels($builder->getValue('subLocalityLevel', []));
            $results[] = $address;

            if (count($results) >= $limit) {
                break;
            }
        }

        return new AddressCollection($results);
    }

    /**
     * Update current resultSet with given key/value.
     *
     * @param AddressBuilder $builder
     * @param string         $type    Component type
     * @param object         $values  The component values
     */
    private function updateAddressComponent(AddressBuilder $builder, string $type, $values)
    {
        switch ($type) {
            case 'postal_code':
                $builder->setPostalCode($values->long_name);

                break;

            case 'locality':
            case 'postal_town':
                $builder->setLocality($values->long_name);

                break;

            case 'administrative_area_level_1':
            case 'administrative_area_level_2':
            case 'administrative_area_level_3':
            case 'administrative_area_level_4':
            case 'administrative_area_level_5':
                $builder->addAdminLevel(intval(substr($type, -1)), $values->long_name, $values->short_name);

                break;

            case 'sublocality_level_1':
            case 'sublocality_level_2':
            case 'sublocality_level_3':
            case 'sublocality_level_4':
            case 'sublocality_level_5':
                $subLocalityLevel = $builder->getValue('subLocalityLevel', []);
                $subLocalityLevel[] = [
                    'level' => intval(substr($type, -1)),
                    'name' => $values->long_name,
                    'code' => $values->short_name,
                ];
                $builder->setValue('subLocalityLevel', $subLocalityLevel);

                break;

            case 'country':
                $builder->setCountry($values->long_name);
                $builder->setCountryCode($values->short_name);

                break;

            case 'street_number':
                $builder->setStreetNumber($values->long_name);

                break;

            case 'route':
                $builder->setStreetName($values->long_name);

                break;

            case 'sublocality':
                $builder->setSubLocality($values->long_name);

                break;

            case 'street_address':
            case 'intersection':
            case 'political':
            case 'colloquial_area':
            case 'ward':
            case 'neighborhood':
            case 'premise':
            case 'subpremise':
            case 'natural_feature':
            case 'airport':
            case 'park':
            case 'point_of_interest':
            case 'establishment':
                $builder->setValue($type, $values->long_name);

                break;

            default:
        }
    }

    /**
     * Sign a URL with a given crypto key
     * Note that this URL must be properly URL-encoded
     * src: http://gmaps-samples.googlecode.com/svn/trunk/urlsigning/UrlSigner.php-source.
     *
     * @param string $query Query to be signed
     *
     * @return string $query query with signature appended
     */
    private function signQuery(string $query): string
    {
        $url = parse_url($query);

        $urlPartToSign = $url['path'].'?'.$url['query'];

        // Decode the private key into its binary format
        $decodedKey = base64_decode(str_replace(['-', '_'], ['+', '/'], $this->privateKey));

        // Create a signature using the private key and the URL-encoded
        // string using HMAC SHA1. This signature will be binary.
        $signature = hash_hmac('sha1', $urlPartToSign, $decodedKey, true);

        $encodedSignature = str_replace(['+', '/'], ['-', '_'], base64_encode($signature));

        return sprintf('%s&signature=%s', $query, $encodedSignature);
    }

    /**
     * Decode the response content and validate it to make sure it does not have any errors.
     *
     * @param string $url
     * @param string $content
     *
     * @return mixed result form json_decode()
     *
     * @throws InvalidCredentials
     * @throws InvalidServerResponse
     * @throws QuotaExceeded
     */
    private function validateResponse(string $url, $content)
    {
        // Throw exception if invalid clientID and/or privateKey used with GoogleMapsBusinessProvider
        if (strpos($content, "Provided 'signature' is not valid for the provided client ID") !== false) {
            throw new InvalidCredentials(sprintf('Invalid client ID / API Key %s', $url));
        }

        $json = json_decode($content);

        // API error
        if (!isset($json)) {
            throw InvalidServerResponse::create($url);
        }

        if ('REQUEST_DENIED' === $json->status && 'The provided API key is invalid.' === $json->error_message) {
            throw new InvalidCredentials(sprintf('API key is invalid %s', $url));
        }

        if ('REQUEST_DENIED' === $json->status) {
            throw new InvalidServerResponse(
                sprintf('API access denied. Request: %s - Message: %s', $url, $json->error_message)
            );
        }

        // you are over your quota
        if ('OVER_QUERY_LIMIT' === $json->status) {
            throw new QuotaExceeded(sprintf('Daily quota exceeded %s', $url));
        }

        return $json;
    }

    /**
     * Parse coordinats and bounds.
     *
     * @param AddressBuilder $builder
     * @param $result
     */
    private function parseCoordinates(AddressBuilder $builder, $result)
    {
        $coordinates = $result->geometry->location;
        $builder->setCoordinates($coordinates->lat, $coordinates->lng);

        if (isset($result->geometry->bounds)) {
            $builder->setBounds(
                $result->geometry->bounds->southwest->lat,
                $result->geometry->bounds->southwest->lng,
                $result->geometry->bounds->northeast->lat,
                $result->geometry->bounds->northeast->lng
            );
        } elseif (isset($result->geometry->viewport)) {
            $builder->setBounds(
                $result->geometry->viewport->southwest->lat,
                $result->geometry->viewport->southwest->lng,
                $result->geometry->viewport->northeast->lat,
                $result->geometry->viewport->northeast->lng
            );
        } elseif ('ROOFTOP' === $result->geometry->location_type) {
            // Fake bounds
            $builder->setBounds(
                $coordinates->lat,
                $coordinates->lng,
                $coordinates->lat,
                $coordinates->lng
            );
        }
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			/*
6			* This file is part of the Geocoder package.
7			* For the full copyright and license information, please view the LICENSE
8			* file that was distributed with this source code.
9			*
10			* @license MIT License
11			*/
12
13			namespace Geocoder\Provider\GoogleMaps;
14
15			use Geocoder\Collection;
16			use Geocoder\Exception\InvalidCredentials;
17			use Geocoder\Exception\InvalidServerResponse;
18			use Geocoder\Exception\QuotaExceeded;
19			use Geocoder\Exception\UnsupportedOperation;
20			use Geocoder\Model\AddressCollection;
21			use Geocoder\Model\AddressBuilder;
22			use Geocoder\Query\GeocodeQuery;
23			use Geocoder\Query\ReverseQuery;
24			use Geocoder\Http\Provider\AbstractHttpProvider;
25			use Geocoder\Provider\GoogleMaps\Model\GoogleAddress;
26			use Geocoder\Provider\Provider;
27			use Http\Client\HttpClient;
28
29			/**
30			* @author William Durand <[email protected]>
31			*/
32			final class GoogleMaps extends AbstractHttpProvider implements Provider
33			{
34			/**
35			* @var string
36			*/
37			const GEOCODE_ENDPOINT_URL_SSL = 'https://maps.googleapis.com/maps/api/geocode/json?address=%s';
38
39			/**
40			* @var string
41			*/
42			const REVERSE_ENDPOINT_URL_SSL = 'https://maps.googleapis.com/maps/api/geocode/json?latlng=%F,%F';
43
44			/**
45			* @var string\|null
46			*/
47			private $region;
48
49			/**
50			* @var string\|null
51			*/
52			private $apiKey;
53
54			/**
55			* @var string
56			*/
57			private $clientId;
58
59			/**
60			* @var string\|null
61			*/
62			private $privateKey;
63
64			/**
65			* Google Maps for Business
66			* https://developers.google.com/maps/documentation/business/.
67			*
68			* @param HttpClient $client An HTTP adapter
69			* @param string $clientId Your Client ID
70			* @param string $privateKey Your Private Key (optional)
			0 ignored issues – show Documentation introduced 2017-06-17 08:56 UTC by Report Bug Copy Issue Report Should the type for parameter `$privateKey` not be `null\|string`? This check looks for `@param` annotations where the type inferred by our type inference engine differs from the declared type. It makes a suggestion as to what type it considers more descriptive. Most often this is a case of a parameter that can be null in addition to its declared types. Loading history...
71			* @param string $region Region biasing (optional)
			0 ignored issues – show Documentation introduced 2017-06-17 08:56 UTC by Report Bug Copy Issue Report Should the type for parameter `$region` not be `null\|string`? This check looks for `@param` annotations where the type inferred by our type inference engine differs from the declared type. It makes a suggestion as to what type it considers more descriptive. Most often this is a case of a parameter that can be null in addition to its declared types. Loading history...
72			* @param string $apiKey Google Geocoding API key (optional)
			0 ignored issues – show Documentation introduced 2017-06-17 08:56 UTC by Report Bug Copy Issue Report Should the type for parameter `$apiKey` not be `null\|string`? This check looks for `@param` annotations where the type inferred by our type inference engine differs from the declared type. It makes a suggestion as to what type it considers more descriptive. Most often this is a case of a parameter that can be null in addition to its declared types. Loading history...
73			*
74			* @return GoogleMaps
75			*/
76			public static function business(HttpClient $client, string $clientId, string $privateKey = null, string $region = null, string $apiKey = null)
77			{
78			$provider = new self($client, $region, $apiKey);
79			$provider->clientId = $clientId;
80			$provider->privateKey = $privateKey;
81
82			return $provider;
83			}
84
85			/**
86			* @param HttpClient $client An HTTP adapter
87			* @param string $region Region biasing (optional)
			0 ignored issues – show Documentation introduced 2017-06-17 08:56 UTC by Report Bug Copy Issue Report Should the type for parameter `$region` not be `null\|string`? This check looks for `@param` annotations where the type inferred by our type inference engine differs from the declared type. It makes a suggestion as to what type it considers more descriptive. Most often this is a case of a parameter that can be null in addition to its declared types. Loading history...
88			* @param string $apiKey Google Geocoding API key (optional)
			0 ignored issues – show Documentation introduced 2017-06-17 08:56 UTC by Report Bug Copy Issue Report Should the type for parameter `$apiKey` not be `null\|string`? This check looks for `@param` annotations where the type inferred by our type inference engine differs from the declared type. It makes a suggestion as to what type it considers more descriptive. Most often this is a case of a parameter that can be null in addition to its declared types. Loading history...
89			*/
90			public function __construct(HttpClient $client, string $region = null, string $apiKey = null)
91			{
92			parent::__construct($client);
93
94			$this->region = $region;
95			$this->apiKey = $apiKey;
96			}
97
98			public function geocodeQuery(GeocodeQuery $query): Collection
99			{
100			// Google API returns invalid data if IP address given
101			// This API doesn't handle IPs
102			if (filter_var($query->getText(), FILTER_VALIDATE_IP)) {
103			throw new UnsupportedOperation('The GoogleMaps provider does not support IP addresses, only street addresses.');
104			}
105
106			$url = sprintf(self::GEOCODE_ENDPOINT_URL_SSL, rawurlencode($query->getText()));
107			if (null !== $bounds = $query->getBounds()) {
108			$url .= sprintf('&bounds=%s,%s\|%s,%s', $bounds->getSouth(), $bounds->getWest(), $bounds->getNorth(), $bounds->getEast());
109			}
110
111			return $this->fetchUrl($url, $query->getLocale(), $query->getLimit(), $query->getData('region', $this->region));
112			}
113
114			public function reverseQuery(ReverseQuery $query): Collection
115			{
116			$coordinate = $query->getCoordinates();
117			$url = sprintf(self::REVERSE_ENDPOINT_URL_SSL, $coordinate->getLatitude(), $coordinate->getLongitude());
118
119			if (null !== $locationType = $query->getData('location_type')) {
120			$url .= '&location_type='.urlencode($locationType);
121			}
122
123			if (null !== $resultType = $query->getData('result_type')) {
124			$url .= '&result_type='.urlencode($resultType);
125			}
126
127			return $this->fetchUrl($url, $query->getLocale(), $query->getLimit(), $query->getData('region', $this->region));
128			}
129
130			/**
131			* {@inheritdoc}
132			*/
133			public function getName(): string
134			{
135			return 'google_maps';
136			}
137
138			/**
139			* @param string $url
140			* @param string $locale
			0 ignored issues – show Documentation introduced 2017-06-17 08:56 UTC by Report Bug Copy Issue Report Should the type for parameter `$locale` not be `null\|string`? This check looks for `@param` annotations where the type inferred by our type inference engine differs from the declared type. It makes a suggestion as to what type it considers more descriptive. Most often this is a case of a parameter that can be null in addition to its declared types. Loading history...
141			*
142			* @return string query with extra params
143			*/
144			private function buildQuery(string $url, string $locale = null, string $region = null)
145			{
146			if (null !== $locale) {
147			$url = sprintf('%s&language=%s', $url, $locale);
148			}
149
150			if (null !== $region) {
151			$url = sprintf('%s&region=%s', $url, $region);
152			}
153
154			if (null !== $this->apiKey) {
155			$url = sprintf('%s&key=%s', $url, $this->apiKey);
156			}
157
158			if (null !== $this->clientId) {
159			$url = sprintf('%s&client=%s', $url, $this->clientId);
160
161			if (null !== $this->privateKey) {
162			$url = $this->signQuery($url);
163			}
164			}
165
166			return $url;
167			}
168
169			/**
170			* @param string $url
171			* @param string $locale
			0 ignored issues – show Documentation introduced 2017-06-17 08:56 UTC by Report Bug Copy Issue Report Should the type for parameter `$locale` not be `null\|string`? This check looks for `@param` annotations where the type inferred by our type inference engine differs from the declared type. It makes a suggestion as to what type it considers more descriptive. Most often this is a case of a parameter that can be null in addition to its declared types. Loading history...
172			* @param int $limit
173			* @param string $region
			0 ignored issues – show Documentation introduced 2017-06-17 08:56 UTC by Report Bug Copy Issue Report Should the type for parameter `$region` not be `null\|string`? This check looks for `@param` annotations where the type inferred by our type inference engine differs from the declared type. It makes a suggestion as to what type it considers more descriptive. Most often this is a case of a parameter that can be null in addition to its declared types. Loading history...
174			*
175			* @return AddressCollection
176			*
177			* @throws InvalidServerResponse
178			* @throws InvalidCredentials
179			*/
180			private function fetchUrl(string $url, string $locale = null, int $limit, string $region = null): AddressCollection
181			{
182			$url = $this->buildQuery($url, $locale, $region);
183			$content = $this->getUrlContents($url);
184			$json = $this->validateResponse($url, $content);
185
186			// no result
187			if (!isset($json->results) \|\| !count($json->results) \|\| 'OK' !== $json->status) {
188			return new AddressCollection([]);
189			}
190
191			$results = [];
192			foreach ($json->results as $result) {
193			$builder = new AddressBuilder($this->getName());
194			$this->parseCoordinates($builder, $result);
195
196			// set official Google place id
197			if (isset($result->place_id)) {
198			$builder->setValue('id', $result->place_id);
199			}
200
201			// update address components
202			foreach ($result->address_components as $component) {
203			foreach ($component->types as $type) {
204			$this->updateAddressComponent($builder, $type, $component);
205			}
206			}
207
208			/** @var GoogleAddress $address */
209			$address = $builder->build(GoogleAddress::class);
210			$address = $address->withId($builder->getValue('id'));
211			if (isset($result->geometry->location_type)) {
212			$address = $address->withLocationType($result->geometry->location_type);
213			}
214			if (isset($result->types)) {
215			$address = $address->withResultType($result->types);
216			}
217			if (isset($result->formatted_address)) {
218			$address = $address->withFormattedAddress($result->formatted_address);
219			}
220			$address = $address->withStreetAddress($builder->getValue('street_address'));
221			$address = $address->withIntersection($builder->getValue('intersection'));
222			$address = $address->withPolitical($builder->getValue('political'));
223			$address = $address->withColloquialArea($builder->getValue('colloquial_area'));
224			$address = $address->withWard($builder->getValue('ward'));
225			$address = $address->withNeighborhood($builder->getValue('neighborhood'));
226			$address = $address->withPremise($builder->getValue('premise'));
227			$address = $address->withSubpremise($builder->getValue('subpremise'));
228			$address = $address->withNaturalFeature($builder->getValue('natural_feature'));
229			$address = $address->withAirport($builder->getValue('airport'));
230			$address = $address->withPark($builder->getValue('park'));
231			$address = $address->withPointOfInterest($builder->getValue('point_of_interest'));
232			$address = $address->withEstablishment($builder->getValue('establishment'));
233			$address = $address->withSubLocalityLevels($builder->getValue('subLocalityLevel', []));
234			$results[] = $address;
235
236			if (count($results) >= $limit) {
237			break;
238			}
239			}
240
241			return new AddressCollection($results);
242			}
243
244			/**
245			* Update current resultSet with given key/value.
246			*
247			* @param AddressBuilder $builder
248			* @param string $type Component type
249			* @param object $values The component values
250			*/
251			private function updateAddressComponent(AddressBuilder $builder, string $type, $values)
252			{
253			switch ($type) {
254			case 'postal_code':
255			$builder->setPostalCode($values->long_name);
256
257			break;
258
259			case 'locality':
260			case 'postal_town':
261			$builder->setLocality($values->long_name);
262
263			break;
264
265			case 'administrative_area_level_1':
266			case 'administrative_area_level_2':
267			case 'administrative_area_level_3':
268			case 'administrative_area_level_4':
269			case 'administrative_area_level_5':
270			$builder->addAdminLevel(intval(substr($type, -1)), $values->long_name, $values->short_name);
271
272			break;
273
274			case 'sublocality_level_1':
275			case 'sublocality_level_2':
276			case 'sublocality_level_3':
277			case 'sublocality_level_4':
278			case 'sublocality_level_5':
279			$subLocalityLevel = $builder->getValue('subLocalityLevel', []);
280			$subLocalityLevel[] = [
281			'level' => intval(substr($type, -1)),
282			'name' => $values->long_name,
283			'code' => $values->short_name,
284			];
285			$builder->setValue('subLocalityLevel', $subLocalityLevel);
286
287			break;
288
289			case 'country':
290			$builder->setCountry($values->long_name);
291			$builder->setCountryCode($values->short_name);
292
293			break;
294
295			case 'street_number':
296			$builder->setStreetNumber($values->long_name);
297
298			break;
299
300			case 'route':
301			$builder->setStreetName($values->long_name);
302
303			break;
304
305			case 'sublocality':
306			$builder->setSubLocality($values->long_name);
307
308			break;
309
310			case 'street_address':
311			case 'intersection':
312			case 'political':
313			case 'colloquial_area':
314			case 'ward':
315			case 'neighborhood':
316			case 'premise':
317			case 'subpremise':
318			case 'natural_feature':
319			case 'airport':
320			case 'park':
321			case 'point_of_interest':
322			case 'establishment':
323			$builder->setValue($type, $values->long_name);
324
325			break;
326
327			default:
328			}
329			}
330
331			/**
332			* Sign a URL with a given crypto key
333			* Note that this URL must be properly URL-encoded
334			* src: http://gmaps-samples.googlecode.com/svn/trunk/urlsigning/UrlSigner.php-source.
335			*
336			* @param string $query Query to be signed
337			*
338			* @return string $query query with signature appended
339			*/
340			private function signQuery(string $query): string
341			{
342			$url = parse_url($query);
343
344			$urlPartToSign = $url['path'].'?'.$url['query'];
345
346			// Decode the private key into its binary format
347			$decodedKey = base64_decode(str_replace(['-', '_'], ['+', '/'], $this->privateKey));
348
349			// Create a signature using the private key and the URL-encoded
350			// string using HMAC SHA1. This signature will be binary.
351			$signature = hash_hmac('sha1', $urlPartToSign, $decodedKey, true);
352
353			$encodedSignature = str_replace(['+', '/'], ['-', '_'], base64_encode($signature));
354
355			return sprintf('%s&signature=%s', $query, $encodedSignature);
356			}
357
358			/**
359			* Decode the response content and validate it to make sure it does not have any errors.
360			*
361			* @param string $url
362			* @param string $content
363			*
364			* @return mixed result form json_decode()
365			*
366			* @throws InvalidCredentials
367			* @throws InvalidServerResponse
368			* @throws QuotaExceeded
369			*/
370			private function validateResponse(string $url, $content)
371			{
372			// Throw exception if invalid clientID and/or privateKey used with GoogleMapsBusinessProvider
373			if (strpos($content, "Provided 'signature' is not valid for the provided client ID") !== false) {
374			throw new InvalidCredentials(sprintf('Invalid client ID / API Key %s', $url));
375			}
376
377			$json = json_decode($content);
378
379			// API error
380			if (!isset($json)) {
381			throw InvalidServerResponse::create($url);
382			}
383
384			if ('REQUEST_DENIED' === $json->status && 'The provided API key is invalid.' === $json->error_message) {
385			throw new InvalidCredentials(sprintf('API key is invalid %s', $url));
386			}
387
388			if ('REQUEST_DENIED' === $json->status) {
389			throw new InvalidServerResponse(
390			sprintf('API access denied. Request: %s - Message: %s', $url, $json->error_message)
391			);
392			}
393
394			// you are over your quota
395			if ('OVER_QUERY_LIMIT' === $json->status) {
396			throw new QuotaExceeded(sprintf('Daily quota exceeded %s', $url));
397			}
398
399			return $json;
400			}
401
402			/**
403			* Parse coordinats and bounds.
404			*
405			* @param AddressBuilder $builder
406			* @param $result
407			*/
408			private function parseCoordinates(AddressBuilder $builder, $result)
409			{
410			$coordinates = $result->geometry->location;
411			$builder->setCoordinates($coordinates->lat, $coordinates->lng);
412
413			if (isset($result->geometry->bounds)) {
414			$builder->setBounds(
415			$result->geometry->bounds->southwest->lat,
416			$result->geometry->bounds->southwest->lng,
417			$result->geometry->bounds->northeast->lat,
418			$result->geometry->bounds->northeast->lng
419			);
420			} elseif (isset($result->geometry->viewport)) {
421			$builder->setBounds(
422			$result->geometry->viewport->southwest->lat,
423			$result->geometry->viewport->southwest->lng,
424			$result->geometry->viewport->northeast->lat,
425			$result->geometry->viewport->northeast->lng
426			);
427			} elseif ('ROOFTOP' === $result->geometry->location_type) {
428			// Fake bounds
429			$builder->setBounds(
430			$coordinates->lat,
431			$coordinates->lng,
432			$coordinates->lat,
433			$coordinates->lng
434			);
435			}
436			}
437			}
438

geocoder-php / Geocoder

GitHub Access Token became invalid

Push — master ( 691675...503bab )

GoogleMaps::updateAddressComponent() D

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like