location.php

<?php
 
namespace Bitrix\Location\Entity;
 
use Bitrix\Location\Entity\Location\Converter\ArrayConverter;
use Bitrix\Location\Entity\Location\Field;
use Bitrix\Location\Entity\Location\FieldCollection;
use Bitrix\Location\Entity\Location\Type;
use Bitrix\Location\Entity\Location\Parents;
use Bitrix\Location\Service;
use Bitrix\Main\ArgumentOutOfRangeException;
use Bitrix\Main\Web\Json;
 
final class Location implements \Serializable
{
    protected $id = 0;
    protected $code = '';
    protected $externalId = '';
    protected $sourceCode = '';
    protected $type = Type::UNKNOWN;
    protected $name = '';
    protected $languageId = '';
    protected $latitude = '';
    protected $longitude = '';
 
    private $fieldCollection;
 
    protected $address = null;
 
    protected $parents = null;
 
    public function __construct()
    {
        $this->fieldCollection = new FieldCollection();
    }
 
    public function isParentOf(Location $childCandidate): bool
    {
        $candidateParents = $childCandidate->getParents();
 
        if(!$candidateParents)
        {
            return false;
        }
 
        return $candidateParents->isContain($this);
    }
 
    public function isChildOf(Location $parentCandidate): bool
    {
        $parents = $this->getParents();
 
        if(!$parents)
        {
            return false;
        }
 
        return $parents->isContain($parentCandidate);
    }
 
    public function isEqualTo(Location $location): bool
    {
        if($this->getId() > 0 && $location->getId() > 0)
        {
            return $this->getId() === $location->getId();
        }
 
        if($this->getExternalId() !== '' || $location->getExternalId() !== ''
            || $this->getSourceCode() !== '' || $location->getSourceCode() !== '')
        {
 
            if($this->getExternalId() === $location->getExternalId()
                && $this->getSourceCode() === $location->getSourceCode())
            {
                return true;
            }
 
            if($this->getExternalId() !== $location->getExternalId())
            {
                return false;
            }
 
            if($this->getSourceCode() !== $location->getSourceCode())
            {
                return false;
            }
        }
 
        if($this->getType() !== $location->getType())
        {
            return false;
        }
 
        if($this->getLanguageId() !== $location->getLanguageId())
        {
            return false;
        }
 
        if($this->getName() !== $location->getName())
        {
            return false;
        }
 
        if($this->getLatitude() !== $location->getLatitude())
        {
            return false;
        }
 
        if($this->getLongitude() !== $location->getLongitude())
        {
            return false;
        }
 
        $thisParents = $this->getParents();
        $otherParents = $location->getParents();
 
        if($thisParents && $otherParents && !$thisParents->isEqualTo($otherParents))
        {
            return false;
        }
 
        return true;
    }
 
    public function getParents()
    {
        $this->loadParents();
        return $this->parents;
    }
 
    public function loadParents(): void
    {
        if($this->parents === null)
        {
            $this->parents = Service\LocationService::getInstance()->findParents($this, $this->languageId);
        }
    }
 
    public function getParentByLevel(int $level): ?Location
    {
        $parents = $this->getParents();
        return (bool)$parents ? $parents[$level] : null;
    }
 
    public function getParentByType(int $type): ?Location
    {
        $parents = $this->getParents();
        return (bool)$parents ? $parents->getItemByType($type) : null;
    }
 
    public function setParents(Parents $parents): self
    {
        $this->parents = $parents;
        $this->parents->setDescendant($this);
        return $this;
    }
 
    public function getExternalId(): string
    {
        return $this->externalId;
    }
 
    public function setExternalId(string $externalId): self
    {
        $this->externalId = $externalId;
        return $this;
    }
 
    public function getLanguageId(): string
    {
        return $this->languageId;
    }
 
    public function setLanguageId(string $languageId): self
    {
        $this->languageId = $languageId;
        return $this;
    }
 
    public function getName(): string
    {
        return $this->name;
    }
 
    public function getNameWithParents(): string
    {
        $result = $this->getName();
 
        if($parents = $this->getParents())
        {
            foreach ($parents as $parent)
            {
                $result = $parent->getName().', '.$this->getName();
            }
        }
 
        return $result;
    }
 
    public function setName(string $name): self
    {
        $this->name = $name;
        return $this;
    }
 
