ExtendConfigDumper - Code Metrics - orocrm/platform - Measure and Improve Code Quality continuously with Scrutinizer

ExtendConfigDumper F
last analyzed 2016-05-19 07:51 UTC

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	531
Duplicated Lines	3.2 %

Coupling/Cohesion

Components	1
Dependencies	16

Metric	Value
wmc	91
lcom	1
cbo	16
dl	17
loc	531
rs	1.5789

14 Methods

Rating	Name	Duplication	Size	Complexity
A	getCacheDir()	0	4	1
A	setCacheDir()	0	4	1
A	__construct()	0	15	1
A	addExtension()	0	4	1
D	updateConfig()	0	42	10
B	dump()	0	28	5
C	checkConfig()	8	44	12
B	clear()	0	26	6
A	getExtensions()	9	9	2
C	checkFieldSchema()	0	47	8
F	checkSchema()	0	114	25
D	updateStateValues()	0	35	9
B	updatePendingConfigs()	0	27	6
A	updateFieldState()	0	13	4

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like ExtendConfigDumper often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use ExtendConfigDumper, and based on these observations, apply Extract Interface, too.

<?php

namespace Oro\Bundle\EntityExtendBundle\Tools;

use Doctrine\Common\Cache\ClearableCache;
use Doctrine\ORM\Mapping\ClassMetadataFactory;

use Symfony\Component\Filesystem\Filesystem;

use Oro\Bundle\EntityConfigBundle\Config\ConfigInterface;
use Oro\Bundle\EntityConfigBundle\Config\ConfigManager;
use Oro\Bundle\EntityConfigBundle\Config\EntityManagerBag;
use Oro\Bundle\EntityConfigBundle\Config\Id\FieldConfigId;
use Oro\Bundle\EntityExtendBundle\EntityConfig\ExtendScope;
use Oro\Bundle\EntityExtendBundle\Extend\FieldTypeHelper;
use Oro\Bundle\EntityExtendBundle\Extend\RelationType;
use Oro\Bundle\EntityConfigBundle\Provider\ConfigProvider;
use Oro\Bundle\EntityExtendBundle\Tools\DumperExtensions\AbstractEntityConfigDumperExtension;

/**
 * @SuppressWarnings(PHPMD.ExcessiveClassComplexity)
 */
class ExtendConfigDumper
{
    const ACTION_PRE_UPDATE = 'preUpdate';
    const ACTION_POST_UPDATE = 'postUpdate';

    /** @deprecated Use ExtendHelper::getExtendEntityProxyClassName and ExtendHelper::ENTITY_NAMESPACE instead */
    const ENTITY = 'Extend\\Entity\\';

    const DEFAULT_PREFIX = 'default_';

    /** @var string */
    protected $cacheDir;

    /** @var EntityManagerBag */
    protected $entityManagerBag;

    /** @var ConfigManager */
    protected $configManager;

    /** @var ExtendDbIdentifierNameGenerator */
    protected $nameGenerator;

    /** @var FieldTypeHelper */
    protected $fieldTypeHelper;

    /** @var EntityGenerator */
    protected $entityGenerator;

    /** @var array */
    protected $extensions = [];

    /** @var AbstractEntityConfigDumperExtension[]|null */
    protected $sortedExtensions;

    /**
     * @param EntityManagerBag                $entityManagerBag
     * @param ConfigManager                   $configManager
     * @param ExtendDbIdentifierNameGenerator $nameGenerator
     * @param FieldTypeHelper                 $fieldTypeHelper
     * @param EntityGenerator                 $entityGenerator
     * @param string                          $cacheDir
     */
    public function __construct(
        EntityManagerBag $entityManagerBag,
        ConfigManager $configManager,
        ExtendDbIdentifierNameGenerator $nameGenerator,
        FieldTypeHelper $fieldTypeHelper,
        EntityGenerator $entityGenerator,
        $cacheDir
    ) {
        $this->entityManagerBag = $entityManagerBag;
        $this->configManager    = $configManager;
        $this->nameGenerator    = $nameGenerator;
        $this->fieldTypeHelper  = $fieldTypeHelper;
        $this->entityGenerator  = $entityGenerator;
        $this->cacheDir         = $cacheDir;
    }

    /**
     * Gets the cache directory
     *
     * @return string
     */
    public function getCacheDir()
    {
        return $this->cacheDir;
    }

    /**
     * Sets the cache directory
     *
     * @param string $cacheDir
     */
    public function setCacheDir($cacheDir)
    {
        $this->cacheDir = $cacheDir;
    }

    /**
     * @param AbstractEntityConfigDumperExtension $extension
     * @param int                                 $priority
     */
    public function addExtension(AbstractEntityConfigDumperExtension $extension, $priority = 0)
    {
        $this->extensions[$priority][] = $extension;
    }

