eZ\Publish\Core\Repository\Helper\RelationProcessor

Complexity

Total Complexity

36

Size/Duplication

Total Lines	239
Duplicated Lines	13.39 %

Coupling/Cohesion

Components	1
Dependencies	17

Importance

Changes	1
Bugs	1	Features	0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
D	appendFieldRelations()	0	37	10
F	processFieldRelations()	32	89	20
B	updateContentRelations()	0	30	4
A	loadExistingRelations()	0	19	1

<?php

/**
 * File containing the RelationProcessor class.
 *
 * @copyright Copyright (C) eZ Systems AS. All rights reserved.
 * @license For full copyright and license information view LICENSE file distributed with this source code.
 *
 * @version //autogentag//
 */
namespace eZ\Publish\Core\Repository\Helper;

use eZ\Publish\SPI\Persistence\Content\VersionInfo as SPIVersionInfo;
use eZ\Publish\SPI\Persistence\Handler;
use eZ\Publish\API\Repository\Values\ContentType\ContentType;
use eZ\Publish\Core\Repository\Values\Content\Relation;
use eZ\Publish\Core\FieldType\Value as BaseValue;
use eZ\Publish\SPI\FieldType\FieldType as SPIFieldType;
use eZ\Publish\SPI\Persistence\Content\Relation\CreateStruct as SPIRelationCreateStruct;
use eZ\Publish\SPI\Persistence\Content\Relation as SPIRelation;

/**
 * RelationProcessor is an internal service used for handling field relations upon Content creation or update.
 *
 * @internal
 */
class RelationProcessor
{
    /**
     * @var \eZ\Publish\SPI\Persistence\Handler
     */
    protected $persistenceHandler;

    /**
     * @var \eZ\Publish\Core\Repository\Helper\FieldTypeRegistry
     */
    private $fieldTypeRegistry;

    /**
     * @var \eZ\Publish\Core\Repository\Helper\DomainMapper
     */
    private $domainMapper;

    /**
     * Setups service with reference to repository object that created it & corresponding handler.
     *
     * @param \eZ\Publish\SPI\Persistence\Handler $handler
     * @param \eZ\Publish\Core\Repository\Helper\FieldTypeRegistry $fieldTypeRegistry
     */
    public function __construct(Handler $handler, FieldTypeRegistry $fieldTypeRegistry, DomainMapper $domainMapper)
    {
        $this->persistenceHandler = $handler;
        $this->fieldTypeRegistry = $fieldTypeRegistry;
        $this->domainMapper = $domainMapper;
    }

    /**
     * Appends destination Content ids of given $fieldValue to the $relation array.
     *
     * If $fieldValue contains Location ids, the will be converted to the Content id that Location encapsulates.
     *
     * @param array $relations
     * @param array $locationIdToContentIdMapping An array with Location Ids as keys and corresponding Content Id as values
     * @param \eZ\Publish\SPI\FieldType\FieldType $fieldType
     * @param \eZ\Publish\Core\FieldType\Value $fieldValue Accepted field value.
     * @param string $fieldDefinitionId
     */
    public function appendFieldRelations(
        array &$relations,
        array &$locationIdToContentIdMapping,
        SPIFieldType $fieldType,
        BaseValue $fieldValue,
        $fieldDefinitionId
    ) {
        foreach ($fieldType->getRelations($fieldValue) as $relationType => $destinationIds) {
            if ($relationType === Relation::FIELD) {
                if (!isset($relations[$relationType][$fieldDefinitionId])) {
                    $relations[$relationType][$fieldDefinitionId] = array();
                }
                $relations[$relationType][$fieldDefinitionId] += array_flip($destinationIds);
            } elseif ($relationType & (Relation::LINK | Relation::EMBED)) {
                // Using bitwise operators as Legacy Stack stores COMMON, LINK and EMBED relation types
                // in the same entry using bitmask
                if (!isset($relations[$relationType])) {
                    $relations[$relationType] = array();
                }

                if (isset($destinationIds['locationIds'])) {
                    foreach ($destinationIds['locationIds'] as $locationId) {
                        if (!isset($locationIdToContentIdMapping[$locationId])) {
                            $location = $this->persistenceHandler->locationHandler()->load($locationId);
                            $locationIdToContentIdMapping[$locationId] = $location->contentId;
                        }

                        $relations[$relationType][$locationIdToContentIdMapping[$locationId]] = true;
                    }
                }

                if (isset($destinationIds['contentIds'])) {
                    $relations[$relationType] += array_flip($destinationIds['contentIds']);
                }
            }
        }
    }

