/**
* {@inheritdoc}
*/
public function getEntityAlias($entityClass)
{
if ($this->configManager->hasConfig($entityClass)) {
// check for enums
$enumCode = $this->configManager->getProvider('enum')->getConfig($entityClass)->get('code');
if ($enumCode) {
$entityAlias = $this->getEntityAliasFromConfig($entityClass);
if (null !== $entityAlias) {
return $entityAlias;
}
return $this->createEntityAlias(str_replace('_', '', $enumCode));
}
// check for dictionaries
$groups = $this->configManager->getProvider('grouping')->getConfig($entityClass)->get('groups');
if (!empty($groups) && in_array(GroupingScope::GROUP_DICTIONARY, $groups, true)) {
// delegate aliases generation to default provider
return null;
}
// exclude hidden entities
if ($this->configManager->isHiddenModel($entityClass)) {
return false;
}
// check for custom entities
if (ExtendHelper::isCustomEntity($entityClass)) {
$entityAlias = $this->getEntityAliasFromConfig($entityClass);
if (null !== $entityAlias) {
return $entityAlias;
}
return $this->createEntityAlias('Extend' . ExtendHelper::getShortClassName($entityClass));
}
}
return null;
}
/**
* @param string $entityClassName
* @param string $relationType
*
* @return array
*/
protected function getEntityChoiceList($entityClassName, $relationType)
{
/** @var EntityConfigId[] $entityIds */
$entityIds = $this->targetEntityClass ? [$this->configManager->getId('extend', $this->targetEntityClass)] : $this->configManager->getIds('extend');
if (in_array($relationType, [RelationTypeBase::ONE_TO_MANY, RelationTypeBase::MANY_TO_MANY], true)) {
$entityIds = array_filter($entityIds, function (EntityConfigId $configId) {
$config = $this->configManager->getConfig($configId);
return $config->is('is_extend');
});
}
$entityIds = array_filter($entityIds, function (EntityConfigId $configId) {
$config = $this->configManager->getConfig($configId);
return !$config->is('state', ExtendScope::STATE_NEW) && ($this->targetEntityClass || !$config->is('is_deleted'));
});
$choices = [];
foreach ($entityIds as $entityId) {
$className = $entityId->getClassName();
if (!$this->configManager->hasConfig($className, 'id') && !ExtendHelper::isCustomEntity($className)) {
// @todo: temporary ignore entities that don't have PK with name 'id'
// remove this in https://magecore.atlassian.net/browse/BAP-9713
continue;
}
if ($className !== $entityClassName) {
$entityConfig = $this->configManager->getProvider('entity')->getConfig($className);
$choices[$className] = $entityConfig->get('label');
}
}
return $choices;
}
/**
* Returns objects extracted from simple search
*
* @param User $user
* @param string $entityClass
* @param string $searchString
* @param int $offset
* @param int $maxResults
*
* @return array
*/
protected function getObjects(User $user, $entityClass, $searchString, $offset, $maxResults)
{
$objects = [];
if (!$this->configManager->hasConfig($entityClass)) {
return $objects;
}
$classNames = $this->shareScopeProvider->getClassNamesBySharingScopeConfig($entityClass);
if (!$classNames) {
return $objects;
}
$tables = [];
foreach ($classNames as $className) {
$metadata = $this->em->getClassMetadata($className);
$tables[] = $metadata->getTableName();
}
$searchResults = $this->indexer->simpleSearch($searchString, $offset, $maxResults, $tables);
list($userIds, $buIds, $orgIds) = $this->getIdsByClass($searchResults, $user);
if ($orgIds) {
$organizations = $this->em->getRepository('OroOrganizationBundle:Organization')->getEnabledOrganizations($orgIds);
$objects = array_merge($objects, $organizations);
}
if ($buIds) {
$businessUnits = $this->em->getRepository('OroOrganizationBundle:BusinessUnit')->getBusinessUnits($buIds);
$objects = array_merge($objects, $businessUnits);
}
if ($userIds) {
$users = $this->em->getRepository('OroUserBundle:User')->findUsersByIds($userIds);
$objects = array_merge($objects, $users);
}
return $objects;
}
/**
* Returns grouped search results
*
* @param string $string
* @return array
*/
public function getGroupedResults($string)
{
$search = $this->getResults($string);
// empty key array contains all data
$result = array('' => array('count' => 0, 'class' => '', 'config' => array(), 'icon' => '', 'label' => ''));
/** @var $item Item */
foreach ($search->getElements() as $item) {
$config = $item->getEntityConfig();
$alias = $config['alias'];
if (!isset($result[$alias])) {
$group = array('count' => 0, 'class' => $item->getEntityName(), 'config' => $config, 'icon' => '', 'label' => '');
if (!empty($group['class']) && $this->configManager->hasConfig($group['class'])) {
$entityConfigId = new EntityConfigId('entity', $group['class']);
$entityConfig = $this->configManager->getConfig($entityConfigId);
if ($entityConfig->has('plural_label')) {
$group['label'] = $this->translator->trans($entityConfig->get('plural_label'));
}
if ($entityConfig->has('icon')) {
$group['icon'] = $entityConfig->get('icon');
}
}
$result[$alias] = $group;
}
$result[$alias]['count']++;
$result['']['count']++;
}
uasort($result, function ($first, $second) {
if ($first['label'] == $second['label']) {
return 0;
}
return $first['label'] > $second['label'] ? 1 : -1;
});
return $result;
}
/**
* @param FieldConfigModel $configModel
* @return array
*/
protected function writeItem(FieldConfigModel $configModel)
{
$className = $configModel->getEntity()->getClassName();
$fieldName = $configModel->getFieldName();
$state = ExtendScope::STATE_UPDATE;
if (!$this->configManager->hasConfig($className, $fieldName)) {
$this->configManager->createConfigFieldModel($className, $fieldName, $configModel->getType());
$state = ExtendScope::STATE_NEW;
}
$translations = [];
foreach ($this->configManager->getProviders() as $provider) {
$scope = $provider->getScope();
$data = $configModel->toArray($scope);
if (!$data) {
continue;
}
$translations = array_merge($translations, $this->processData($provider, $provider->getConfig($className, $fieldName), $data, $state));
}
$this->setExtendData($className, $fieldName, $state);
$this->updateEntityState($className);
if ($state === ExtendScope::STATE_UPDATE && in_array($configModel->getType(), ['enum', 'multiEnum'], true)) {
$this->setEnumData($configModel->toArray('enum'), $className, $fieldName);
}
return $translations;
}
/**
* @param string $className The entity class name
* @param string $attrName The entity config attribute name
* @param string $scope The entity config scope name
*
* @return mixed
*/
public function getClassConfigValue($className, $attrName, $scope = 'entity')
{
if (!$this->configManager->hasConfig($className)) {
return null;
}
$entityConfig = new EntityConfigId($scope, $className);
return $this->configManager->getConfig($entityConfig)->get($attrName);
}
/**
* Check if an association between a given entity type and activity type is ready to be used in a business logic.
* It means that the association should exist and should not be marked as deleted.
*
* @param string $entityClass The target entity class
* @param string $activityClass The activity entity class
*
* @return bool
*/
protected function isActivityAssociationAccessible($entityClass, $activityClass)
{
$associationName = ExtendHelper::buildAssociationName($entityClass, ActivityScope::ASSOCIATION_KIND);
if (!$this->configManager->hasConfig($activityClass, $associationName)) {
return false;
}
return ExtendHelper::isFieldAccessible($this->configManager->getFieldConfig('extend', $activityClass, $associationName));
}
/**
* Check if an association between a given entity type and attachments is ready to be used in a business logic.
* It means that the association should exist and should not be marked as deleted.
*
* @param string $entityClass The target entity class
*
* @return bool
*/
protected function isAttachmentAssociationAccessible($entityClass)
{
$associationName = ExtendHelper::buildAssociationName($entityClass);
if (!$this->configManager->hasConfig(self::ATTACHMENT_ENTITY, $associationName)) {
return false;
}
return ExtendHelper::isFieldAccessible($this->configManager->getFieldConfig('extend', self::ATTACHMENT_ENTITY, $associationName));
}
/**
* {@inheritdoc}
*/
public function isIgnoredRelation(ClassMetadata $metadata, $associationName)
{
if (!$this->configManager->hasConfig($metadata->name, $associationName)) {
return false;
}
$extendFieldConfig = $this->configManager->getFieldConfig('extend', $metadata->name, $associationName);
return !ExtendHelper::isFieldAccessible($extendFieldConfig) || $this->configManager->isHiddenModel($metadata->name, $associationName) || $extendFieldConfig->has('target_entity') && !ExtendHelper::isEntityAccessible($this->configManager->getEntityConfig('extend', $extendFieldConfig->get('target_entity')));
}
/**
* @param $className
*
* @return null|string
*/
public function getGridName($className)
{
$className = $this->entityClassNameHelper->resolveEntityClass($className);
if (!$this->configManager->hasConfig($className)) {
return null;
}
return $this->configManager->getProvider('security')->getConfig($className)->get('share_grid');
}
/**
* @param string $className
*
* @return bool
*/
protected function isExtendEntity($className)
{
$result = false;
if ($this->configManager->hasConfig($className)) {
$extendProvider = $this->configManager->getProvider('extend');
$result = $extendProvider->getConfig($className)->is('is_extend');
}
return $result;
}
/**
* @param string $className
* @param string $fieldName
*
* @return bool
*/
protected function isMultiEnumField($className, $fieldName)
{
if ($this->configManager->hasConfig($className, $fieldName)) {
/** @var FieldConfigId $fieldId */
$fieldId = $this->configManager->getId('extend', $className, $fieldName);
if ($fieldId->getFieldType() === 'multiEnum') {
return true;
}
}
return false;
}
/**
* {@inheritdoc}
*/
public function isIgnoredRelation(ClassMetadata $metadata, $associationName)
{
if (!$this->configManager->hasConfig($metadata->name, $associationName)) {
return false;
}
$groups = $this->configManager->getEntityConfig('grouping', $metadata->name)->get('groups');
if (empty($groups) || !in_array(ActivityScope::GROUP_ACTIVITY, $groups, true)) {
return false;
}
$mapping = $metadata->getAssociationMapping($associationName);
if (!$mapping['isOwningSide'] || !($mapping['type'] & ClassMetadata::MANY_TO_MANY)) {
return false;
}
$activityAssociationName = ExtendHelper::buildAssociationName($mapping['targetEntity'], ActivityScope::ASSOCIATION_KIND);
return $associationName === $activityAssociationName;
}
/**
* {@inheritdoc}
*/
public function getMetadataFor($object)
{
$metadata = [];
if ($object instanceof EntityManagerAwareInterface) {
$entityFQCN = $object->getManager()->getMetadata()->name;
$metadata['entity'] = [];
$metadata['entity']['phpType'] = $entityFQCN;
if ($this->cm->hasConfig($entityFQCN)) {
$config = $this->cm->getConfig(new EntityConfigId('entity', $entityFQCN));
$metadata['entity']['label'] = $this->translator->trans($config->get('label'));
$metadata['entity']['pluralLabel'] = $this->translator->trans($config->get('plural_label'));
$metadata['entity']['description'] = $this->translator->trans($config->get('description'));
}
}
return $metadata;
}
/**
* @param string $targetClassName
* @param string $activityClassName
*
* @return bool
*/
public function isApplicableTarget($targetClassName, $activityClassName)
{
if (!isset($this->providers[$activityClassName]) || !$this->configManager->hasConfig($targetClassName)) {
return false;
}
return $this->providers[$activityClassName]->isApplicableTarget($this->configManager->getId('entity', $targetClassName), $this->configManager);
}
/**
* @param string $className The entity class name
* @param string $routeType Route Type
* @param bool $strict Should exception be thrown if no route of given type found
*
* @return string
*/
public function getClassRoute($className, $routeType = 'view', $strict = false)
{
if (!$this->configManager->hasConfig($className)) {
return null;
}
return $this->configManager->getEntityMetadata($className)->getRoute($routeType, $strict);
}
/**
* @param ConfigIdInterface $configId
* @return bool
*/
public function hasConfigById(ConfigIdInterface $configId)
{
if ($configId instanceof FieldConfigId) {
return $this->configManager->hasConfig($configId->getClassName(), $configId->getFieldName());
} else {
return $this->configManager->hasConfig($configId->getClassName());
}
}
/**
* @param string $className
* @return null|string
*/
protected function getClassLabel($className)
{
if (!$this->configManager->hasConfig($className)) {
return null;
}
$label = $this->configManager->getProvider('entity')->getConfig($className)->get('label');
return $this->translator->trans($label);
}
/**
* @param string $className
* @return null|string
*/
protected function getClassLabel($className)
{
if (!$this->configManager->hasConfig($className)) {
return null;
}
$entityConfig = new EntityConfigId('entity', $className);
$label = $this->configManager->getConfig($entityConfig)->get('label');
return $this->translator->trans($label);
}
/**
* @param BeforeGroupingChainWidgetEvent $event
*/
public function isAllowedButton(BeforeGroupingChainWidgetEvent $event)
{
$entity = $event->getEntity();
$pageType = $event->getPageType();
if ($pageType === null || !is_object($entity) || !$this->configManager->hasConfig($this->doctrineHelper->getEntityClass($entity)) || !$this->isAllowedOnPage($this->doctrineHelper->getEntityClass($entity), $pageType)) {
// Clear allowed widgets
$event->setWidgets([]);
}
}
/**
* @param string $className
* @param ConfigManager $configManager
*
* @return bool
*/
protected function isExtendEntity($className, ConfigManager $configManager)
{
$result = false;
// check if an entity is marked as extended (both extended and custom entities are marked as extended)
if ($configManager->hasConfig($className)) {
$extendProvider = $configManager->getProvider('extend');
$result = $extendProvider->getConfig($className)->is('is_extend');
}
return $result;
}
/**
* @param string $entityClass
* @throws WorkflowException
*/
public function generateWorkflowFields($entityClass)
{
if ($this->entityConnector->isWorkflowAware($entityClass)) {
return;
}
$extendConfigProvider = $this->configManager->getProvider('extend');
$entityConfig = $extendConfigProvider->getConfig($entityClass);
if (!$entityConfig || !$entityConfig->is('is_extend')) {
throw new WorkflowException(sprintf('Class %s can not be extended', $entityClass));
}
$workflowItemClass = 'Oro\\Bundle\\WorkflowBundle\\Entity\\WorkflowItem';
$workflowStepClass = 'Oro\\Bundle\\WorkflowBundle\\Entity\\WorkflowStep';
// add fields
$hasWorkflowItemField = $this->configManager->hasConfig($entityClass, self::PROPERTY_WORKFLOW_ITEM);
if (!$hasWorkflowItemField) {
$this->addRelationField($entityClass, self::PROPERTY_WORKFLOW_ITEM, ConfigHelper::getTranslationKey('entity', 'label', $workflowItemClass, 'related_entity'), ConfigHelper::getTranslationKey('entity', 'description', $workflowItemClass, 'related_entity'), $workflowItemClass, 'id');
}
$hasWorkflowStepField = $this->configManager->hasConfig($entityClass, self::PROPERTY_WORKFLOW_STEP);
if (!$hasWorkflowStepField) {
$this->addRelationField($entityClass, self::PROPERTY_WORKFLOW_STEP, ConfigHelper::getTranslationKey('entity', 'label', $workflowStepClass, 'related_entity'), ConfigHelper::getTranslationKey('entity', 'description', $workflowStepClass, 'related_entity'), $workflowStepClass, 'label');
}
// update entity config
$entityConfig->set('state', ExtendScope::STATE_UPDATE);
$entityConfig->set('upgradeable', true);
$this->configManager->persist($entityConfig);
$this->configManager->flush();
// update database
$this->entityProcessor->updateDatabase();
// make fields hidden
// TODO: Fields can be hidden only after schema update due to a bug in DoctrineSubscriber
// TODO: Should be fixed in scope of https://magecore.atlassian.net/browse/BAP-3621
// TODO: If make fields hidden then these fields will be created only for the first extended entity
// TODO: Should be fixed in scope of https://magecore.atlassian.net/browse/BAP-3632
/*
if (!$hasWorkflowItemField) {
$this->hideRelationField($entityClass, self::PROPERTY_WORKFLOW_ITEM);
}
if (!$hasWorkflowStepField) {
$this->hideRelationField($entityClass, self::PROPERTY_WORKFLOW_STEP);
}
$this->configManager->flush();
*/
}
/**
* @param string $className
* @param string $fieldName
* @param string $fieldType
* @param bool $force
*/
protected function loadFieldConfigs($className, $fieldName, $fieldType, $force)
{
if ($this->configManager->hasConfig($className, $fieldName)) {
$this->logger->info(sprintf('Update config for "%s" field.', $fieldName));
$this->configManager->updateConfigFieldModel($className, $fieldName, $force);
} else {
$this->logger->info(sprintf('Create config for "%s" field.', $fieldName));
$this->configManager->createConfigFieldModel($className, $fieldName, $fieldType);
}
}
/**
* @param FieldConfigId $fieldId
*
* @return string
*/
protected function getManyToOneColumnName(FieldConfigId $fieldId)
{
$columnName = null;
if ($this->configManager->hasConfig($fieldId->getClassName(), $fieldId->getFieldName())) {
$columnName = $this->getFieldConfig($fieldId)->get('column_name');
}
if (!$columnName) {
$columnName = $this->nameGenerator->generateRelationColumnName($fieldId->getFieldName());
}
return $columnName;
}
/**
* @param string $className The entity class name
* @param string $routeType Route Type
* @param bool $strict Should exception be thrown if no route of given type found
*
* @return string|null
*/
public function getClassRoute($className, $routeType = 'view', $strict = false)
{
if (!$this->configManager->hasConfig($className)) {
return null;
}
$entityMetadata = $this->configManager->getEntityMetadata($className);
if (!$entityMetadata) {
return null;
}
$route = $entityMetadata->getRoute($routeType, $strict);
return $route && $this->hasRoute($route) ? $route : null;
}
/**
* @param string $className The entity class name
* @param string $routeType Route Type
* @param bool $strict Should exception be thrown if no route of given type found
*
* @return string
*/
public function getClassRoute($className, $routeType = 'view', $strict = false)
{
if (!$this->configManager->hasConfig($className)) {
return null;
}
$route = $this->configManager->getEntityMetadata($className)->getRoute($routeType, $strict);
if ($collection = $this->router->getRouteCollection()) {
if ($collection->get($route) === null) {
return null;
}
}
return $route;
}
/**
* {@inheritdoc}
*/
public function isIgnoredRelation(ClassMetadata $metadata, $associationName)
{
if (!$this->configManager->hasConfig($metadata->name, $associationName)) {
return false;
}
$extendFieldConfig = $this->configManager->getFieldConfig('extend', $metadata->name, $associationName);
if (!ExtendHelper::isFieldAccessible($extendFieldConfig)) {
return true;
}
if ($this->excludeHiddenFields && $this->configManager->isHiddenModel($metadata->name, $associationName)) {
return true;
}
if ($extendFieldConfig->has('target_entity')) {
$targetEntity = $extendFieldConfig->get('target_entity');
if (!ExtendHelper::isEntityAccessible($this->configManager->getEntityConfig('extend', $targetEntity))) {
return true;
}
if ($this->excludeHiddenEntities && $this->configManager->isHiddenModel($targetEntity)) {
return true;
}
}
return false;
}
/**
* Renames configurable fields
*
* @param array $renameConfigs
* @return bool TRUE if at least one field was renamed; otherwise, FALSE
*/
protected function renameFields($renameConfigs)
{
$hasChanges = false;
foreach ($renameConfigs as $className => $renameConfig) {
foreach ($renameConfig as $fieldName => $newFieldName) {
if ($this->configManager->hasConfig($className, $fieldName)) {
$renamed = $this->renameField($className, $fieldName, $newFieldName);
if ($renamed && !$hasChanges) {
$hasChanges = true;
}
}
}
}
return $hasChanges;
}
/**
* Get list of dynamic fields to show
*
* @param string $entityName
*
* @return array
*/
protected function getDynamicFields($entityName)
{
$fields = [];
if ($this->cm->hasConfig($entityName)) {
$entityProvider = $this->cm->getProvider('entity');
$extendProvider = $this->cm->getProvider('extend');
$datagridProvider = $this->cm->getProvider('datagrid');
$fieldIds = $entityProvider->getIds($entityName);
foreach ($fieldIds as $fieldId) {
if ($extendProvider->getConfigById($fieldId)->is('owner', ExtendManager::OWNER_CUSTOM) && $datagridProvider->getConfigById($fieldId)->is('is_visible') && !$extendProvider->getConfigById($fieldId)->is('state', ExtendManager::STATE_NEW) && !$extendProvider->getConfigById($fieldId)->is('is_deleted')) {
$fields[] = $fieldId;
}
}
}
return $fields;
}
/**
* @dataProvider hasConfigProvider
*/
public function testHasConfig($expectedResult, $checkDatabaseResult, $cachedResult, $findModelResult, $className, $fieldName)
{
$this->modelManager->expects($this->any())->method('checkDatabase')->willReturn($checkDatabaseResult);
if ($checkDatabaseResult) {
$this->configCache->expects($this->once())->method('getConfigurable')->with($className, $fieldName)->willReturn($cachedResult);
if (null === $cachedResult) {
$this->configCache->expects($this->once())->method('saveConfigurable')->with($expectedResult, $className, $fieldName);
if ($fieldName) {
$this->modelManager->expects($this->once())->method('findFieldModel')->with($className, $fieldName)->willReturn($findModelResult);
} else {
$this->modelManager->expects($this->once())->method('findEntityModel')->with($className)->willReturn($findModelResult);
}
}
}
$result = $this->configManager->hasConfig($className, $fieldName);
$this->assertEquals($expectedResult, $result);
}
