flipbox\meta\services\Fields

Complexity

Total Complexity

61

Size/Duplication

Total Lines	512
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	14

Test Coverage

Coverage

0%

Importance

Changes

0

16 Methods

Rating	Name	Duplication	Size	Complexity
A	tableAlias()	0	4	1
A	ensureField()	0	10	2
A	getQuery()	0	14	1
A	serializeValue()	0	19	2
B	normalizeQueryInputValues()	0	63	9
B	getExistingValues()	0	28	6
A	beforeElementDelete()	0	19	3
B	afterElementSave()	0	43	7
A	duplicate()	0	17	4
A	save()	0	23	3
A	deleteOld()	0	21	3
A	applyFieldTranslationSetting()	0	27	5
A	saveFieldTranslations()	0	38	5
A	getOtherSiteMeta()	0	24	5
A	getRelationFields()	0	16	4
A	normalizeQueryInputValue()	0	9	1

<?php

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

namespace flipbox\meta\services;

use Craft;
use craft\base\Element;
use craft\base\ElementInterface;
use craft\base\FieldInterface;
use craft\elements\db\ElementQueryInterface;
use craft\fields\BaseRelationField;
use flipbox\craft\sortable\associations\db\SortableAssociationQueryInterface;
use flipbox\craft\sortable\associations\records\SortableAssociationInterface;
use flipbox\craft\sortable\associations\services\SortableFields;
use flipbox\meta\db\MetaQuery;
use flipbox\meta\elements\Meta as MetaElement;
use flipbox\meta\fields\Meta;
use flipbox\meta\fields\Meta as MetaField;
use flipbox\meta\Meta as MetaPlugin;
use flipbox\meta\records\Meta as MetaRecord;
use yii\base\Exception;

/**
 * @author Flipbox Factory <hello@flipboxfactory.com>
 * @since 1.0.0
 *
 * @method MetaQuery find()
 */
class Fields extends SortableFields
{
    /**
     * @inheritdoc
     */
    const SOURCE_ATTRIBUTE = MetaRecord::SOURCE_ATTRIBUTE;

    /**
     * @inheritdoc
     */
    const TARGET_ATTRIBUTE = MetaRecord::TARGET_ATTRIBUTE;

    /**
     * @inheritdoc
     */
    protected static function tableAlias(): string
    {
        return MetaRecord::tableAlias();
    }

    /**
     * @param FieldInterface $field
     * @throws Exception
     */
    private function ensureField(FieldInterface $field)
    {
        if (!$field instanceof MetaField) {
            throw new Exception(sprintf(
                "The field must be an instance of '%s', '%s' given.",
                (string)MetaField::class,
                (string)get_class($field)
            ));
        }
    }

    /**
     * @inheritdoc
     */
    public function getQuery(
        FieldInterface $field,
        ElementInterface $element = null
    ): SortableAssociationQueryInterface {
        /** @var MetaField $field */
        $this->ensureField($field);

        $query = MetaPlugin::getInstance()->getElements()->getQuery();

        $query->siteId = $this->targetSiteId($element);
        $query->fieldId = $field->id;

        return $query;
    }


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

    /**
     * @param FieldInterface $field
     * @param $value
     * @param ElementInterface|null $element
     * @return array
     */
    public function serializeValue(
        FieldInterface $field,

The parameter $field is not used and could be removed.

        $value,
        ElementInterface $element = null

The parameter $element is not used and could be removed.

    ): array {
        /** @var MetaQuery $value */
        $serialized = [];
        $new = 0;

        foreach ($value->all() as $meta) {
            $metaId = $meta->id ?? 'new' . ++$new;
            $serialized[$metaId] = [
                'enabled' => $meta->enabled,
                'fields' => $meta->getSerializedFieldValues(),
            ];
        }

        return $serialized;
    }

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

