GoogleMaps::serializeComponents() - Code Metrics - Inspection of "Add ability to specify component filters for Googl..." - geocoder-php/google-maps-provider - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( a21885...2cca59 )

by Tobias

created 2018-12-03 09:05 UTC

GoogleMaps::serializeComponents() A

↳ Parent: GoogleMaps

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	6
ccs	3
cts	3
cp	1
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	1
crap	1

<?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;

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

    /**
     * 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)
     * @param string     $channel    Google Channel parameter (optional)
     *
     * @return GoogleMaps
     */
    public static function business(HttpClient $client, string $clientId, string $privateKey = null, string $region = null, string $apiKey = null, string $channel = null)
    {
        $provider = new self($client, $region, $apiKey);
        $provider->clientId = $clientId;
        $provider->privateKey = $privateKey;
        $provider->channel = $channel;

        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());
        }

        if (null !== $components = $query->getData('components')) {
            $serializedComponents = is_string($components) ? $components : $this->serializeComponents($components);
            $url .= sprintf('&components=%s', urlencode($serializedComponents));
        }

        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): string
    {
        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->channel) {
                $url = sprintf('%s&channel=%s', $url, $this->channel);
            }

            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);
    }

    /**
     * Serialize the component query parameter.
     *
     * @param array $components
     *
     * @return string
     */
    private function serializeComponents(array $components): string
    {
        return implode('|', array_map(function ($name, $value) {
            return sprintf('%s:%s', $name, $value);
        }, array_keys($components), $components));
    }

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

geocoder-php / google-maps-provider

Push — master ( a21885...2cca59 )

GoogleMaps::serializeComponents() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like