    /**
     * Persists relation data for a content version.
     *
     * This method creates new relations and deletes removed relations.
     *
     * @param array $inputRelations
     * @param mixed $sourceContentId
     * @param mixed $sourceContentVersionNo
     * @param \eZ\Publish\API\Repository\Values\ContentType\ContentType $contentType
     * @param \eZ\Publish\API\Repository\Values\Content\Relation[] $existingRelations An array of existing relations for Content version (empty when creating new content)
     */
    public function processFieldRelations(
        array $inputRelations,
        $sourceContentId,
        $sourceContentVersionNo,
        ContentType $contentType,
        array $existingRelations = array()
    ) {
        // Map existing relations for easier handling
        $mappedRelations = array();
        foreach ($existingRelations as $relation) {
            if ($relation->type === Relation::FIELD) {
                $fieldDefinitionId = $contentType->getFieldDefinition($relation->sourceFieldDefinitionIdentifier)->id;
                $mappedRelations[$relation->type][$fieldDefinitionId][$relation->destinationContentInfo->id] = $relation;
            }
            // Using bitwise AND as Legacy Stack stores COMMON, LINK and EMBED relation types
            // in the same entry using bitmask
            if ($relation->type & Relation::LINK) {

This code seems to be duplicated across your project.

                $mappedRelations[Relation::LINK][$relation->destinationContentInfo->id] = $relation;
            }
            if ($relation->type & Relation::EMBED) {

This code seems to be duplicated across your project.

                $mappedRelations[Relation::EMBED][$relation->destinationContentInfo->id] = $relation;
            }
        }

        // Add new relations
        foreach ($inputRelations as $relationType => $relationData) {
            if ($relationType === Relation::FIELD) {
                foreach ($relationData as $fieldDefinitionId => $contentIds) {
                    foreach (array_keys($contentIds) as $destinationContentId) {
                        if (isset($mappedRelations[$relationType][$fieldDefinitionId][$destinationContentId])) {
                            unset($mappedRelations[$relationType][$fieldDefinitionId][$destinationContentId]);
                        } else {

This code seems to be duplicated across your project.

                            $this->persistenceHandler->contentHandler()->addRelation(
                                new SPIRelationCreateStruct(
                                    array(
                                        'sourceContentId' => $sourceContentId,
                                        'sourceContentVersionNo' => $sourceContentVersionNo,
                                        'sourceFieldDefinitionId' => $fieldDefinitionId,
                                        'destinationContentId' => $destinationContentId,
                                        'type' => $relationType,
                                    )
                                )
                            );
                        }
                    }
                }
            } elseif ($relationType === Relation::LINK || $relationType === Relation::EMBED) {
                foreach (array_keys($relationData) as $destinationContentId) {
                    if (isset($mappedRelations[$relationType][$destinationContentId])) {
                        unset($mappedRelations[$relationType][$destinationContentId]);
                    } else {

This code seems to be duplicated across your project.

                        $this->persistenceHandler->contentHandler()->addRelation(
                            new SPIRelationCreateStruct(
                                array(
                                    'sourceContentId' => $sourceContentId,
                                    'sourceContentVersionNo' => $sourceContentVersionNo,
                                    'sourceFieldDefinitionId' => null,
                                    'destinationContentId' => $destinationContentId,
                                    'type' => $relationType,
                                )
                            )
                        );
                    }
                }
            }
        }

        // Remove relations not present in input set
        foreach ($mappedRelations as $relationType => $relationData) {
            foreach ($relationData as $relationEntry) {
                switch ($relationType) {
                    case Relation::FIELD:
                        foreach ($relationEntry as $relation) {
                            $this->persistenceHandler->contentHandler()->removeRelation(
                                $relation->id,
                                $relationType
                            );
                        }
                        break;
                    case Relation::LINK:
                    case Relation::EMBED:
                        $this->persistenceHandler->contentHandler()->removeRelation(
                            $relationEntry->id,
                            $relationType
                        );
                }
            }
        }
    }

    /**
     * Updates the relations for $contentId, either for $versionNo, or for all versions if not set.
     *
     * @param mixed $contentId
     * @param int $versionNo
     *
     * @return void
     */
    public function updateContentRelations($contentId, ContentType $contentType, $versionNo = null)
    {
        $contentHandler = $this->persistenceHandler->contentHandler();
        if (!isset($versionNo)) {
            $versions = $contentHandler->listVersions($contentId);
        } else {
            $versions = [$contentHandler->loadVersionInfo($contentId, $versionNo)];
        }

        foreach ($versions as $versionInfo) {
            $locationIdToContentIdMapping = $existingRelations = $relations = [];

$existingRelations is not used, you could remove the assignment.

            foreach ($contentHandler->load($contentId, $versionInfo->versionNo)->fields as $field) {
                $fieldType = $this->fieldTypeRegistry->getFieldType($field->type);
                $this->appendFieldRelations(
                    $relations,
                    $locationIdToContentIdMapping,
                    $fieldType,
                    $fieldType->fromPersistenceValue($field->value),

$fieldType->fromPersistenceValue($field->value) of type object<eZ\Publish\SPI\FieldType\Value> is not a sub-type of object<eZ\Publish\Core\FieldType\Value>. It seems like you assume a concrete implementation of the interface eZ\Publish\SPI\FieldType\Value to be always present.

                    $field->fieldDefinitionId
                );
            }
            $this->processFieldRelations(
                $relations,
                $contentId,
                $versionInfo->versionNo,
                $contentType,
                $this->loadExistingRelations($versionInfo)
            );
        }
    }

    private function loadExistingRelations(SPIVersionInfo $versionInfo)
    {
        return array_map(
            function(SPIRelation $spiRelation) use ($versionInfo) {
                return $this->domainMapper->buildRelationDomainObject(
                    $spiRelation,
                    $versionInfo->contentInfo,

$versionInfo->contentInfo is of type object<eZ\Publish\SPI\Persistence\Content\ContentInfo>, but the function expects a object<eZ\Publish\API\Repository\Values\Content\ContentInfo>.

                    $this->domainMapper->buildContentInfoDomainObject(
                        $this->persistenceHandler->contentHandler()->loadContentInfo($spiRelation->destinationContentId)
                    )
                );
            },
            $this->persistenceHandler->contentHandler()->loadRelations(
                $versionInfo->contentInfo->id,
                $versionInfo->versionNo,
                Relation::COMMON|Relation::EMBED
            )
        );
    }
}