LTDBeget\dns\configurator\Zone

Complexity

Total Complexity

32

Size/Duplication

Total Lines	221
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	9

Test Coverage

Coverage

78.38%

16 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	fromString()	0	4	1
A	fromArray()	0	4	1
A	__toString()	0	10	2
A	sort()	0	19	4
A	iterateNodes()	0	6	2
A	iterateRecords()	0	8	3
A	toArray()	0	9	2
A	getNodeNames()	0	4	1
A	getNode()	0	10	2
A	isNodeExist()	0	4	1
A	removeRecords()	0	8	3
A	isEmptyZone()	0	10	3
A	validate()	0	20	4
A	getErrorsStore()	0	4	1
A	getOrigin()	0	4	1

<?php
/**
 * @author: Viskov Sergey
 * @date  : 4/12/16
 * @time  : 1:00 PM
 */

namespace LTDBeget\dns\configurator;

use LTDBeget\dns\configurator\deserializer\ArrayDeserializer;
use LTDBeget\dns\configurator\deserializer\PlainDeserializer;
use LTDBeget\dns\configurator\errors\ErrorsStore;
use LTDBeget\dns\configurator\errors\ValidationError;
use LTDBeget\dns\configurator\traits\RecordsIterateTrait;
use LTDBeget\dns\configurator\validators\OriginValidator;
use LTDBeget\dns\configurator\validators\SoaNumberCheck;
use LTDBeget\dns\configurator\zoneEntities\Node;
use LTDBeget\dns\configurator\zoneEntities\record\base\Record;
use LTDBeget\dns\enums\eErrorCode;
use LTDBeget\dns\enums\eRecordType;

/**
 * Class Zone
 *
 * @package LTDBeget\dns\configurator
 */
class Zone
{
    use RecordsIterateTrait;

    /**
     * @var String
     */
    private $origin;
    /**
     * @var Node[] $nodes
     */
    private $nodes = [];
    /**
     * @var ErrorsStore
     */
    private $errorsStore;

    /**
     * @param $origin
     */
    public function __construct(string $origin)
    {
        $this->origin      = mb_strtolower(trim($origin));
        $this->errorsStore = new ErrorsStore();
    }

    /**
     * @param string $origin
     * @param string $plainData
     * @return Zone
     */
    public static function fromString(string $origin, string $plainData) : Zone
    {
        return PlainDeserializer::deserialize(new self($origin), $plainData);
    }

    /**
     * @param string $origin
     * @param array  $arrayData
     * @return Zone
     */
    public static function fromArray(string $origin, array $arrayData) : Zone
    {
        return ArrayDeserializer::deserialize(new self($origin), $arrayData);
    }

    /**
     * @return string
     */
    public function __toString() : string
    {
        $this->sort();
        $records = [];
        foreach ($this->iterateRecords() as $record) {
            $records[] = (string) $record;
        }

        return implode("\n", $records);
    }

    /**
     * Sort zone by node names and record types
     */
    public function sort()
    {
        $nodes = $this->nodes;
        /** @var Node[] $_nodes */
        $_nodes = [];
        foreach (['@', 'www', '*'] as $node_name) {
            if (isset($nodes[$node_name])) {
                $_nodes[$node_name] = $nodes[$node_name];
                unset($nodes[$node_name]);
            }
        }

        ksort($nodes);
        $this->nodes = array_merge($_nodes, $nodes);

        foreach ($this->iterateNodes() as $node) {
            $node->sort();
        }
    }

    /**
     * @return Node[]
     */
    public function iterateNodes()
    {
        foreach ($this->nodes as $node) {
            yield $node;
        }
    }

    /**
     * @param eRecordType|null $type
     * @return Record[]
     */
    public function iterateRecords(eRecordType $type = NULL)
    {
        foreach ($this->iterateNodes() as $node) {
            foreach ($node->iterateRecords($type) as $record) {
                yield $record;
            }
        }
    }

    /**
     * @return array
     */
    public function toArray() : array
    {
        $records = [];
        foreach ($this->iterateRecords() as $record) {
            $records[] = $record->toArray();
        }

        return $records;
    }

    /**
     * @return array
     */
    public function getNodeNames() : array
    {
        return array_keys($this->nodes);
    }

    /**
     * @param $name
     * @return Node
     */
    public function getNode(string $name) : Node
    {
        $name = mb_strtolower(trim($name));

        if (!$this->isNodeExist($name)) {
            $this->nodes[$name] = new Node($this, $name);
        }

        return $this->nodes[$name];
    }

    /**
     * Check is node by given name already exists
     *
     * @param $name
     * @return bool
     */
    public function isNodeExist($name) : bool
    {
        return array_key_exists(mb_strtolower(trim($name)), $this->nodes);
    }

    /**
     * @param eRecordType|NULL $type
     */
    public function removeRecords(eRecordType $type = NULL)
    {
        foreach ($this->iterateNodes() as $node) {
            foreach ($node->iterateRecords($type) as $record) {
                $record->remove();
            }
        }
    }

    /**
     * @return bool
     */
    public function isEmptyZone() : bool
    {
        $result = true;
        foreach ($this->iterateNodes() as $node) {
            if(! $node->isEmptyNode()) {
                $result = false;
            }
        }
        return $result;
    }

    /**
     * Full validate zone via build in validators
     *
     * @return bool
     */
    public function validate() : bool
    {
        $errorsStore = $this->getErrorsStore();
        $errorsStore->clear();

        foreach ($this->iterateNodes() as $node) {
            /** @noinspection PhpInternalEntityUsedInspection */
            $node->validate();
        }

        if (!SoaNumberCheck::validate($this)) {
            $errorsStore->add(ValidationError::makeZoneError($this, eErrorCode::SOA_ERROR()));
        }

        if (!OriginValidator::validate($this->getOrigin())) {
            $errorsStore->add(ValidationError::makeZoneError($this, eErrorCode::WRONG_ORIGIN()));
        }

        return !$errorsStore->isHasErrors();
    }

    /**
     * @return ErrorsStore
     */
    public function getErrorsStore()
    {
        return $this->errorsStore;
    }

    /**
     * @return String
     */
    public function getOrigin() : string
    {
        return $this->origin;
    }
}