flipbox\craft\domains\validators\DomainsValidator

Complexity

Total Complexity

17

Size/Duplication

Total Lines	138
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Test Coverage

Coverage

0%

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	init()	0	8	2
A	validateAttribute()	0	12	2
A	validateElementAttribute()	0	14	2
A	validateQuery()	0	14	4
A	validateDomainModel()	0	21	4
A	validateUniqueDomain()	0	32	3

<?php

/**
 * @copyright  Copyright (c) Flipbox Digital Limited
 * @license    https://flipboxfactory.com/software/domains/license
 * @link       https://www.flipboxfactory.com/software/domains/
 */

namespace flipbox\craft\domains\validators;

use Craft;
use craft\base\Element;
use craft\base\ElementInterface;
use flipbox\craft\domains\queries\DomainsQuery;
use flipbox\craft\domains\fields\Domains;
use flipbox\craft\domains\records\Domain;
use yii\base\Exception;
use yii\base\Model;
use yii\validators\Validator;

/**
 * @author Flipbox Factory <hello@flipboxfactory.com>
 * @since 1.0.0
 */
class DomainsValidator extends Validator
{
    /**
     * @var Domains
     */
    public $field;

    /**
     * @inheritdoc
     * @throws Exception
     */
    public function init()
    {
        parent::init();

        if (!$this->field instanceof Domains) {
            throw new Exception("Field must be an instance of 'Domains'.");
        }
    }

    /**
     * @param Model $model
     * @param string $attribute
     * @throws Exception
     */
    public function validateAttribute($model, $attribute)
    {
        if (!$model instanceof ElementInterface) {
            throw new Exception(sprintf(
                "Model must be an instance of '%s'.",
                (string)ElementInterface::class
            ));
        }

        /** @var ElementInterface $model */
        $this->validateElementAttribute($model, $attribute);
    }

    /**
     * @param ElementInterface $element
     * @param string $attribute
     * @throws Exception
     */
    protected function validateElementAttribute(ElementInterface $element, string $attribute)
    {
        /** @var Element $element */
        $value = $element->{$attribute};

        if (!$value instanceof DomainsQuery) {
            throw new Exception(sprintf(
                "Field value must be an instance of '%s'.",
                (string)DomainsQuery::class
            ));
        }

        $this->validateQuery($value, $element, $attribute);
    }

    /**
     * @param DomainsQuery $query
     * @param ElementInterface $element
     * @param string $attribute
     */
    protected function validateQuery(DomainsQuery $query, ElementInterface $element, string $attribute)
    {
        if (null !== ($cachedResult = $query->getCachedResult())) {
            $domains = [];
            foreach ($cachedResult as $model) {
                $this->validateDomainModel($model, $element, $attribute);
                $domains[$model->domain] = $model->domain;
            }

            if ($this->field->unique === true) {
                $this->validateUniqueDomain(array_keys($domains), $element, $attribute);
            }
        }
    }

    /**
     * @param Domain $domain
     * @param ElementInterface $element
     * @param string $attribute
     */
    protected function validateDomainModel(Domain $domain, ElementInterface $element, string $attribute)
    {
        /** @var Element $element */
        if (!$domain->validate(['domain', 'status'])) {
            if ($domain->hasErrors('domain')) {
                $this->addError(
                    $element,
                    $attribute,
                    $domain->getFirstError('domain')
                );
            }

            if ($domain->hasErrors('status')) {
                $this->addError(
                    $element,
                    $attribute,
                    $domain->getFirstError('status')
                );
            }
        }
    }

    protected function validateUniqueDomain(array $domains, ElementInterface $element, string $attribute)
    {
        /** @var Element $element */
        $domainQuery = Domain::find()
            ->select(['elementId', 'domain'])
            ->andWhere(['domain' => $domains]);

        // Ignore this element
        if (null !== ($existingElementId = $element->getId())) {
            $domainQuery->andWhere([
                '!=',
                'elementId',
                $existingElementId
            ]);
        }

        if (null !== ($domain = $domainQuery->one())) {
            /** @var Domain $domain */
            $this->addError(
                $element,
                $attribute,
                Craft::t(
                    'domains',
                    "Domain '{domain}' is already in use by element {elementId}.",
                    [
                        'domain' => $domain->domain,
                        'elementId' => $domain->elementId
                    ]
                )
            );
        }
    }
}