    /**
     * Accepts input data and converts it into an array of associated Meta elements
     *
     * @param FieldInterface $field
     * @param SortableAssociationQueryInterface $query
     * @param array $value
     * @param ElementInterface|null $element
     */
    protected function normalizeQueryInputValues(
        FieldInterface $field,
        SortableAssociationQueryInterface $query,
        array $value,
        ElementInterface $element = null
    ) {
        /** @var MetaField $field */

        $models = [];
        $sortOrder = 1;
        $prevElement = null;
        /** @var MetaElement|null $prevElement */

        // Get existing values
        $existingValues = $element === null ? [] : $this->getExistingValues($field, $value, $element);
        $ownerId = $element->id ?? null;

        foreach ($value as $metaId => $metaData) {
            // Is this new? (Or has it been deleted?)
            if (strpos($metaId, 'new') === 0 || !isset($existingValues[$metaId])) {
                $meta = MetaPlugin::getInstance()->getElements()->create([
                    'fieldId' => $field->id,
                    'ownerId' => $ownerId,
                    'siteId' => $this->targetSiteId($element)
                ]);
            } else {
                $meta = $existingValues[$metaId];
            }

            /** @var MetaElement $meta */

            $meta->enabled = (bool)$metaData['enabled'] ?? true;
            $meta->setOwnerId($ownerId);

            // Set the content post location on the element if we can
            $fieldNamespace = $element->getFieldParamNamespace();

            if ($fieldNamespace !== null) {
                $metaFieldNamespace = ($fieldNamespace ? $fieldNamespace . '.' : '') .
                    '.' . $field->handle .
                    '.' . $metaId .
                    '.fields';
                $meta->setFieldParamNamespace($metaFieldNamespace);
            }

            if (isset($metaData['fields'])) {
                $meta->setFieldValues($metaData['fields']);
            }

            $sortOrder++;
            $meta->sortOrder = $sortOrder;

            // Set the prev/next elements
            if ($prevElement) {
                $prevElement->setNext($meta);
                $meta->setPrev($prevElement);
            }
            $prevElement = $meta;

            $models[] = $meta;
        }
        $query->setCachedResult($models);
    }

    /**
     * @param MetaField $field
     * @param array $values
     * @param ElementInterface $element
     * @return array
     */
    protected function getExistingValues(MetaField $field, array $values, ElementInterface $element): array
    {
        /** @var Element $element */
        if (!empty($element->id)) {
            $ids = [];

            foreach ($values as $metaId => $meta) {
                if (is_numeric($metaId) && $metaId !== 0) {
                    $ids[] = $metaId;
                }
            }

            if (!empty($ids)) {
                $oldMetaQuery = MetaPlugin::getInstance()->getElements()->getQuery();
                $oldMetaQuery->fieldId($field->id);
                $oldMetaQuery->ownerId($element->id);
                $oldMetaQuery->id($ids);
                $oldMetaQuery->limit(null);
                $oldMetaQuery->status(null);
                $oldMetaQuery->enabledForSite(false);
                $oldMetaQuery->siteId($element->siteId);
                $oldMetaQuery->indexBy('id');
                return $oldMetaQuery->all();
            }
        }

        return [];
    }


    /*******************************************
     * ELEMENT EVENTS
     *******************************************/

    /**
     * @param MetaField $field
     * @param ElementInterface $element
     * @return bool
     * @throws \Throwable
     */
    public function beforeElementDelete(MetaField $field, ElementInterface $element): bool
    {
        // Delete any meta elements that belong to this element(s)
        foreach (Craft::$app->getSites()->getAllSiteIds() as $siteId) {
            $query = MetaElement::find();
            $query->status(null);
            $query->enabledForSite(false);
            $query->fieldId($field->id);
            $query->siteId($siteId);
            $query->owner($element);

            /** @var MetaElement $meta */
            foreach ($query->all() as $meta) {
                Craft::$app->getElements()->deleteElement($meta);
            }
        }

        return true;
    }

