ContentManager::getComplexFieldValue() - Code Metrics - Inspection of "Fix problem with migrations that have many steps s..." - kaliop-uk/ezmigrationbundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( e7f7b5...2ae0e9 )

by Gaetano

created 2016-08-09 09:34 UTC

ContentManager::getComplexFieldValue() A

↳ Parent: ContentManager

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	1

Metric	Value
c	1
b	0
f	1
dl	0
loc	4
rs	10
cc	1
eloc	2
nc	1
nop	3

<?php

namespace Kaliop\eZMigrationBundle\Core\Executor;

use eZ\Publish\API\Repository\FieldType;
use eZ\Publish\API\Repository\Values\ContentType\ContentType;
use eZ\Publish\API\Repository\Values\Content\ContentCreateStruct;
use eZ\Publish\API\Repository\Values\Content\ContentUpdateStruct;
use eZ\Publish\Core\FieldType\Checkbox\Value as CheckboxValue;

/**
 * Implements the actions for managing (create/update/delete) Content in the system through
 * migrations and abstracts away the eZ Publish Public API.
 *
 * @todo add support for updating of content metadata
 */
class ContentManager extends RepositoryExecutor
{
    protected $supportedStepTypes = array('content');

    protected $complexFieldManager;

    public function __construct($complexFieldManager)
    {
        $this->complexFieldManager = $complexFieldManager;
    }

    /**
     * @param string $action
     * @return ContentCollection
     * @throws \Exception
     */
    protected function matchContents($action)

    {
        if (!isset($this->dsl['object_id']) && !isset($this->dsl['remote_id']) && !isset($this->dsl['match'])) {
            throw new \Exception("The ID or remote ID of an object or a Match Condition is required to $action a new location.");
        }

        // Backwards compat
        if (!isset($this->dsl['match'])) {
            if (isset($this->dsl['object_id'])) {
                $this->dsl['match'] = array('content_id' => $this->dsl['object_id']);
            } elseif (isset($this->dsl['remote_id'])) {
                $this->dsl['match'] = array('content_remote_id' => $this->dsl['remote_id']);
            }
        }

        $match = $this->dsl['match'];

        // convert the references passed in the match
        foreach ($match as $condition => $values) {
            if (is_array($values)) {
                foreach ($values as $position => $value) {
                    if ($this->referenceResolver->isReference($value)) {
                        $match[$condition][$position] = $this->referenceResolver->getReferenceValue($value);
                    }
                }
            } else {
                if ($this->referenceResolver->isReference($values)) {
                    $match[$condition] = $this->referenceResolver->getReferenceValue($values);
                }
            }
        }

        return $this->contentMatcher->matchContent($match);
class MyClass { }

$x = new MyClass();
$x->foo = true;
    }

    /**
     * Handle the content create migration action type
     */
    protected function create()
    {
        $this->loginUser();

        $contentService = $this->repository->getContentService();
        $locationService = $this->repository->getLocationService();
        $contentTypeService = $this->repository->getContentTypeService();

        $contentTypeIdentifier = $this->dsl['content_type'];
        if ($this->referenceResolver->isReference($contentTypeIdentifier)) {
            $contentTypeIdentifier = $this->referenceResolver->getReferenceValue($contentTypeIdentifier);
        }
        $contentType = $contentTypeService->loadContentTypeByIdentifier($contentTypeIdentifier);

        // FIXME: Defaulting in language code for now
        $contentCreateStruct = $contentService->newContentCreateStruct($contentType, self::DEFAULT_LANGUAGE_CODE);
        $this->setFields($contentCreateStruct, $this->dsl['attributes'], $contentType);

        if (array_key_exists('remote_id', $this->dsl)) {
            $contentCreateStruct->remoteId = $this->dsl['remote_id'];
        }

        // instantiate a location create struct from the parent location
        $locationId = $this->dsl['main_location'];
        if ($this->referenceResolver->isReference($locationId)) {
            $locationId = $this->referenceResolver->getReferenceValue($locationId);
        }
        $locationCreateStruct = $locationService->newLocationCreateStruct($locationId);
        if (array_key_exists('remote_id', $this->dsl)) {
            $locationCreateStruct->remoteId = $this->dsl['remote_id'] . '_location';
        }

        if (array_key_exists('priority', $this->dsl)) {
            $locationCreateStruct->priority = $this->dsl['priority'];
        }

        $locations = array($locationCreateStruct);

        if (array_key_exists('other_locations', $this->dsl)) {
            foreach ($this->dsl['other_locations'] as $otherLocation) {

                $locationId = $otherLocation;
                if ($this->referenceResolver->isReference($locationId)) {
                    $locationId = $this->referenceResolver->getReferenceValue($otherLocation);
                }
                $secondaryLocationCreateStruct = $locationService->newLocationCreateStruct($locationId);
                array_push($locations, $secondaryLocationCreateStruct);
            }
        }

        // create a draft using the content and location create struct and publish it
        $draft = $contentService->createContent($contentCreateStruct, $locations);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        $content = $contentService->publishVersion($draft->versionInfo);

        $this->setReferences($content);
    }

