repository.php

См. документацию.

<?php
 
namespace Bitrix\Location\Source\Google;
 
use Bitrix\Location\Entity\Location;
use Bitrix\Location\Entity\Generic\Collection;
use Bitrix\Location\Entity\Location\Parents;
use Bitrix\Location\Exception\RuntimeException;
use Bitrix\Location\Repository\Location\Capability\IFindByCoords;
use Bitrix\Location\Repository\Location\Capability\IFindByExternalId;
use Bitrix\Location\Repository\Location\Capability\IFindByText;
use Bitrix\Location\Repository\Location\Capability\IFindParents;
use Bitrix\Location\Repository\Location\IRepository;
use Bitrix\Location\Repository\Location\ISource;
use Bitrix\Location\Service\LocationService;
use Bitrix\Location\Source\BaseRepository;
use Bitrix\Location\Source\Google\Converters;
use Bitrix\Location\Source\Google\Converters\BaseConverter;
use Bitrix\Location\Source\Google\Requesters;
use Bitrix\Location\Source\Google\Requesters\BaseRequester;
use \Bitrix\Location\Common\CachedPool;
use Bitrix\Main\Localization\Loc;
use Bitrix\Main\Web\HttpClient;
 
Loc::loadMessages(__FILE__);

class Repository extends BaseRepository implements
    IRepository,
    IFindByExternalId,
    IFindByCoords,
    IFindByText,
    IFindParents,
    ISource
{
    protected $apiKey = '';
    protected static $sourceCode = 'GOOGLE';
    protected $httpClient = null;
    protected $cachePool = null;
    protected $googleSource = null;
 
    public function __construct(
        string $apiKey,
        HttpClient $httpClient,
        GoogleSource $googleSource,
        CachedPool $cachePool = null
    )
    {
        $this->apiKey = $apiKey;
        $this->httpClient = $httpClient;
        $this->cachePool = $cachePool;
        $this->googleSource = $googleSource;
    }

    public function findByExternalId(string $locationExternalId, string $sourceCode, string $languageId)
    {
        if ($sourceCode !== self::$sourceCode || $locationExternalId === '')
        {
            return null;
        }
 
        return $this->find(
            new Requesters\ByIdRequester($this->httpClient, $this->cachePool),
            new Converters\ByIdConverter($languageId),
            [
                'placeid' => $locationExternalId,
                'language' => $this->googleSource->convertLang($languageId),
            ]
        );
    }
 
    public function findByCoords(float $lat, float $lng, int $zoom, string $languageId): ?Location
    {
        $foundLocations = $this->find(
            new Requesters\ByCoordsRequester($this->httpClient, $this->cachePool),
            new Converters\ByCoordsConverter($languageId),
            [
                'latlng' => implode(',', [$lat, $lng]),
                'language' => $this->googleSource->convertLang($languageId),
            ]
        );
 
        return $foundLocations[0] ?? null;
    }

    public function findByText(string $query, string $languageId)
    {
        if ($query == '')
        {
            return null;
        }
 
        return $this->find(
            new Requesters\ByQueryRequester($this->httpClient, $this->cachePool),
            new Converters\ByQueryConverter($languageId),
            [
                'query' => $query,
                'language' => $this->googleSource->convertLang($languageId)
            ]
        );
    }
 
    protected function isCollectionContainLocation(Location $location, Collection $collection): bool
    {
        foreach ($collection->getItems() as $item)
        {
            if ($location->getExternalId() === $item->getExternalId())
            {
                return true;
            }
        }
 
        return false;
    }
 
    protected function chooseParentFromCollection(
        Location $location,
        Collection $collection,
        Parents $parentResultCollection,
        array $parentTypes
    ): ?Location
    {
        if ($collection->count() <= 0)
        {
            return null;
        }
 
        $candidatesTypes = [];
 
        for ($i = 0, $l = $collection->count(); $i < $l; $i++)
        {
            $candidate = $collection[$i];
 
            if ($location->getExternalId() === $candidate->getExternalId())
            {
                continue;
            }
 
            $candidateType = $candidate->getType();
 
            if ($candidateType === Location\Type::UNKNOWN)
            {
                continue;
            }
 
            if ($location->getType() !== Location\Type::UNKNOWN && $candidate->getType() >= $location->getType())
            {
                continue;
            }
 
            // check if we already have the same location in result parents collection
            if ($this->isCollectionContainLocation($candidate, $parentResultCollection))
            {
                continue;
            }
 
            if (in_array($candidateType, $parentTypes, true))
            {
                return $candidate;
            }
 
            $candidatesTypes[] = [$i, $candidateType];
        }
 
        if (count($candidatesTypes) <= 0)
        {
            return null;
        }
 
        if (count($candidatesTypes) > 1)
        {
            $typeColumn = array_column($candidatesTypes, 1);
            array_multisort($typeColumn, SORT_ASC, $candidatesTypes);
        }
 
        return $collection[$candidatesTypes[0][0]];
    }

    /*
     * Needs tests
     */
    public function findParents(Location $location, string $languageId): ?Parents
    {
        if ($location->getSourceCode() !== self::$sourceCode || $location->getExternalId() == '')
        {
            return null;
        }
 
        $result = (new Parents())
            ->setDescendant($location);
 
        /* Temporary. To decrease the usage of the Google API */
        return $result;
        /* */
 
        //We need full information about the location
        $rawData = $this->find(
            new Requesters\ByIdRequester($this->httpClient, $this->cachePool),
            null,
            [
                'placeid' => $location->getExternalId(),
                'language' => $languageId,
            ]
        );
 
        $ancestorDataConverter = new Converters\AncestorDataConverter();
        $ancestorsRawData = $ancestorDataConverter->convert($rawData, $location->getType());
 
        //is it always available?
        $latLon = $location->getLatitude().','.$location->getLongitude();
 
        foreach ($ancestorsRawData as $data)
        {
            //Just searching by query taking into account lat and lon
            $res = $this->find(
                new Requesters\ByQueryRequester($this->httpClient, $this->cachePool),
                new Converters\ByQueryConverter($languageId),
                [
                    'query' => $data['NAME'],
                    //todo: may be restrict by several types?
                    'location' => $latLon,
                    'language' => $languageId,
                ]
            );
 
            if ($res instanceof Collection && $res->count() > 0)
            {
                if (!($parentSource = $this->chooseParentFromCollection($location, $res, $result, $data['TYPES'])))
                {
                    continue;
                }
 
                $localParent = $this->findLocalLocationByExternalId($parentSource);
 
                //the parent location have already been saved
                if ($localParent)
                {
                    $result->addItem($localParent);
 
                    if ($llParents = $localParent->getParents())
                    {
                        foreach ($llParents as $localParent)
                        {
                            $result->addItem($localParent);
                        }
                    }
 
                    break;
                }
                else
                {
                    //we need detailed info
                    $detailedParent = $this->findByExternalId(
                        $parentSource->getExternalId(),
                        self::$sourceCode,
                        $languageId
                    );
 
                    if ($detailedParent)
                    {
                        $result->addItem($detailedParent);
                    }
                }
            }
        }
 
        return $result;
    }

    protected function findLocalLocationByExternalId(Location $location)
    {
        return LocationService::getInstance()->findByExternalId(
            $location->getExternalId(),
            $location->getSourceCode(),
            $location->getLanguageId(),
            LOCATION_SEARCH_SCOPE_INTERNAL,
        );
    }

    protected function buildFinder($requester, $converter)
    {
        return new Finder($requester, $converter);
    }

    protected function find($requester,  $converter = null, array $findParams = [])
    {
        if ($this->apiKey === '')
        {
            throw new RuntimeException(
                Loc::getMessage('LOCATION_ADDRESS_REPOSITORY_API_KEY_ERROR'),
                ErrorCodes::REPOSITORY_FIND_API_KEY_ERROR
            );
        }
 
        $finder = $this->buildFinder($requester, $converter);
        $findParams['key'] = $this->apiKey;
 
        return $finder->find($findParams);
    }

    public static function getSourceCode(): string
    {
        return self::$sourceCode;
    }
}