flipbox\craft\integration\fields\NormalizeValueTrait

Complexity

Total Complexity

18

Size/Duplication

Total Lines	166
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Test Coverage

Coverage

0%

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
	recordClass()	0	1	?
A	normalizeValue()	0	11	2
A	getQuery()	0	21	2
A	normalizeQuery()	0	8	3
A	normalizeQueryValue()	0	17	3
A	normalizeQueryInputValues()	0	12	2
A	normalizeQueryInputValue()	0	24	2
A	normalizeQueryEmptyValue()	0	5	1
A	targetSiteId()	0	9	3

<?php

/**
 * @copyright  Copyright (c) Flipbox Digital Limited
 * @license    https://github.com/flipboxfactory/craft-integration/blob/master/LICENSE
 * @link       https://github.com/flipboxfactory/craft-integration/
 */

namespace flipbox\craft\integration\fields;

use Craft;
use craft\base\Element;
use craft\base\ElementInterface;
use flipbox\craft\integration\db\IntegrationAssociationQuery;
use yii\db\ActiveRecord;

/**
 * @author Flipbox Factory <hello@flipboxfactory.com>
 * @since 2.0.0
 *
 * @property int $id
 * @property int $elementId
 * @property int $objectId
 */
trait NormalizeValueTrait
{
    /**
     * @return string
     */
    abstract public static function recordClass(): string;

    /*******************************************
     * NORMALIZE VALUE
     *******************************************/

    /**
     * @param $value
     * @param ElementInterface|null $element
     * @return IntegrationAssociationQuery
     */
    public function normalizeValue(
        $value,
        ElementInterface $element = null
    ) {
        if ($value instanceof IntegrationAssociationQuery) {
            return $value;
        }
        $query = $this->getQuery($element);
        $this->normalizeQueryValue($query, $value, $element);
        return $query;
    }

    /**
     * @param ElementInterface|null $element
     * @return IntegrationAssociationQuery
     */
    protected function getQuery(
        ElementInterface $element = null
    ): IntegrationAssociationQuery {

        /** @var ActiveRecord $recordClass */
        $recordClass = static::recordClass();

        /** @var IntegrationAssociationQuery $query */
        $query = $recordClass::find();

        $query
            ->field($this->id)
            ->element($element)
            ->site($this->targetSiteId($element));

        if ($this->max !== null) {
            $query->limit($this->max);

The property max does not exist. Did you maybe forget to declare it?

        }

        return $query;
    }

    /**
     * @param IntegrationAssociationQuery $query
     * @param ElementInterface|null $element
     */
    protected function normalizeQuery(
        IntegrationAssociationQuery $query,
        ElementInterface $element = null
    ) {
        $query->element = (
            $element === null || $element->getId() === null
        ) ? false : $element->getId();
    }

    /**
     * @param IntegrationAssociationQuery $query
     * @param $value
     * @param ElementInterface|null $element
     */
    protected function normalizeQueryValue(
        IntegrationAssociationQuery $query,
        $value,
        ElementInterface $element = null
    ) {
        $this->normalizeQuery($query, $element);

        if (is_array($value)) {
            $this->normalizeQueryInputValues($query, $value, $element);
            return;
        }

        if ($value === '') {
            $this->normalizeQueryEmptyValue($query);
            return;
        }
    }

    /**
     * @param IntegrationAssociationQuery $query
     * @param array $value
     * @param ElementInterface|null $element
     */
    protected function normalizeQueryInputValues(
        IntegrationAssociationQuery $query,
        array $value,
        ElementInterface $element = null
    ) {
        $models = [];
        $sortOrder = 1;
        foreach ($value as $val) {
            $models[] = $this->normalizeQueryInputValue($val, $sortOrder, $element);
        }
        $query->setCachedResult($models);
    }

    /**
     * @param $value
     * @param int $sortOrder
     * @param ElementInterface|null $element
     * @return IntegrationAssociationQuery
     */
    protected function normalizeQueryInputValue(
        $value,
        int &$sortOrder,
        ElementInterface $element = null
    ): IntegrationAssociationQuery {

        if (is_string($value)) {
            $value = [
                'objectId' => $value
            ];
        }

        $recordClass = static::recordClass();

        return new $recordClass(array_merge(
            (array)$value,
            [
                'field' => $this,
                'element' => $element,
                'siteId' => $this->targetSiteId($element),
                'sortOrder' => $sortOrder++
            ]
        ));
    }

    /**
     * @param IntegrationAssociationQuery $query
     */
    protected function normalizeQueryEmptyValue(
        IntegrationAssociationQuery $query
    ) {
        $query->setCachedResult([]);
    }


    /**
     * Returns the site ID that target elements should have.
     *
     * @param ElementInterface|Element|null $element
     *
     * @return int
     */
    protected function targetSiteId(ElementInterface $element = null): int
    {
        /** @var Element $element */
        if (Craft::$app->getIsMultiSite() === true && $element !== null) {
            return $element->siteId;
        }

        return Craft::$app->getSites()->currentSite->id;
    }
}