    public function getAddress(): ?Address
    {
        if($this->address === null)
        {
            $this->address = Location\Converter\AddressConverter::convertToAddress($this);
        }
 
        return $this->address;
    }
 
    public function setAddress(Address $address): self
    {
        $this->address = $address;
        return $this;
    }
 
    public function getId(): int
    {
        return $this->id;
    }
 
    public function setId(int $id): self
    {
        $this->id = $id;
        return $this;
    }
 
    public function getCode(): string
    {
        return $this->code;
    }
 
    public function setCode(string $code): self
    {
        $this->code = $code;
        return $this;
    }
 
    public function getSourceCode(): string
    {
        return $this->sourceCode;
    }
 
    public function setSourceCode($sourceCode): self
    {
        $this->sourceCode = $sourceCode;
        return $this;
    }
 
    public function getType(): int
    {
        return $this->type;
    }
 
    public function setType(int $type): self
    {
        if(!Type::isValueExist($type))
        {
            throw new ArgumentOutOfRangeException('Wrong location type');
        }
 
        $this->type = $type;
        return $this;
    }
 
    public function copyDataFrom(Location $otherLocation): void
    {
        $this->setId($otherLocation->getId())
            ->setCode($otherLocation->getCode())
            ->setExternalId($otherLocation->getExternalId())
            ->setSourceCode($otherLocation->getSourceCode())
            ->setType($otherLocation->getType())
            ->setName($otherLocation->getName())
            ->setLanguageId($otherLocation->getLanguageId())
            ->setLatitude($otherLocation->getLatitude())
            ->setLongitude($otherLocation->getLongitude());
 
            if($address = $otherLocation->getAddress())
            {
                $this->setAddress($address);
            }
    }
 
    public function getLatitude(): string
    {
        return $this->latitude;
    }
 
    public function setLatitude(string $latitude): self
    {
        $this->latitude = $latitude;
        return $this;
    }
 
    public function getLongitude(): string
    {
        return $this->longitude;
    }
 
    public function setLongitude(string $longitude): self
    {
        $this->longitude = $longitude;
        return $this;
    }
 
    public function save(): \Bitrix\Main\Result
    {
        return Service\LocationService::getInstance()->save($this);
    }
 
    public static function load(int $id, string $languageId = LANGUAGE_ID)
    {
        return Service\LocationService::getInstance()->findById($id, $languageId);
    }
 
    public function delete(): \Bitrix\Main\Result
    {
        return Service\LocationService::getInstance()->delete($this);
    }
 
    public function serialize()
    {
        return serialize(
            \Bitrix\Location\Entity\Location\Converter\ArrayConverter::convertToArray($this)
        );
    }
 
    public function __serialize(): array
    {
        return \Bitrix\Location\Entity\Location\Converter\ArrayConverter::convertToArray($this);
    }
 
    public function unserialize($serialized)
    {
        $this->copyDataFrom(
            Location::fromArray(
                unserialize($serialized, ['allowed_classes' => false])
            )
        );
    }
 
    public function __unserialize(array $data): void
    {
        $this->copyDataFrom(
            Location::fromArray(
                $data
            )
        );
    }
 
    public function toArray(): array
    {
        return ArrayConverter::convertToArray($this);
    }
 
    public function toJson(): string
    {
        return Json::encode($this->toArray());
    }
 
    public static function fromArray(array $location): Location
    {
        return ArrayConverter::convertFromArray($location);
    }
 
    public function setFieldValue(int $type, string $value): self
    {
        if($field = $this->fieldCollection->getItemByType($type))
        {
            $field->setValue($value);
        }
        else
        {
            $this->fieldCollection->addItem(
                new Field($type, $value)
            );
        }
 
        return $this;
    }
 
    public function getAllFieldsValues(): array
    {
        $result = [];
 
        foreach ($this->fieldCollection as $field)
        {
            $result[$field->getType()] = $field->getValue();
        }
 
        return $result;
    }
 
    public function getFieldValue(int $type): ?string
    {
        $result = null;
 
        if($field = $this->fieldCollection->getItemByType($type))
        {
            $result = $field->getValue();
        }
 
        return $result;
    }
 
    public function isFieldExist(int $type): bool
    {
        return (bool)$this->fieldCollection->getItemByType($type);
    }
 
    public function getFieldCollection(): FieldCollection
    {
        return $this->fieldCollection;
    }
}