    /**
     * Update config.
     *
     * @param callable|null $filter function (ConfigInterface $config) : bool
     * @param bool $updateCustom
     */
    public function updateConfig($filter = null, $updateCustom = false)
    {
        $aliases = ExtendClassLoadingUtils::getAliases($this->cacheDir);
        $this->clear(true);

        if ($updateCustom) {
            $this->updatePendingConfigs();
        }

        $extensions = $this->getExtensions();

        foreach ($extensions as $extension) {
            if ($extension->supports(self::ACTION_PRE_UPDATE)) {
                $extension->preUpdate();
            }
        }

        $configProvider = $this->configManager->getProvider('extend');

        $extendConfigs = null === $filter
            ? $configProvider->getConfigs(null, true)
            : $configProvider->filter($filter, null, true);
        foreach ($extendConfigs as $extendConfig) {
            if ($extendConfig->is('upgradeable')) {
                if ($extendConfig->is('is_extend')) {
                    $this->checkSchema($extendConfig, $configProvider, $aliases, $filter);
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}
                }

                $this->updateStateValues($extendConfig, $configProvider);
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}
            }
        }

        foreach ($extensions as $extension) {
            if ($extension->supports(self::ACTION_POST_UPDATE)) {
                $extension->postUpdate();
            }
        }

        $this->configManager->flush();

        $this->clear();
    }

    public function dump()
    {
        $schemas       = [];
        $extendConfigs = $this->configManager->getProvider('extend')->getConfigs(null, true);
        foreach ($extendConfigs as $extendConfig) {
            $schema    = $extendConfig->get('schema');
            $className = $extendConfig->getId()->getClassName();

            if ($schema) {
                $schemas[$className]                 = $schema;
                $schemas[$className]['relationData'] = $extendConfig->get('relation', false, []);
            }
        }

        $cacheDir = $this->entityGenerator->getCacheDir();
        if ($cacheDir === $this->cacheDir) {
            $this->entityGenerator->generate($schemas);
        } else {
            $this->entityGenerator->setCacheDir($this->cacheDir);
            try {
                $this->entityGenerator->generate($schemas);
                $this->entityGenerator->setCacheDir($cacheDir);
            } catch (\Exception $e) {
                $this->entityGenerator->setCacheDir($cacheDir);
                throw $e;
            }
        }
    }

    /**
     * Makes sure that extended entity configs are ready to be processing by other config related commands
     */
    public function checkConfig()
    {
        $hasAliases = file_exists(ExtendClassLoadingUtils::getAliasesPath($this->cacheDir));
        if ($hasAliases) {
            return;
        }

        $hasChanges    = false;
        $extendConfigs = $this->configManager->getProvider('extend')->getConfigs(null, true);
        foreach ($extendConfigs as $extendConfig) {
            $schema = $extendConfig->get('schema', false, []);

            // make sure that inheritance definition for extended entities is up-to-date
            // this check is required to avoid doctrine mapping exceptions during the platform update
            // in case if a parent class is changed in a new version of a code
            if (isset($schema['type'], $schema['class'], $schema['entity']) && $schema['type'] === 'Extend') {
                $entityClassName = $schema['entity'];
                $parentClassName = get_parent_class($schema['class']);
                if ($parentClassName !== $entityClassName) {
                    $inheritClassName = get_parent_class($parentClassName);

                    $hasSchemaChanges = false;
                    if (!isset($schema['parent']) || $schema['parent'] !== $parentClassName) {
                        $hasSchemaChanges = true;
                        $schema['parent'] = $parentClassName;
                    }
                    if (!isset($schema['inherit']) || $schema['inherit'] !== $inheritClassName) {
                        $hasSchemaChanges  = true;
                        $schema['inherit'] = $inheritClassName;
                    }

                    if ($hasSchemaChanges) {
                        $hasChanges = true;
                        $extendConfig->set('schema', $schema);
                        $this->configManager->persist($extendConfig);
                    }
                }
            }
        }

        if ($hasChanges) {
            $this->configManager->flush();
        }
    }

    /**
     * Removes the entity proxies and metadata from the cache
     *
     * @param bool $keepEntityProxies Set TRUE if proxies for custom and extend entities should not be deleted
     */
    public function clear($keepEntityProxies = false)
    {
        $filesystem = new Filesystem();

        if ($keepEntityProxies) {
            $aliasesPath = ExtendClassLoadingUtils::getAliasesPath($this->cacheDir);
            if ($filesystem->exists($aliasesPath)) {
                $filesystem->remove($aliasesPath);
            }
        } else {
            $baseCacheDir = ExtendClassLoadingUtils::getEntityBaseCacheDir($this->cacheDir);
            if ($filesystem->exists($baseCacheDir)) {
                $filesystem->remove([$baseCacheDir]);
            }
            $filesystem->mkdir(ExtendClassLoadingUtils::getEntityCacheDir($this->cacheDir));
        }

        foreach ($this->entityManagerBag->getEntityManagers() as $em) {
            /** @var ClassMetadataFactory $metadataFactory */
            $metadataFactory = $em->getMetadataFactory();
            $metadataCache   = $metadataFactory->getCacheDriver();
            if ($metadataCache instanceof ClearableCache) {
                $metadataCache->deleteAll();
            }
        }
    }

    /**
     * Return sorted extensions
     *
     * @return AbstractEntityConfigDumperExtension[]
     */
    protected function getExtensions()
    {
        if (null === $this->sortedExtensions) {
            krsort($this->extensions);
            $this->sortedExtensions = call_user_func_array('array_merge', $this->extensions);
        }

        return $this->sortedExtensions;
    }

    /**
     * Check fields parameters and update field config
     *
     * @param string          $entityName
     * @param ConfigInterface $fieldConfig
     * @param array           $relationProperties
     * @param array           $defaultProperties
     * @param array           $properties
     * @param array           $doctrine
     */
    protected function checkFieldSchema(
        $entityName,
        ConfigInterface $fieldConfig,
        array &$relationProperties,
        array &$defaultProperties,
        array &$properties,
        array &$doctrine
    ) {
        if ($fieldConfig->is('is_extend')) {
            /** @var FieldConfigId $fieldConfigId */
            $fieldConfigId = $fieldConfig->getId();
            $fieldName     = $fieldConfigId->getFieldName();
            $fieldType     = $fieldConfigId->getFieldType();
            $isDeleted     = $fieldConfig->is('is_deleted');
            $columnName    = $fieldConfig->get('column_name', false, $fieldName);

            $underlyingFieldType = $this->fieldTypeHelper->getUnderlyingType($fieldType);
            if (in_array($underlyingFieldType, RelationType::$anyToAnyRelations, true)) {
                $relationProperties[$fieldName] = [];
                if ($isDeleted) {
                    $relationProperties[$fieldName]['private'] = true;
                }
                if ($underlyingFieldType !== RelationType::MANY_TO_ONE && !$fieldConfig->is('without_default')) {
                    $defaultName = self::DEFAULT_PREFIX . $fieldName;

                    $defaultProperties[$defaultName] = [];
                    if ($isDeleted) {
                        $defaultProperties[$defaultName]['private'] = true;
                    }
                }
            } else {
                $properties[$fieldName] = [];
                if ($isDeleted) {
                    $properties[$fieldName]['private'] = true;
                }

                $doctrine[$entityName]['fields'][$fieldName] = [
                    'column'    => $columnName,
                    'type'      => $fieldType,
                    'nullable'  => true,
                    'length'    => $fieldConfig->get('length'),
                    'precision' => $fieldConfig->get('precision'),
                    'scale'     => $fieldConfig->get('scale'),
                ];
            }
        }
    }

    /**
     * @SuppressWarnings(PHPMD.NPathComplexity)
     * @SuppressWarnings(PHPMD.CyclomaticComplexity)
     * @SuppressWarnings(PHPMD.ExcessiveMethodLength)
     *
     * @param ConfigInterface $extendConfig
     * @param ConfigProvider  $configProvider
     * @param array|null      $aliases
     * @param callable|null   $filter function (ConfigInterface $config) : bool
     */
    protected function checkSchema(
        ConfigInterface $extendConfig,
        ConfigProvider $configProvider,
        $aliases,
        $filter = null
    ) {
        $className  = $extendConfig->getId()->getClassName();
        $doctrine   = [];
        $entityName = $className;

        if (ExtendHelper::isCustomEntity($className)) {
            $type      = 'Custom';
            $tableName = $extendConfig->get('table');
            if (!$tableName) {
                $tableName = $this->nameGenerator->generateCustomEntityTableName($className);
            }
            $doctrine[$entityName] = [
                'type'  => 'entity',
                'table' => $tableName
            ];
            // add 'id' field only for Custom entity without inheritance
            if (!$extendConfig->has('inherit')) {
                $doctrine[$entityName]['fields'] = [
                    'id' => ['type' => 'integer', 'id' => true, 'generator' => ['strategy' => 'AUTO']]
                ];
            }
        } else {
            $type                  = 'Extend';
            $entityName            = $extendConfig->get('extend_class');
            $doctrine[$entityName] = [
                'type'   => 'mappedSuperclass',
                'fields' => [],
            ];
        }

        $schema             = $extendConfig->get('schema', false, []);
        $properties         = isset($schema['property']) && null !== $filter ? $schema['property'] : [];
        $relationProperties = isset($schema['relation']) && null !== $filter ? $schema['relation'] : [];
        $defaultProperties  = isset($schema['default']) && null !== $filter ? $schema['default'] : [];
        $addRemoveMethods   = isset($schema['addremove']) && null !== $filter ? $schema['addremove'] : [];

        $fieldConfigs = null === $filter
            ? $configProvider->getConfigs($className, true)
            : $configProvider->filter($filter, $className, true);
        foreach ($fieldConfigs as $fieldConfig) {
            $this->updateFieldState($fieldConfig);
            $this->checkFieldSchema(
                $entityName,
                $fieldConfig,
                $relationProperties,
                $defaultProperties,
                $properties,
                $doctrine
            );
        }

        $relations = $extendConfig->get('relation', false, []);
        foreach ($relations as $relation) {
            /** @var FieldConfigId $fieldId */
            $fieldId = $relation['field_id'];
            if (!$fieldId) {
                continue;
            }

            $fieldName = $fieldId->getFieldName();
            $isDeleted = $configProvider->hasConfig($fieldId->getClassName(), $fieldName)
                ? $configProvider->getConfig($fieldId->getClassName(), $fieldName)->is('is_deleted')
                : false;
            if (!isset($relationProperties[$fieldName])) {
                $relationProperties[$fieldName] = [];
                if ($isDeleted) {
                    $relationProperties[$fieldName]['private'] = true;
                }
            }
            if (!$isDeleted && $fieldId->getFieldType() !== RelationType::MANY_TO_ONE) {
                $addRemoveMethods[$fieldName]['self'] = $fieldName;

                /** @var FieldConfigId $targetFieldId */
                $targetFieldId = $relation['target_field_id'];
                if ($targetFieldId) {
                    $fieldType = $fieldId->getFieldType();

                    $addRemoveMethods[$fieldName]['target']              = $targetFieldId->getFieldName();
                    $addRemoveMethods[$fieldName]['is_target_addremove'] = $fieldType === RelationType::MANY_TO_MANY;
                }
            }
        }

        $schema = [
            'class'     => $className,
            'entity'    => $entityName,
            'type'      => $type,
            'property'  => $properties,
            'relation'  => $relationProperties,
            'default'   => $defaultProperties,
            'addremove' => $addRemoveMethods,
            'doctrine'  => $doctrine,
        ];

        if ($type === 'Extend') {
            $parentClassName = get_parent_class($className);
            if ($parentClassName === $entityName) {
                $parentClassName = $aliases[$entityName];
            }
            $schema['parent']  = $parentClassName;
            $schema['inherit'] = get_parent_class($parentClassName);
        } elseif ($extendConfig->has('inherit')) {
            $schema['inherit'] = $extendConfig->get('inherit');
        }

        $extendConfig->set('schema', $schema);

        $this->configManager->persist($extendConfig);
    }

    /**
     * @param ConfigInterface $fieldConfig
     */
    protected function updateFieldState(ConfigInterface $fieldConfig)
    {
        if ($fieldConfig->is('state', ExtendScope::STATE_DELETE)) {
            $fieldConfig->set('is_deleted', true);
            $this->configManager->persist($fieldConfig);
        } elseif (!$fieldConfig->is('state', ExtendScope::STATE_ACTIVE)) {
            if ($fieldConfig->is('state', ExtendScope::STATE_RESTORE)) {
                $fieldConfig->set('is_deleted', false);
            }
            $fieldConfig->set('state', ExtendScope::STATE_ACTIVE);
            $this->configManager->persist($fieldConfig);
        }
    }

    /**
     * @param ConfigInterface $entityConfig
     * @param ConfigProvider  $configProvider
     */
    protected function updateStateValues(ConfigInterface $entityConfig, ConfigProvider $configProvider)
    {
        if ($entityConfig->is('state', ExtendScope::STATE_DELETE)) {
            // mark entity as deleted
            if (!$entityConfig->is('is_deleted')) {
                $entityConfig->set('is_deleted', true);
                $this->configManager->persist($entityConfig);
            }

            // mark all fields as deleted
            $fieldConfigs = $configProvider->getConfigs($entityConfig->getId()->getClassName(), true);
            foreach ($fieldConfigs as $fieldConfig) {
                if (!$fieldConfig->is('is_deleted')) {
                    $fieldConfig->set('is_deleted', true);
                    $this->configManager->persist($fieldConfig);
                }
            }
        } elseif (!$entityConfig->is('state', ExtendScope::STATE_ACTIVE)) {
            $hasNotActiveFields = false;

            $fieldConfigs = $configProvider->getConfigs($entityConfig->getId()->getClassName(), true);
            foreach ($fieldConfigs as $fieldConfig) {
                if (!$fieldConfig->in('state', [ExtendScope::STATE_ACTIVE, ExtendScope::STATE_DELETE])) {
                    $hasNotActiveFields = true;
                    break;
                }
            }

            // Set entity state to active if all fields are active or deleted
            if (!$hasNotActiveFields) {
                $entityConfig->set('state', ExtendScope::STATE_ACTIVE);
                $this->configManager->persist($entityConfig);
            }
        }
    }

    /**
     * Updates pending configs
     */
    protected function updatePendingConfigs()
    {
        $pendingChanges = [];

        $configs = $this->configManager->getProvider('extend')->getConfigs();
        foreach ($configs as $config) {
            $configPendingChanges = $config->get('pending_changes');
            if (!$configPendingChanges) {
                continue;
            }

            $pendingChanges[$config->getId()->getClassName()] = $configPendingChanges;
            $config->set('pending_changes', []);
            $this->configManager->persist($config);
        }

        foreach ($pendingChanges as $className => $changes) {
            foreach ($changes as $scope => $values) {
                $provider = $this->configManager->getProvider($scope);
                $config = $provider->getConfig($className);
                foreach ($values as $code => $value) {
                    $config->set($code, ExtendHelper::updatedPendingValue($config->get($code), $value));
                }
                $this->configManager->persist($config);
            }
        }
    }
}