    /**
     * Handle the content update migration action type
     *
     * @todo handle updating of more metadata fields
     */
    protected function update()
    {
        $this->loginUser();

        $contentService = $this->repository->getContentService();
        $contentTypeService = $this->repository->getContentTypeService();

        /*if (isset($this->dsl['object_id'])) {

            $objectId = $this->dsl['object_id'];
            if ($this->referenceResolver->isReference($objectId)) {
                $objectId = $this->referenceResolver->getReferenceValue($objectId);
            }
            $contentToUpdate = $contentService->loadContent($objectId);
            $contentInfo = $contentToUpdate->contentInfo;
        } else {
            $remoteId = $this->dsl['remote_id'];
            if ($this->referenceResolver->isReference($remoteId)) {
                $remoteId = $this->referenceResolver->getReferenceValue($remoteId);
            }

            //try {
                $contentInfo = $contentService->loadContentInfoByRemoteId($remoteId);
            // disabled in v2: we disallow this. For matching location-remote-id, use the 'match' keyword
            //} catch (\eZ\Publish\API\Repository\Exceptions\NotFoundException $e) {
            //    $location = $this->repository->getLocationService()->loadLocationByRemoteId($remoteId);
            //    $contentInfo = $location->contentInfo;
            //}
        }*/

        $contentCollection = $this->matchContents('update');

        if (count($contentCollection) > 1 && array_key_exists('references', $this->dsl)) {
            throw new \Exception("Can not execute Content update because multiple contents match, and a references section is specified in the dsl. References can be set when only 1 content matches");
        }

        $contentType = null;

        foreach ($contentCollection as $content) {
            $contentInfo = $content->contentInfo;

            if ($contentType == null) {
                $contentType = $contentTypeService->loadContentType($contentInfo->contentTypeId);
            }

            $contentUpdateStruct = $contentService->newContentUpdateStruct();

            if (array_key_exists('attributes', $this->dsl)) {
                $this->setFields($contentUpdateStruct, $this->dsl['attributes'], $contentType);
            }

            $draft = $contentService->createContentDraft($contentInfo);
            $contentService->updateContent($draft->versionInfo,$contentUpdateStruct);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
            $content = $contentService->publishVersion($draft->versionInfo);

            if (array_key_exists('new_remote_id', $this->dsl)) {
                // Update object remote ID
                $contentMetaDataUpdateStruct = $contentService->newContentMetadataUpdateStruct();
                $contentMetaDataUpdateStruct->remoteId = $this->dsl['new_remote_id'];
                $content = $contentService->updateContentMetadata($content->contentInfo, $contentMetaDataUpdateStruct);

                // Update main location remote ID
                // removed in v2: this is NOT generic!
                //$locationService = $this->repository->getLocationService();

                //$locationUpdateStruct = $locationService->newLocationUpdateStruct();

                //$locationUpdateStruct->remoteId = $this->dsl['new_remote_id'] . '_location';

                //$location = $locationService->loadLocation($content->contentInfo->mainLocationId);

                //$locationService->updateLocation($location, $locationUpdateStruct);

            }

            $this->setReferences($contentCollection);
        }
    }

    /**
     * Handle the content delete migration action type
     */
    protected function delete()
    {
        $this->loginUser();

        $contentService = $this->repository->getContentService();

        $contentCollection = $this->matchContents('delete');

        foreach ($contentCollection as $content) {
            $contentService->deleteContent($content->contentInfo);
        }
    }