    /**
     * @param Meta $field
     * @param ElementInterface $owner
     * @throws \Exception
     * @throws \Throwable
     * @throws \yii\db\Exception
     */
    public function afterElementSave(MetaField $field, ElementInterface $owner)
    {
        /** @var Element $owner */

        /** @var MetaQuery $query */
        $query = $owner->getFieldValue($field->handle);

        // Skip if the query's site ID is different than the element's
        // (Indicates that the value as copied from another site for element propagation)
        if ($query->siteId != $owner->siteId) {
            return;
        }

        if (null === ($elements = $query->getCachedResult())) {
            $query = clone $query;
            $query->status = null;
            $query->enabledForSite = false;
            $elements = $query->all(); // existing meta
        }

        $transaction = Craft::$app->getDb()->beginTransaction();
        try {
            // If this is a preexisting element, make sure that the blocks for this field/owner respect the
            // field's translation setting
            if ($query->ownerId) {
                $this->applyFieldTranslationSetting($query->ownerId, $query->siteId, $field);

It seems like $query->ownerId can also be of type array<integer,integer>; however, flipbox\meta\services\Fields::applyFieldTranslationSetting() does only seem to accept integer, maybe add an additional type check?

            }

            // If the query is set to fetch blocks of a different owner, we're probably duplicating an element
            if ($query->ownerId && $query->ownerId != $owner->id) {
                $this->duplicate($field, $owner, $query, $elements);
            } else {
                $this->save($field, $owner, $elements);
            }

            $transaction->commit();
        } catch (\Exception $e) {
            $transaction->rollback();
            throw $e;
        }

        return;
    }

    /**
     * @param MetaField $field
     * @param ElementInterface $owner
     * @param MetaQuery $query
     * @param array $elements
     * @throws \Throwable
     * @throws \craft\errors\InvalidElementException
     */
    private function duplicate(MetaField $field, ElementInterface $owner, MetaQuery $query, array $elements)
    {
        /** @var Element $owner */

        $newQuery = clone $query;
        $newQuery->ownerId = $owner->id;
        if (!$newQuery->exists()) {
            // Duplicate for the new owner
            $elementsService = Craft::$app->getElements();
            foreach ($elements as $element) {
                $elementsService->duplicateElement($element, [
                    'ownerId' => $owner->id,
                    'ownerSiteId' => $field->localize ? $owner->siteId : null
                ]);
            }
        }
    }

    /**
     * @param MetaField $field
     * @param ElementInterface $owner
     * @param MetaElement[] $elements
     * @throws Exception
     * @throws \Throwable
     * @throws \craft\errors\ElementNotFoundException
     */
    private function save(MetaField $field, ElementInterface $owner, array $elements)
    {
        /** @var Element $owner */

        $elementIds = [];

        // Only propagate the blocks if the owner isn't being propagated
        $propagate = !$owner->propagating;

        /** @var MetaElement $element */
        foreach ($elements as $element) {
            $element->setOwner($owner);
            $element->ownerSiteId = ($field->localize ? $owner->siteId : null);
            $element->propagating = $owner->propagating;

            Craft::$app->getElements()->saveElement($element, false, $propagate);

            $elementIds[] = $element->id;
        }

        // Delete any elements that have been removed
        $this->deleteOld($field, $owner, $elementIds);
    }

    /**
     * @param MetaField $field
     * @param ElementInterface $owner
     * @param array $excludeIds
     * @throws \Throwable
     */
    private function deleteOld(MetaField $field, ElementInterface $owner, array $excludeIds)
    {
        /** @var Element $owner */

        $deleteElementsQuery = MetaElement::find()
            ->status(null)
            ->enabledForSite(false)
            ->ownerId($owner->id)
            ->fieldId($field->id)
            ->where(['not', ['elements.id' => $excludeIds]]);

        if ($field->localize) {
            $deleteElementsQuery->ownerSiteId($owner->siteId);
        } else {
            $deleteElementsQuery->siteId($owner->siteId);
        }

        foreach ($deleteElementsQuery->all() as $deleteElement) {
            Craft::$app->getElements()->deleteElement($deleteElement);
        }
    }