1		<?php
2
3		namespace Oro\Bundle\EntityExtendBundle\Tools;
4
5		use Doctrine\Common\Cache\ClearableCache;
6		use Doctrine\ORM\Mapping\ClassMetadataFactory;
7
8		use Symfony\Component\Filesystem\Filesystem;
9
10		use Oro\Bundle\EntityConfigBundle\Config\ConfigInterface;
11		use Oro\Bundle\EntityConfigBundle\Config\ConfigManager;
12		use Oro\Bundle\EntityConfigBundle\Config\EntityManagerBag;
13		use Oro\Bundle\EntityConfigBundle\Config\Id\FieldConfigId;
14		use Oro\Bundle\EntityExtendBundle\EntityConfig\ExtendScope;
15		use Oro\Bundle\EntityExtendBundle\Extend\FieldTypeHelper;
16		use Oro\Bundle\EntityExtendBundle\Extend\RelationType;
17		use Oro\Bundle\EntityConfigBundle\Provider\ConfigProvider;
18		use Oro\Bundle\EntityExtendBundle\Tools\DumperExtensions\AbstractEntityConfigDumperExtension;
19
20		/**
21		* @SuppressWarnings(PHPMD.ExcessiveClassComplexity)
22		*/
23		class ExtendConfigDumper
24		{
25		const ACTION_PRE_UPDATE = 'preUpdate';
26		const ACTION_POST_UPDATE = 'postUpdate';
27
28		/** @deprecated Use ExtendHelper::getExtendEntityProxyClassName and ExtendHelper::ENTITY_NAMESPACE instead */
29		const ENTITY = 'Extend\\Entity\\';
30
31		const DEFAULT_PREFIX = 'default_';
32
33		/** @var string */
34		protected $cacheDir;
35
36		/** @var EntityManagerBag */
37		protected $entityManagerBag;
38
39		/** @var ConfigManager */
40		protected $configManager;
41
42		/** @var ExtendDbIdentifierNameGenerator */
43		protected $nameGenerator;
44
45		/** @var FieldTypeHelper */
46		protected $fieldTypeHelper;
47
48		/** @var EntityGenerator */
49		protected $entityGenerator;
50
51		/** @var array */
52		protected $extensions = [];
53
54		/** @var AbstractEntityConfigDumperExtension[]\|null */
55		protected $sortedExtensions;
56
57		/**
58		* @param EntityManagerBag $entityManagerBag
59		* @param ConfigManager $configManager
60		* @param ExtendDbIdentifierNameGenerator $nameGenerator
61		* @param FieldTypeHelper $fieldTypeHelper
62		* @param EntityGenerator $entityGenerator
63		* @param string $cacheDir
64		*/
65		public function __construct(
66		EntityManagerBag $entityManagerBag,
67		ConfigManager $configManager,
68		ExtendDbIdentifierNameGenerator $nameGenerator,
69		FieldTypeHelper $fieldTypeHelper,
70		EntityGenerator $entityGenerator,
71		$cacheDir
72		) {
73		$this->entityManagerBag = $entityManagerBag;
74		$this->configManager = $configManager;
75		$this->nameGenerator = $nameGenerator;
76		$this->fieldTypeHelper = $fieldTypeHelper;
77		$this->entityGenerator = $entityGenerator;
78		$this->cacheDir = $cacheDir;
79		}
80
81		/**
82		* Gets the cache directory
83		*
84		* @return string
85		*/
86		public function getCacheDir()
87		{
88		return $this->cacheDir;
89		}
90
91		/**
92		* Sets the cache directory
93		*
94		* @param string $cacheDir
95		*/
96		public function setCacheDir($cacheDir)
97		{
98		$this->cacheDir = $cacheDir;
99		}
100
101		/**
102		* @param AbstractEntityConfigDumperExtension $extension
103		* @param int $priority
104		*/
105		public function addExtension(AbstractEntityConfigDumperExtension $extension, $priority = 0)
106		{
107		$this->extensions[$priority][] = $extension;
108		}
109
110		/**
111		* Update config.
112		*
113		* @param callable\|null $filter function (ConfigInterface $config) : bool
114		* @param bool $updateCustom
115		*/
116		public function updateConfig($filter = null, $updateCustom = false)
117		{
118		$aliases = ExtendClassLoadingUtils::getAliases($this->cacheDir);
119		$this->clear(true);
120
121		if ($updateCustom) {
122		$this->updatePendingConfigs();
123		}
124
125		$extensions = $this->getExtensions();
126
127		foreach ($extensions as $extension) {
128		if ($extension->supports(self::ACTION_PRE_UPDATE)) {
129		$extension->preUpdate();
130		}
131		}
132
133		$configProvider = $this->configManager->getProvider('extend');
134
135		$extendConfigs = null === $filter
136		? $configProvider->getConfigs(null, true)
137		: $configProvider->filter($filter, null, true);
138		foreach ($extendConfigs as $extendConfig) {
139		if ($extendConfig->is('upgradeable')) {
140		if ($extendConfig->is('is_extend')) {
141		$this->checkSchema($extendConfig, $configProvider, $aliases, $filter);
		0 ignored issues – show Bug introduced 2016-03-02 07:39 UTC by Report Bug Copy Issue Report It seems like `$configProvider` defined by `$this->configManager->getProvider('extend')` on line `133` can be `null`; however, `Oro\Bundle\EntityExtendB...igDumper::checkSchema()` does not accept `null`, maybe add an additional type check? Unless you are absolutely sure that the expression can never be null because of other conditions, we strongly recommend to add an additional type check to your code: /** @return stdClass\|null */ function mayReturnNull() { } function doesNotAcceptNull(stdClass $x) { } // With potential error. function withoutCheck() { $x = mayReturnNull(); doesNotAcceptNull($x); // Potential error here. } // Safe - Alternative 1 function withCheck1() { $x = mayReturnNull(); if ( ! $x instanceof stdClass) { throw new \LogicException('$x must be defined.'); } doesNotAcceptNull($x); } // Safe - Alternative 2 function withCheck2() { $x = mayReturnNull(); if ($x instanceof stdClass) { doesNotAcceptNull($x); } } Loading history...
142		}
143
144		$this->updateStateValues($extendConfig, $configProvider);
		0 ignored issues – show Bug introduced 2016-03-02 07:39 UTC by Report Bug Copy Issue Report It seems like `$configProvider` defined by `$this->configManager->getProvider('extend')` on line `133` can be `null`; however, `Oro\Bundle\EntityExtendB...er::updateStateValues()` does not accept `null`, maybe add an additional type check? Unless you are absolutely sure that the expression can never be null because of other conditions, we strongly recommend to add an additional type check to your code: /** @return stdClass\|null */ function mayReturnNull() { } function doesNotAcceptNull(stdClass $x) { } // With potential error. function withoutCheck() { $x = mayReturnNull(); doesNotAcceptNull($x); // Potential error here. } // Safe - Alternative 1 function withCheck1() { $x = mayReturnNull(); if ( ! $x instanceof stdClass) { throw new \LogicException('$x must be defined.'); } doesNotAcceptNull($x); } // Safe - Alternative 2 function withCheck2() { $x = mayReturnNull(); if ($x instanceof stdClass) { doesNotAcceptNull($x); } } Loading history...
145		}
146		}
147
148		foreach ($extensions as $extension) {
149		if ($extension->supports(self::ACTION_POST_UPDATE)) {
150		$extension->postUpdate();
151		}
152		}
153
154		$this->configManager->flush();
155
156		$this->clear();
157		}
158
159		public function dump()
160		{
161		$schemas = [];
162		$extendConfigs = $this->configManager->getProvider('extend')->getConfigs(null, true);
163		foreach ($extendConfigs as $extendConfig) {
164		$schema = $extendConfig->get('schema');
165		$className = $extendConfig->getId()->getClassName();
166
167		if ($schema) {
168		$schemas[$className] = $schema;
169		$schemas[$className]['relationData'] = $extendConfig->get('relation', false, []);
170		}
171		}
172
173		$cacheDir = $this->entityGenerator->getCacheDir();
174		if ($cacheDir === $this->cacheDir) {
175		$this->entityGenerator->generate($schemas);
176		} else {
177		$this->entityGenerator->setCacheDir($this->cacheDir);
178		try {
179		$this->entityGenerator->generate($schemas);
180		$this->entityGenerator->setCacheDir($cacheDir);
181		} catch (\Exception $e) {
182		$this->entityGenerator->setCacheDir($cacheDir);
183		throw $e;
184		}
185		}
186		}
187
188		/**
189		* Makes sure that extended entity configs are ready to be processing by other config related commands
190		*/
191		public function checkConfig()
192		{
193		$hasAliases = file_exists(ExtendClassLoadingUtils::getAliasesPath($this->cacheDir));
194		if ($hasAliases) {
195		return;
196		}
197
198		$hasChanges = false;
199		$extendConfigs = $this->configManager->getProvider('extend')->getConfigs(null, true);
200		foreach ($extendConfigs as $extendConfig) {
201		$schema = $extendConfig->get('schema', false, []);
202
203		// make sure that inheritance definition for extended entities is up-to-date
204		// this check is required to avoid doctrine mapping exceptions during the platform update
205		// in case if a parent class is changed in a new version of a code
206		if (isset($schema['type'], $schema['class'], $schema['entity']) && $schema['type'] === 'Extend') {
207		$entityClassName = $schema['entity'];
208		$parentClassName = get_parent_class($schema['class']);
209		if ($parentClassName !== $entityClassName) {
210		$inheritClassName = get_parent_class($parentClassName);
211
212		$hasSchemaChanges = false;
213	View Code Duplication	if (!isset($schema['parent']) \|\| $schema['parent'] !== $parentClassName) {
214		$hasSchemaChanges = true;
215		$schema['parent'] = $parentClassName;
216		}
217	View Code Duplication	if (!isset($schema['inherit']) \|\| $schema['inherit'] !== $inheritClassName) {
218		$hasSchemaChanges = true;
219		$schema['inherit'] = $inheritClassName;
220		}
221
222		if ($hasSchemaChanges) {
223		$hasChanges = true;
224		$extendConfig->set('schema', $schema);
225		$this->configManager->persist($extendConfig);
226		}
227		}
228		}
229		}
230
231		if ($hasChanges) {
232		$this->configManager->flush();
233		}
234		}
235
236		/**
237		* Removes the entity proxies and metadata from the cache
238		*
239		* @param bool $keepEntityProxies Set TRUE if proxies for custom and extend entities should not be deleted
240		*/
241		public function clear($keepEntityProxies = false)
242		{
243		$filesystem = new Filesystem();
244
245		if ($keepEntityProxies) {
246		$aliasesPath = ExtendClassLoadingUtils::getAliasesPath($this->cacheDir);
247		if ($filesystem->exists($aliasesPath)) {
248		$filesystem->remove($aliasesPath);
249		}
250		} else {
251		$baseCacheDir = ExtendClassLoadingUtils::getEntityBaseCacheDir($this->cacheDir);
252		if ($filesystem->exists($baseCacheDir)) {
253		$filesystem->remove([$baseCacheDir]);
254		}
255		$filesystem->mkdir(ExtendClassLoadingUtils::getEntityCacheDir($this->cacheDir));
256		}
257
258		foreach ($this->entityManagerBag->getEntityManagers() as $em) {
259		/** @var ClassMetadataFactory $metadataFactory */
260		$metadataFactory = $em->getMetadataFactory();
261		$metadataCache = $metadataFactory->getCacheDriver();
262		if ($metadataCache instanceof ClearableCache) {
263		$metadataCache->deleteAll();
264		}
265		}
266		}
267
268		/**
269		* Return sorted extensions
270		*
271		* @return AbstractEntityConfigDumperExtension[]
272		*/
273	View Code Duplication	protected function getExtensions()
274		{
275		if (null === $this->sortedExtensions) {
276		krsort($this->extensions);
277		$this->sortedExtensions = call_user_func_array('array_merge', $this->extensions);
278		}
279
280		return $this->sortedExtensions;
281		}
282
283		/**
284		* Check fields parameters and update field config
285		*
286		* @param string $entityName
287		* @param ConfigInterface $fieldConfig
288		* @param array $relationProperties
289		* @param array $defaultProperties
290		* @param array $properties
291		* @param array $doctrine
292		*/
293		protected function checkFieldSchema(
294		$entityName,
295		ConfigInterface $fieldConfig,
296		array &$relationProperties,
297		array &$defaultProperties,
298		array &$properties,
299		array &$doctrine
300		) {
301		if ($fieldConfig->is('is_extend')) {
302		/** @var FieldConfigId $fieldConfigId */
303		$fieldConfigId = $fieldConfig->getId();
304		$fieldName = $fieldConfigId->getFieldName();
305		$fieldType = $fieldConfigId->getFieldType();
306		$isDeleted = $fieldConfig->is('is_deleted');
307		$columnName = $fieldConfig->get('column_name', false, $fieldName);
308
309		$underlyingFieldType = $this->fieldTypeHelper->getUnderlyingType($fieldType);
310		if (in_array($underlyingFieldType, RelationType::$anyToAnyRelations, true)) {
311		$relationProperties[$fieldName] = [];
312		if ($isDeleted) {
313		$relationProperties[$fieldName]['private'] = true;
314		}
315		if ($underlyingFieldType !== RelationType::MANY_TO_ONE && !$fieldConfig->is('without_default')) {
316		$defaultName = self::DEFAULT_PREFIX . $fieldName;
317
318		$defaultProperties[$defaultName] = [];
319		if ($isDeleted) {
320		$defaultProperties[$defaultName]['private'] = true;
321		}
322		}
323		} else {
324		$properties[$fieldName] = [];
325		if ($isDeleted) {
326		$properties[$fieldName]['private'] = true;
327		}
328
329		$doctrine[$entityName]['fields'][$fieldName] = [
330		'column' => $columnName,
331		'type' => $fieldType,
332		'nullable' => true,
333		'length' => $fieldConfig->get('length'),
334		'precision' => $fieldConfig->get('precision'),
335		'scale' => $fieldConfig->get('scale'),
336		];
337		}
338		}
339		}
340
341		/**
342		* @SuppressWarnings(PHPMD.NPathComplexity)
343		* @SuppressWarnings(PHPMD.CyclomaticComplexity)
344		* @SuppressWarnings(PHPMD.ExcessiveMethodLength)
345		*
346		* @param ConfigInterface $extendConfig
347		* @param ConfigProvider $configProvider
348		* @param array\|null $aliases
349		* @param callable\|null $filter function (ConfigInterface $config) : bool
350		*/
351		protected function checkSchema(
352		ConfigInterface $extendConfig,
353		ConfigProvider $configProvider,
354		$aliases,
355		$filter = null
356		) {
357		$className = $extendConfig->getId()->getClassName();
358		$doctrine = [];
359		$entityName = $className;
360
361		if (ExtendHelper::isCustomEntity($className)) {
362		$type = 'Custom';
363		$tableName = $extendConfig->get('table');
364		if (!$tableName) {
365		$tableName = $this->nameGenerator->generateCustomEntityTableName($className);
366		}
367		$doctrine[$entityName] = [
368		'type' => 'entity',
369		'table' => $tableName
370		];
371		// add 'id' field only for Custom entity without inheritance
372		if (!$extendConfig->has('inherit')) {
373		$doctrine[$entityName]['fields'] = [
374		'id' => ['type' => 'integer', 'id' => true, 'generator' => ['strategy' => 'AUTO']]
375		];
376		}
377		} else {
378		$type = 'Extend';
379		$entityName = $extendConfig->get('extend_class');
380		$doctrine[$entityName] = [
381		'type' => 'mappedSuperclass',
382		'fields' => [],
383		];
384		}
385
386		$schema = $extendConfig->get('schema', false, []);
387		$properties = isset($schema['property']) && null !== $filter ? $schema['property'] : [];
388		$relationProperties = isset($schema['relation']) && null !== $filter ? $schema['relation'] : [];
389		$defaultProperties = isset($schema['default']) && null !== $filter ? $schema['default'] : [];
390		$addRemoveMethods = isset($schema['addremove']) && null !== $filter ? $schema['addremove'] : [];
391
392		$fieldConfigs = null === $filter
393		? $configProvider->getConfigs($className, true)
394		: $configProvider->filter($filter, $className, true);
395		foreach ($fieldConfigs as $fieldConfig) {
396		$this->updateFieldState($fieldConfig);
397		$this->checkFieldSchema(
398		$entityName,
399		$fieldConfig,
400		$relationProperties,
401		$defaultProperties,
402		$properties,
403		$doctrine
404		);
405		}
406
407		$relations = $extendConfig->get('relation', false, []);
408		foreach ($relations as $relation) {
409		/** @var FieldConfigId $fieldId */
410		$fieldId = $relation['field_id'];
411		if (!$fieldId) {
412		continue;
413		}
414
415		$fieldName = $fieldId->getFieldName();
416		$isDeleted = $configProvider->hasConfig($fieldId->getClassName(), $fieldName)
417		? $configProvider->getConfig($fieldId->getClassName(), $fieldName)->is('is_deleted')
418		: false;
419		if (!isset($relationProperties[$fieldName])) {
420		$relationProperties[$fieldName] = [];
421		if ($isDeleted) {
422		$relationProperties[$fieldName]['private'] = true;
423		}
424		}
425		if (!$isDeleted && $fieldId->getFieldType() !== RelationType::MANY_TO_ONE) {
426		$addRemoveMethods[$fieldName]['self'] = $fieldName;
427
428		/** @var FieldConfigId $targetFieldId */
429		$targetFieldId = $relation['target_field_id'];
430		if ($targetFieldId) {
431		$fieldType = $fieldId->getFieldType();
432
433		$addRemoveMethods[$fieldName]['target'] = $targetFieldId->getFieldName();
434		$addRemoveMethods[$fieldName]['is_target_addremove'] = $fieldType === RelationType::MANY_TO_MANY;
435		}
436		}
437		}
438
439		$schema = [
440		'class' => $className,
441		'entity' => $entityName,
442		'type' => $type,
443		'property' => $properties,
444		'relation' => $relationProperties,
445		'default' => $defaultProperties,
446		'addremove' => $addRemoveMethods,
447		'doctrine' => $doctrine,
448		];
449
450		if ($type === 'Extend') {
451		$parentClassName = get_parent_class($className);
452		if ($parentClassName === $entityName) {
453		$parentClassName = $aliases[$entityName];
454		}
455		$schema['parent'] = $parentClassName;
456		$schema['inherit'] = get_parent_class($parentClassName);
457		} elseif ($extendConfig->has('inherit')) {
458		$schema['inherit'] = $extendConfig->get('inherit');
459		}
460
461		$extendConfig->set('schema', $schema);
462
463		$this->configManager->persist($extendConfig);
464		}
465
466		/**
467		* @param ConfigInterface $fieldConfig
468		*/
469		protected function updateFieldState(ConfigInterface $fieldConfig)
470		{
471		if ($fieldConfig->is('state', ExtendScope::STATE_DELETE)) {
472		$fieldConfig->set('is_deleted', true);
473		$this->configManager->persist($fieldConfig);
474		} elseif (!$fieldConfig->is('state', ExtendScope::STATE_ACTIVE)) {
475		if ($fieldConfig->is('state', ExtendScope::STATE_RESTORE)) {
476		$fieldConfig->set('is_deleted', false);
477		}
478		$fieldConfig->set('state', ExtendScope::STATE_ACTIVE);
479		$this->configManager->persist($fieldConfig);
480		}
481		}
482
483		/**
484		* @param ConfigInterface $entityConfig
485		* @param ConfigProvider $configProvider
486		*/
487		protected function updateStateValues(ConfigInterface $entityConfig, ConfigProvider $configProvider)
488		{
489		if ($entityConfig->is('state', ExtendScope::STATE_DELETE)) {
490		// mark entity as deleted
491		if (!$entityConfig->is('is_deleted')) {
492		$entityConfig->set('is_deleted', true);
493		$this->configManager->persist($entityConfig);
494		}
495
496		// mark all fields as deleted
497		$fieldConfigs = $configProvider->getConfigs($entityConfig->getId()->getClassName(), true);
498		foreach ($fieldConfigs as $fieldConfig) {
499		if (!$fieldConfig->is('is_deleted')) {
500		$fieldConfig->set('is_deleted', true);
501		$this->configManager->persist($fieldConfig);
502		}
503		}
504		} elseif (!$entityConfig->is('state', ExtendScope::STATE_ACTIVE)) {
505		$hasNotActiveFields = false;
506
507		$fieldConfigs = $configProvider->getConfigs($entityConfig->getId()->getClassName(), true);
508		foreach ($fieldConfigs as $fieldConfig) {
509		if (!$fieldConfig->in('state', [ExtendScope::STATE_ACTIVE, ExtendScope::STATE_DELETE])) {
510		$hasNotActiveFields = true;
511		break;
512		}
513		}
514
515		// Set entity state to active if all fields are active or deleted
516		if (!$hasNotActiveFields) {
517		$entityConfig->set('state', ExtendScope::STATE_ACTIVE);
518		$this->configManager->persist($entityConfig);
519		}
520		}
521		}
522
523		/**
524		* Updates pending configs
525		*/
526		protected function updatePendingConfigs()
527		{
528		$pendingChanges = [];
529
530		$configs = $this->configManager->getProvider('extend')->getConfigs();
531		foreach ($configs as $config) {
532		$configPendingChanges = $config->get('pending_changes');
533		if (!$configPendingChanges) {
534		continue;
535		}
536
537		$pendingChanges[$config->getId()->getClassName()] = $configPendingChanges;
538		$config->set('pending_changes', []);
539		$this->configManager->persist($config);
540		}
541
542		foreach ($pendingChanges as $className => $changes) {
543		foreach ($changes as $scope => $values) {
544		$provider = $this->configManager->getProvider($scope);
545		$config = $provider->getConfig($className);
546		foreach ($values as $code => $value) {
547		$config->set($code, ExtendHelper::updatedPendingValue($config->get($code), $value));
548		}
549		$this->configManager->persist($config);
550		}
551		}
552		}
553		}
554

orocrm / platform

ExtendConfigDumper F last analyzed 2016-05-19 07:51 UTC