ContentManager::delete() - Code Metrics - Inspection of "Better error messages from migrate and generate co..." - kaliop-uk/ezmigrationbundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 956196...175692 )

by Gaetano

created 2016-08-05 17:10 UTC

ContentManager::delete() A

↳ Parent: ContentManager

Complexity

Conditions	2
Paths	2

Size

Total Lines	12
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Importance

Changes	3
Bugs	0	Features	0

Metric	Value
c	3
b	0
f	0
dl	0
loc	12
rs	9.4285
cc	2
eloc	6
nc	2
nop	0

<?php

namespace Kaliop\eZMigrationBundle\Core\Executor;

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']);

        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);
        $content = $contentService->publishVersion($draft->versionInfo);

        $this->setReferences($content);
    }

    /**
     * Handle the content update migration action type
     */
    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) {
                $contentTypeService->loadContentType($contentInfo->contentTypeId);
            }

            $contentUpdateStruct = $contentService->newContentUpdateStruct();

            if (array_key_exists('attributes', $this->dsl)) {
                $this->setFieldsToUpdate($contentUpdateStruct, $this->dsl['attributes'], $contentType);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            }

            $draft = $contentService->createContentDraft($contentInfo);
            $contentService->updateContent($draft->versionInfo,$contentUpdateStruct);
            $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 $createStruct
     * @param array $fields
     */
    protected function setFields(ContentCreateStruct &$createStruct, array $fields)

    {
        foreach ($fields as $field) {
            // each $field is one key value pair
            // eg.: $field = array($fieldIdentifier => $fieldValue)

            $fieldIdentifier = key($field);

            $fieldTypeIdentifier = $createStruct->contentType->fieldDefinitionsByIdentifier[$fieldIdentifier]->fieldTypeIdentifier;


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

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

    /**
     * Helper function to set the fields of a ContentUpdateStruct based on the DSL attribute settings.
     *
     * @param ContentUpdateStruct $updateStruct
     * @param array $fields
     */
    protected function setFieldsToUpdate(ContentUpdateStruct &$updateStruct, array $fields, ContentType $contentType)

    {
        foreach ($fields as $field) {
            // each $field is one key value pair
            // eg.: $field = array($fieldIdentifier => $fieldValue)

            $fieldIdentifier = key($field);

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


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

            $updateStruct->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 string $fieldTypeIdentifier
     * @param string $identifier
     * @param mixed $value
     * @throws \InvalidArgumentException
     * @return object
     */
    protected function handleSingleField($fieldTypeIdentifier, $identifier, $value)

    {
        switch ($fieldTypeIdentifier) {
            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 string $fieldTypeIdentifier
     * @param array $fieldValueArray
     * @param array $context
     * @return object
     */
    protected function handleComplexField($fieldTypeIdentifier, array $fieldValueArray, array $context = array())
    {
        return $this->complexFieldManager->getComplexFieldValue($fieldTypeIdentifier, $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\Values\ContentType\ContentType;
6		use eZ\Publish\API\Repository\Values\Content\ContentCreateStruct;
7		use eZ\Publish\API\Repository\Values\Content\ContentUpdateStruct;
8		use eZ\Publish\Core\FieldType\Checkbox\Value as CheckboxValue;
9
10		/**
11		* Implements the actions for managing (create/update/delete) Content in the system through
12		* migrations and abstracts away the eZ Publish Public API.
13		*
14		* @todo add support for updating of content metadata
15		*/
16		class ContentManager extends RepositoryExecutor
17		{
18		protected $supportedStepTypes = array('content');
19
20		protected $complexFieldManager;
21
22		public function __construct($complexFieldManager)
23		{
24		$this->complexFieldManager = $complexFieldManager;
25		}
26
27		/**
28		* @param string $action
29		* @return ContentCollection
30		* @throws \Exception
31		*/
32	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...
33		{
34		if (!isset($this->dsl['object_id']) && !isset($this->dsl['remote_id']) && !isset($this->dsl['match'])) {
35		throw new \Exception("The ID or remote ID of an object or a Match Condition is required to $action a new location.");
36		}
37
38		// Backwards compat
39		if (!isset($this->dsl['match'])) {

kaliop-uk / ezmigrationbundle

Push — master ( 956196...175692 )

ContentManager::delete() A

Complexity

Size

Duplication

Importance

Available Fixes

Duplication Side-by-Side

Filter issues like