    /**
     * Helper function to set the fields of a ContentCreateStruct based on the DSL attribute settings.
     *
     * @param ContentCreateStruct|ContentUpdateStruct $createOrUpdateStruct
     * @param ContentType $contentType
     * @param array $fields
     */
    protected function setFields(&$createOrUpdateStruct, array $fields, ContentType $contentType)
    {
        foreach ($fields as $field) {
            // each $field is one key value pair
            // eg.: $field = array($fieldIdentifier => $fieldValue)

            $fieldIdentifier = key($field);

            $fieldType = $contentType->fieldDefinitionsByIdentifier[$fieldIdentifier];


            if (is_array($field[$fieldIdentifier])) {
                // Complex field needs special handling eg.: ezimage, ezbinaryfile
                $fieldValue = $this->getComplexFieldValue($field[$fieldIdentifier], $fieldType, $this->context);
            } else {
                // Primitive field eg.: ezstring, ezxml etc.
                $fieldValue = $this->getSingleFieldValue($field[$fieldIdentifier], $fieldType, $this->context);
            }

            $createOrUpdateStruct->setField($fieldIdentifier, $fieldValue, self::DEFAULT_LANGUAGE_CODE);
        }
    }

    /**
     * Create the field value for a primitive field
     * This function is needed to get past validation on Checkbox fieldtype (eZP bug)
     *
     * @param mixed $value
     * @param FieldType $fieldType
     * @param array $context
     * @throws \InvalidArgumentException
     * @return object
     */
    protected function getSingleFieldValue($value, FieldType $fieldType, array $context = array())

    {
        switch ($fieldType->getFieldTypeIdentifier()) {
            case 'ezboolean':
                $fieldValue = new CheckboxValue(($value == 1) ? true : false);
                break;
            default:
                $fieldValue = $value;
        }

        if ($this->referenceResolver->isReference($value)) {
            $fieldValue = $this->referenceResolver->getReferenceValue($value);
        }

        return $fieldValue;
    }

    /**
     * Create the field value for a complex field eg.: ezimage, ezfile
     *
     * @param FieldType $fieldType
     * @param array $fieldValueArray
     * @param array $context
     * @return object
     */
    protected function getComplexFieldValue(array $fieldValueArray, FieldType $fieldType, array $context = array())
    {
        return $this->complexFieldManager->getComplexFieldValue($fieldType, $fieldValueArray, $context);
    }

    /**
     * Sets references to certain content attributes.
     * The Content Manager currently supports setting references to object_id and location_id
     *
     * @param \eZ\Publish\API\Repository\Values\Content\Content $content
     * @throws \InvalidArgumentException When trying to set a reference to an unsupported attribute
     * @return boolean
     *
     * @todo add support for other attributes: contentTypeId, contentTypeIdentifier, section, etc...
     */
    protected function setReferences($content)

    {
        if (!array_key_exists('references', $this->dsl)) {
            return false;
        }

        foreach ($this->dsl['references'] as $reference) {

            switch ($reference['attribute']) {
                case 'object_id':
                case 'id':
                    $value = $content->id;
                    break;
                case 'location_id':
                    $value = $content->contentInfo->mainLocationId;
                    break;
                default:
                    throw new \InvalidArgumentException('Content Manager does not support setting references for attribute ' . $reference['attribute']);
            }

            $this->referenceResolver->addReference($reference['identifier'], $value);
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
        }

        return true;
    }
}


1		<?php
2
3		namespace Kaliop\eZMigrationBundle\Core\Executor;
4
5		use eZ\Publish\API\Repository\FieldType;
6		use eZ\Publish\API\Repository\Values\ContentType\ContentType;
7		use eZ\Publish\API\Repository\Values\Content\ContentCreateStruct;
8		use eZ\Publish\API\Repository\Values\Content\ContentUpdateStruct;
9		use eZ\Publish\Core\FieldType\Checkbox\Value as CheckboxValue;
10
11		/**
12		* Implements the actions for managing (create/update/delete) Content in the system through
13		* migrations and abstracts away the eZ Publish Public API.
14		*
15		* @todo add support for updating of content metadata
16		*/
17		class ContentManager extends RepositoryExecutor
18		{
19		protected $supportedStepTypes = array('content');
20
21		protected $complexFieldManager;
22
23		public function __construct($complexFieldManager)
24		{
25		$this->complexFieldManager = $complexFieldManager;
26		}
27
28		/**
29		* @param string $action
30		* @return ContentCollection
31		* @throws \Exception
32		*/
33	View Code Duplication	protected function matchContents($action)
		0 ignored issues – show Duplication introduced 2016-08-05 17:20 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
34		{
35		if (!isset($this->dsl['object_id']) && !isset($this->dsl['remote_id']) && !isset($this->dsl['match'])) {
36		throw new \Exception("The ID or remote ID of an object or a Match Condition is required to $action a new location.");
37		}
38
39		// Backwards compat

kaliop-uk / ezmigrationbundle

Push — master ( e7f7b5...2ae0e9 )

ContentManager::getComplexFieldValue() A

Complexity

Size

Duplication

Importance

Available Fixes

Duplication Side-by-Side

Filter issues like