    /**
     * Applies the field's translation setting to a set of blocks.
     *
     * @param int $ownerId
     * @param int $ownerSiteId
     * @param Meta $field
     * @throws Exception
     * @throws \Throwable
     * @throws \craft\errors\ElementNotFoundException
     */
    private function applyFieldTranslationSetting(int $ownerId, int $ownerSiteId, MetaField $field)
    {
        // If the field is translatable, see if there are any global blocks that should be localized
        if ($field->localize) {
            $this->saveFieldTranslations($field, $ownerId, $ownerSiteId);
        } else {
            // Otherwise, see if the field has any localized blocks that should be deleted
            foreach (Craft::$app->getSites()->getAllSiteIds() as $siteId) {
                if ($siteId != $ownerSiteId) {
                    /** @var MetaQuery $elements */
                    $elements = MetaElement::find()

The method ownerSiteId() does not exist on craft\elements\db\ElementQuery. Did you maybe mean siteId()?

                        ->fieldId($field->id)
                        ->ownerId($ownerId)
                        ->status(null)
                        ->enabledForSite(false)
                        ->limit(null)
                        ->siteId($siteId)
                        ->ownerSiteId($siteId)
                        ->all();

                    foreach ($elements as $element) {
                        Craft::$app->getElements()->deleteElement($element);
                    }
                }
            }
        }
    }

    /**
     * @param MetaField $field
     * @param int $ownerId
     * @param int $ownerSiteId
     * @throws Exception
     * @throws \Throwable
     * @throws \craft\errors\ElementNotFoundException
     */
    private function saveFieldTranslations(MetaField $field, int $ownerId, int $ownerSiteId)
    {
        /** @var MetaQuery $elements */
        $elementQuery = MetaElement::find()

The method ownerSiteId() does not exist on craft\elements\db\ElementQuery. Did you maybe mean siteId()?

            ->fieldId($field->id)
            ->ownerId($ownerId)
            ->status(null)
            ->enabledForSite(false)
            ->limit(null)
            ->siteId($ownerSiteId)
            ->ownerSiteId(':empty:');

        $elements = $elementQuery->all();

        if (empty($elements)) {
            return;
        }

        // Prefetch the blocks in all the other sites, in case they have any localized content
        $otherSiteMeta = $this->getOtherSiteMeta($elementQuery, $ownerSiteId);

        // Explicitly assign the current site's blocks to the current site
        foreach ($elements as $element) {
            $element->ownerSiteId = $ownerSiteId;
            Craft::$app->getElements()->saveElement($element, false);
        }

        // Now save the other sites' blocks as new site-specific blocks
        foreach ($otherSiteMeta as $siteId => $siteElements) {
            foreach ($siteElements as $element) {
                $element->id = null;
                $element->contentId = null;
                $element->siteId = (int)$siteId;
                $element->ownerSiteId = (int)$siteId;
                Craft::$app->getElements()->saveElement($element, false);
            }
        }
    }

    /**
     * @param MetaQuery $query
     * @param int $ownerSiteId
     * @return array
     */
    private function getOtherSiteMeta(MetaQuery $query, int $ownerSiteId)
    {
        // Find any relational fields
        $relationFields = $this->getRelationFields($query->all());

        $otherSiteMeta = [];
        foreach (Craft::$app->getSites()->getAllSiteIds() as $siteId) {
            if ($siteId != $ownerSiteId) {
                /** @var MetaElement[] $siteElements */
                $siteElements = $otherSiteMeta[$siteId] = $query->siteId($siteId)->all();

                // Hard-set the relation IDs
                foreach ($siteElements as $element) {
                    foreach ($relationFields as $handle) {
                        /** @var ElementQueryInterface $relationQuery */
                        $relationQuery = $element->getFieldValue($handle);
                        $element->setFieldValue($handle, $relationQuery->ids());
                    }
                }
            }
        }

        return $otherSiteMeta;
    }

    /**
     * @param array $elements
     * @return array
     */
    private function getRelationFields(array $elements)
    {
        // Find any relational fields on these blocks
        $relationFields = [];

        foreach ($elements as $element) {
            foreach ($element->getFieldLayout()->getFields() as $field) {
                if ($field instanceof BaseRelationField) {
                    $relationFields[] = $field->handle;
                }
            }
            break;
        }

        return $relationFields;
    }

    /**
     * @inheritdoc
     */
    protected function normalizeQueryInputValue(
        FieldInterface $field,
        $value,
        int &$sortOrder,
        ElementInterface $element = null
    ): SortableAssociationInterface {

        throw new Exception(__METHOD__ . ' is not implemented');
    }
}