/** * {@inheritdoc} */ protected function getChoices($entityName, $withRelations, $withVirtualFields) { $choiceFields = []; $choiceRelations = []; $idFieldNames = $this->doctrineHelper->getEntityIdentifierFieldNames($entityName); foreach ($this->getEntityFields($entityName, $withRelations, $withVirtualFields) as $fieldName => $field) { $formConfig = $this->formConfigProvider->getConfig($entityName, $fieldName); if ($formConfig->is('is_enabled', false) || in_array($fieldName, $idFieldNames)) { // field is not enabled for displaying in forms // or field is entity identifier continue; } if (!isset($field['relation_type'])) { $choiceFields[$fieldName] = $field['label']; } elseif (!in_array($field['relation_type'], RelationType::$toManyRelations)) { // enable only mass update for *-to-one relations $choiceRelations[$fieldName] = $field['label']; } } if (empty($choiceRelations)) { return $choiceFields; } $choices = []; if (!empty($choiceFields)) { $choices[$this->translator->trans('oro.entity.form.entity_fields')] = $choiceFields; } $choices[$this->translator->trans('oro.entity.form.entity_related')] = $choiceRelations; return $choices; }
/** * @param bool $withRelations * * @dataProvider testDataProvider */ public function testBuildFormRegularGuesser($withRelations) { $entityName = 'Test\\Entity'; $this->doctrineHelperMock->expects($this->once())->method('getEntityIdentifierFieldNames')->with($entityName)->willReturn(['id']); $fields = [['name' => 'oneField', 'type' => 'string', 'label' => 'One field'], ['name' => 'anotherField', 'type' => 'string', 'label' => 'Another field']]; if ($withRelations) { $fields[] = ['name' => 'relField', 'relation_type' => 'ref-one', 'label' => 'Many to One field']; } $this->entityFieldMock->expects($this->once())->method('getFields')->willReturn($fields); $this->formConfigMock->expects($this->at(0))->method('getConfig')->with($entityName, 'oneField')->willReturn(new Config(new FieldConfigId('form', $entityName, 'someField'), ['is_enabled' => false])); $this->formConfigMock->expects($this->at(1))->method('getConfig')->with($entityName, 'anotherField')->willReturn(new Config(new FieldConfigId('form', $entityName, 'anotherField'), ['is_enabled' => true])); if ($withRelations) { $this->formConfigMock->expects($this->at(2))->method('getConfig')->with($entityName, 'relField')->willReturn(new Config(new FieldConfigId('form', $entityName, 'relField'), ['is_enabled' => true])); $this->translatorMock->expects($this->at(0))->method('trans')->with('oro.entity.form.entity_fields')->willReturn('Fields'); $this->translatorMock->expects($this->at(1))->method('trans')->with('oro.entity.form.entity_related')->willReturn('Relations'); } $form = $this->factory->create($this->type, null, ['entity' => $entityName, 'with_relations' => $withRelations]); $view = $form->createView(); $this->assertEquals('update_field_choice', $view->vars['full_name'], 'Failed asserting that field name is correct'); $this->assertNotEmpty($view->vars['configs']['component']); $this->assertEquals('entity-field-choice', $view->vars['configs']['component']); $this->assertEquals('update_field_choice', $form->getConfig()->getType()->getName(), 'Failed asserting that correct underlying type was used'); if ($withRelations) { $this->assertCount(2, $view->vars['choices'], 'Failed asserting that choices are grouped'); } else { $this->assertCount(1, $view->vars['choices'], 'Failed asserting that choices exists'); /** @var ChoiceView $choice */ $choice = reset($view->vars['choices']); $this->assertEquals('Another field', $choice->label); } }
/** * @param array $fields * @param array $configValues * @param array $expected * * @dataProvider fieldsDataProvider */ public function testGetFields(array $fields, array $configValues, array $expected) { $entity = new \StdClass(); foreach ($fields as $field) { /** @var ConfigInterface $field */ $fieldId = $field->getId(); /** @var FieldConfigId $fieldId */ $fieldName = $fieldId->getFieldName(); $entity->{$fieldName} = $fieldName; } $this->configProvider->expects($this->once())->method('filter')->will($this->returnValue($fields)); $config = $this->getMock('Oro\\Bundle\\EntityConfigBundle\\Config\\ConfigInterface'); $this->configProvider->expects($this->any())->method('getConfigById')->will($this->returnValue($config)); foreach ($configValues as $key => $configValue) { $config->expects($this->at($key))->method('get')->will($this->returnCallback(function ($value, $strict, $default) use($configValue) { if (!is_null($configValue)) { return $configValue; } return $default; })); } $this->dispatcher->expects($this->exactly(sizeof($fields)))->method('dispatch'); $rows = $this->extension->getFields($entity); $this->assertEquals(json_encode($expected), json_encode($rows)); }
/** * {@inheritdoc} */ public function buildForm(FormBuilderInterface $builder, array $options) { if (empty($options['data_class'])) { return; } $className = $options['data_class']; if (!$this->entityConfigProvider->hasConfig($className)) { return; } $config = $this->entityConfigProvider->getConfig($className); if (!$config->has('unique_key')) { return; } $uniqueKeys = $config->get('unique_key', false, ['keys' => []]); /* @var \Symfony\Component\Validator\Mapping\ClassMetadata $validatorMetadata */ $validatorMetadata = $this->validator->getMetadataFor($className); foreach ($uniqueKeys['keys'] as $uniqueKey) { $fields = $uniqueKey['key']; $labels = array_map(function ($fieldName) use($className) { $label = $this->entityConfigProvider->getConfig($className, $fieldName)->get('label'); return $this->translator->trans($label); }, $fields); $constraint = new UniqueEntity(['fields' => $fields, 'errorPath' => '', 'message' => $this->translator->transChoice('oro.entity.validation.unique_field', sizeof($fields), ['%field%' => implode(', ', $labels)])]); $validatorMetadata->addConstraint($constraint); } }
/** * @param object $entity * * @return ConfigInterface[] */ protected function getEntityActivityContactFields($entity) { $fields = array_keys(ActivityScope::$fieldsConfiguration); return $this->extendProvider->filter(function (ConfigInterface $config) use($fields) { /** @var FieldConfigId $fieldConfigId */ $fieldConfigId = $config->getId(); return in_array($fieldConfigId->getFieldName(), $fields); }, ClassUtils::getClass($entity)); }
/** * @param string $className * @return bool */ protected function hasFrontendOwnership($className) { if ($this->ownershipConfigProvider->hasConfig($className)) { $config = $this->ownershipConfigProvider->getConfig($className); if ($config->has('frontend_owner_type')) { return true; } } return false; }
/** * @param ResultRecordInterface $record * @return array */ public function getWorkflowDefinitionPermissions(ResultRecordInterface $record) { $isActiveWorkflow = false; $relatedEntity = $record->getValue('entityClass'); if ($this->configProvider->hasConfig($relatedEntity)) { $config = $this->configProvider->getConfig($relatedEntity); $isActiveWorkflow = $record->getValue('name') == $config->get('active_workflow'); } $isSystem = $record->getValue('system'); return array('activate' => !$isActiveWorkflow, 'clone' => true, 'deactivate' => $isActiveWorkflow, 'delete' => !$isSystem, 'update' => !$isSystem, 'view' => true); }
/** * @param string $entityName * @return string|null */ protected function getEntityGridName($entityName) { $gridName = null; if ($this->configProvider->hasConfig($entityName)) { $config = $this->configProvider->getConfig($entityName); $gridName = $config->get('grid_name'); } if (!$gridName) { throw new \RuntimeException(sprintf('Grid not found for entity "%s"', $entityName)); } return $gridName; }
/** * {@inheritdoc} */ protected function filterPrivileges(ArrayCollection $privileges, array $rootIds) { $privileges = parent::filterPrivileges($privileges, $rootIds); $entityPrefix = 'entity:'; foreach ($privileges as $key => $privilege) { $oid = $privilege->getIdentity()->getId(); if (strpos($oid, $entityPrefix) === 0) { $className = substr($oid, strlen($entityPrefix)); if (!$this->ownershipConfigProvider->hasConfig($className)) { unset($privileges[$key]); } } } return $privileges; }
/** * {@inheritdoc} */ public function buildForm(FormBuilderInterface $builder, array $options) { $fields = []; $className = $options['className']; $fieldConfigIds = $this->entityProvider->getIds($className); /** @var FieldConfigId $fieldConfigId */ foreach ($fieldConfigIds as $fieldConfigId) { if ($fieldConfigId->getFieldType() === RelationTypeBase::TO_MANY) { continue; } $fieldName = $fieldConfigId->getFieldName(); $fields[$fieldName] = $this->entityProvider->getConfig($className, $fieldName)->get('label', false, ucfirst($fieldName)); } $builder->add('keys', 'collection', array('required' => true, 'type' => new UniqueKeyType($fields), 'allow_add' => true, 'allow_delete' => true, 'prototype' => true, 'prototype_name' => 'tag__name__', 'label' => false, 'constraints' => [new UniqueKeys()])); }
/** * @param object $object * * @return array */ protected function getApplicableRelations($object) { $result = []; $className = ClassUtils::getClass($object); if (!$this->extendConfigProvider->hasConfig($className)) { return $result; } $extendConfig = $this->extendConfigProvider->getConfig($className); $relations = $extendConfig->get('relation'); if (empty($relations)) { return $result; } $targetEntities = $this->getTargetEntities(); foreach ($relations as $relation) { if (empty($relation['owner'])) { continue; } /** @var FieldConfigId $fieldId */ $fieldId = $relation['field_id']; if ($fieldId->getFieldType() !== 'manyToOne') { continue; } $relatedEntityClass = $relation['target_entity']; if (!in_array($relatedEntityClass, $targetEntities)) { continue; } if (!isset($result[$relatedEntityClass])) { $result[$relatedEntityClass] = []; } $result[$relatedEntityClass][] = $fieldId->getFieldName(); } return $result; }
/** * @param null|string $entityName * * @return bool */ public function isMassActionEnabled($entityName) { $isEnabled = false; if ($entityName && $this->gridConfigProvider->hasConfig($entityName)) { $isEnabled = $this->gridConfigProvider->getConfig($entityName)->is('update_mass_action_enabled'); } else { $this->logger->debug("Update Mass Action: not configured for " . $entityName); } if ($isEnabled && $this->securityFacade->isGranted('EDIT', 'entity:' . $entityName)) { $isEnabled = true; } elseif ($isEnabled) { $this->logger->debug("Update Mass Action: not allowed to modify the entity of class " . $entityName); $isEnabled = false; } return $isEnabled; }
/** * @param string $entity * @return bool */ protected function isShowWorkflowStep($entity) { if ($this->configProvider->hasConfig($entity)) { $config = $this->configProvider->getConfig($entity); return $config->has('show_step_in_grid') && $config->is('show_step_in_grid'); } return false; }
/** * {@inheritDoc} */ public function guessType($class, $property) { $metadata = $this->getMetadataForClass($class); if (!$metadata || !$this->formConfigProvider->hasConfig($class, $property)) { return $this->createDefaultTypeGuess(); } $formConfig = $this->formConfigProvider->getConfig($class, $property); $isSingleValuedAssoc = $property && $metadata->hasAssociation($property) && $metadata->isSingleValuedAssociation($property); $hasNoFormType = !$formConfig->has('form_type'); if ($hasNoFormType && $isSingleValuedAssoc) { // try to find form config for target class $guess = $this->guessType($metadata->getAssociationTargetClass($property), null); } elseif ($hasNoFormType) { $guess = $this->createDefaultTypeGuess(); } else { $guess = $this->getTypeGuess($formConfig, $class, $property); } return $guess; }
/** * Get Active Workflow that is applicable to entity class * * @param string $entityClass * @return Workflow|null */ public function getActiveWorkflowByEntityClass($entityClass) { if ($this->configProvider->hasConfig($entityClass)) { $entityConfig = $this->configProvider->getConfig($entityClass); $activeWorkflowName = $entityConfig->get('active_workflow'); if ($activeWorkflowName) { return $this->getWorkflow($activeWorkflowName, false); } } return null; }
/** * Get workflow definition related entities. * * @throws MissedRequiredOptionException * @return array */ public function getRelatedEntitiesChoice() { if (!$this->entityName) { throw new MissedRequiredOptionException('Entity name is required.'); } if (empty($this->relatedEntities)) { $qb = $this->entityManager->createQueryBuilder(); $qb->select('entity.relatedEntity')->from($this->entityName, 'entity')->distinct('entity.relatedEntity'); $result = (array) $qb->getQuery()->getArrayResult(); foreach ($result as $value) { $className = $value['relatedEntity']; $label = $className; if ($this->configProvider->hasConfig($className)) { $config = $this->configProvider->getConfig($className); $label = $this->translator->trans($config->get('label')); } $this->relatedEntities[$className] = $label; } } return $this->relatedEntities; }
/** * @param array $options * @param string $class * @param string|null $field * @param bool $multiple * @return array */ protected function addLabelOption(array $options, $class, $field = null, $multiple = false) { if (array_key_exists('label', $options) || !$this->entityConfigProvider->hasConfig($class, $field)) { return $options; } $entityConfig = $this->entityConfigProvider->getConfig($class, $field); $labelOption = $multiple ? 'plural_label' : 'label'; if ($entityConfig->has($labelOption)) { $options['label'] = $entityConfig->get($labelOption); } return $options; }
/** * {@inheritDoc} */ public function guessType($class, $property) { $metadata = $this->getMetadataForClass($class); if (!$metadata) { return $this->createDefaultTypeGuess(); } if (!$this->formConfigProvider->hasConfig($class, $property)) { return $this->createDefaultTypeGuess(); } $formConfig = $this->formConfigProvider->getConfig($class, $property); if (!$formConfig->has('form_type')) { // try to find form config for target class if ($property && $metadata->hasAssociation($property) && $metadata->isSingleValuedAssociation($property)) { return $this->guessType($metadata->getAssociationTargetClass($property), null); } return $this->createDefaultTypeGuess(); } $formType = $formConfig->get('form_type'); $formOptions = $formConfig->has('form_options') ? $formConfig->get('form_options') : array(); $formOptions = $this->addLabelOption($formOptions, $class, $property); return $this->createTypeGuess($formType, $formOptions); }
public function testWarmUpCacheFilterConfigsByScope() { $config1 = new Config(new EntityConfigId('ownership', 'AcmeBundle\\Entity\\User')); $config2 = new Config(new EntityConfigId('ownership', 'AcmeBundle\\Entity\\Account')); $this->configProvider->expects($this->once())->method('getConfigs')->willReturn([$config1, $config2]); $this->securityConfigProvider->expects($this->atLeastOnce())->method('hasConfig')->willReturn(true); $securityConfig1 = $this->getMock('Oro\\Bundle\\EntityConfigBundle\\Config\\ConfigInterface'); $securityConfig1->expects($this->once())->method('get')->with('group_name')->willReturn(''); $securityConfig2 = $this->getMock('Oro\\Bundle\\EntityConfigBundle\\Config\\ConfigInterface'); $securityConfig2->expects($this->once())->method('get')->with('group_name')->willReturn('commerce'); $this->securityConfigProvider->expects($this->atLeastOnce())->method('getConfig')->will($this->onConsecutiveCalls($securityConfig1, $securityConfig2)); $this->cache->expects($this->once())->method('fetch')->with($this->equalTo('AcmeBundle\\Entity\\Account')); $this->provider->warmUpCache(); }
/** * Return "false" if can't find config for field, "null" if field type is unknown for given field * or array with config data for given field * * @param ClassMetadata $metadata * @param $field * @return array|bool */ protected function guessAttributeParametersScalarField(ClassMetadata $metadata, $field) { if ($metadata->hasField($field)) { $doctrineType = $metadata->getTypeOfField($field); if (!isset($this->doctrineTypeMapping[$doctrineType])) { return null; } return $this->formatResult($this->getLabel($metadata->getName(), $field), $this->doctrineTypeMapping[$doctrineType]['type'], $this->doctrineTypeMapping[$doctrineType]['options']); } elseif ($this->entityConfigProvider->hasConfig($metadata->getName(), $field)) { $entityConfig = $this->entityConfigProvider->getConfig($metadata->getName(), $field); $fieldType = $entityConfig->getId()->getFieldType(); if (!FieldTypeHelper::isRelation($fieldType)) { return $this->formatResult($entityConfig->get('label'), $this->doctrineTypeMapping[$fieldType]['type'], $this->doctrineTypeMapping[$fieldType]['options']); } } return false; }
/** * Return view link options or simple text * * @param object $targetEntity * @param ConfigInterface $field * * @throws \Doctrine\ORM\Mapping\MappingException * @return array|string */ protected function getValueForManyToOne($targetEntity, ConfigInterface $field) { $targetFieldName = $field->get('target_field'); $targetClassName = $field->get('target_entity'); if (!class_exists($targetClassName)) { return ''; } $title = (string) $this->propertyAccessor->getValue($targetEntity, $targetFieldName); $targetMetadata = $this->entityManager->getClassMetadata($targetClassName); $id = $this->propertyAccessor->getValue($targetEntity, $targetMetadata->getSingleIdentifierFieldName()); $relationExtendConfig = $this->extendProvider->getConfig($targetClassName); $routeOptions = $relationExtendConfig->is('owner', ExtendScope::OWNER_CUSTOM) ? $this->getCustomEntityViewRouteOptions($targetClassName, $id) : $this->getClassViewRouteOptions($targetClassName, $id); if ($routeOptions['route']) { return ['link' => $this->router->generate($routeOptions['route'], $routeOptions['route_params']), 'title' => $title]; } return $title; }
/** * @param ConfigInterface $fieldConfig * @param string $relationKey */ protected function createTargetRelation(ConfigInterface $fieldConfig, $relationKey) { /** @var FieldConfigId $fieldConfigId */ $fieldConfigId = $fieldConfig->getId(); $selfFieldId = new FieldConfigId('extend', $fieldConfigId->getClassName(), $fieldConfigId->getFieldName(), $this->fieldTypeHelper->getUnderlyingType($fieldConfigId->getFieldType())); $targetEntityClass = $fieldConfig->get('target_entity'); $selfConfig = $this->extendConfigProvider->getConfig($selfFieldId->getClassName()); $selfRelations = $selfConfig->get('relation'); $selfRelationConfig =& $selfRelations[$relationKey]; $selfRelationConfig['field_id'] = $selfFieldId; $targetConfig = $this->extendConfigProvider->getConfig($targetEntityClass); $targetRelations = $targetConfig->get('relation'); $targetRelationConfig =& $targetRelations[$relationKey]; $targetRelationConfig['target_field_id'] = $selfFieldId; $selfConfig->set('relation', $selfRelations); $targetConfig->set('relation', $targetRelations); $this->extendConfigProvider->persist($targetConfig); }
/** * @param ConfigInterface $config * @return bool */ public function filterFields(ConfigInterface $config) { $extendConfig = $this->extendProvider->getConfigById($config->getId()); /** @var FieldConfigId $fieldConfigId */ $fieldConfigId = $extendConfig->getId(); // skip system, new and deleted fields if (!$config->is('owner', ExtendScope::OWNER_CUSTOM) || $config->is('state', ExtendScope::STATE_NEW) || $config->is('is_deleted')) { return false; } // skip invisible fields if (!$this->viewProvider->getConfigById($config->getId())->is('is_displayable')) { return false; } // skip relations if they are referenced to deleted entity $underlyingFieldType = $this->fieldTypeHelper->getUnderlyingType($fieldConfigId->getFieldType()); if (in_array($underlyingFieldType, RelationType::$anyToAnyRelations) && $this->extendProvider->getConfig($extendConfig->get('target_entity'))->is('is_deleted', true)) { return false; } return true; }
public function testHandleUpdateNotAllowed() { $massActionMock = $this->getMock(MassActionInterface::class); $datagridMock = $this->getMock('Oro\\Bundle\\DataGridBundle\\Datagrid\\DatagridInterface'); $iteratorMock = $this->getMock('Oro\\Bundle\\DataGridBundle\\Datasource\\Orm\\IterableResultInterface'); $entityName = 'Test\\EntityName'; $hasConfig = true; $isEnabled = true; $isGranted = false; $data = []; $this->actionRepoMock->expects($this->once())->method('getEntityName')->with($datagridMock)->will($this->returnValue($entityName)); $this->configMock->expects($this->once())->method('hasConfig')->with($entityName)->will($this->returnValue($hasConfig)); $this->configMock->expects($this->once())->method('getConfig')->with($entityName)->will($this->returnValue(new Config(new EntityConfigId('extend', $entityName), ['update_mass_action_enabled' => $isEnabled]))); $this->securityMock->expects($this->once())->method('isGranted')->with('EDIT', 'entity:' . $entityName)->will($this->returnValue($isGranted)); $this->actionRepoMock->expects($this->never())->method('batchUpdate'); $this->transMock->expects($this->once())->method('trans')->will($this->returnValue(uniqid())); $options = ActionConfiguration::create(['success_message' => '', 'error_message' => '']); $massActionMock->expects($this->any())->method('getOptions')->will($this->returnValue($options)); $this->transMock->expects($this->once())->method('trans')->with('', ['%error%' => 'Action not configured or not allowed']); $this->loggerMock->expects($this->once())->method('debug'); $actionResponse = $this->handler->handle(new MassActionHandlerArgs($massActionMock, $datagridMock, $iteratorMock, $data)); $this->assertFalse($actionResponse->isSuccessful()); }
/** * Makes sure that both source and target entities know about a reverse relation * * @param ConfigInterface $fieldConfig */ protected function ensureReverseRelationCompleted(ConfigInterface $fieldConfig) { /** @var FieldConfigId $fieldConfigId */ $fieldConfigId = $fieldConfig->getId(); $relationKey = $fieldConfig->get('relation_key'); $selfConfig = $this->extendConfigProvider->getConfig($fieldConfigId->getClassName()); $selfRelations = $selfConfig->get('relation', false, []); if (isset($selfRelations[$relationKey]['field_id']) && $selfRelations[$relationKey]['field_id']) { return; } $targetConfig = $this->extendConfigProvider->getConfig($fieldConfig->get('target_entity')); $targetRelations = $targetConfig->get('relation', false, []); if (!isset($targetRelations[$relationKey])) { return; } $selfFieldId = new FieldConfigId('extend', $fieldConfigId->getClassName(), $fieldConfigId->getFieldName(), $this->fieldTypeHelper->getUnderlyingType($fieldConfigId->getFieldType())); $selfRelations[$relationKey]['field_id'] = $selfFieldId; $targetRelations[$relationKey]['target_field_id'] = $selfFieldId; $selfConfig->set('relation', $selfRelations); $targetConfig->set('relation', $targetRelations); $this->extendConfigProvider->persist($selfConfig); $this->extendConfigProvider->persist($targetConfig); }
public function testSetRolePrivileges() { $role = new AccountUserRole('TEST'); $roleSecurityIdentity = new RoleSecurityIdentity($role); $firstClass = 'FirstClass'; $secondClass = 'SecondClass'; $unknownClass = 'UnknownClass'; $request = new Request(); $request->setMethod('GET'); $firstEntityPrivilege = $this->createPrivilege('entity', 'entity:' . $firstClass, 'VIEW'); $firstEntityConfig = $this->createClassConfigMock(true); $secondEntityPrivilege = $this->createPrivilege('entity', 'entity:' . $secondClass, 'VIEW'); $secondEntityConfig = $this->createClassConfigMock(false); $unknownEntityPrivilege = $this->createPrivilege('entity', 'entity:' . $unknownClass, 'VIEW'); $actionPrivilege = $this->createPrivilege('action', 'action', 'random_action'); $entityForm = $this->getMock('Symfony\\Component\\Form\\FormInterface'); $entityForm->expects($this->once())->method('setData')->willReturnCallback(function (ArrayCollection $actualPrivileges) use($firstEntityPrivilege) { $this->assertEquals([$firstEntityPrivilege], array_values($actualPrivileges->toArray())); }); $actionForm = $this->getMock('Symfony\\Component\\Form\\FormInterface'); $actionForm->expects($this->once())->method('setData')->willReturnCallback(function (ArrayCollection $actualPrivileges) use($actionPrivilege) { $this->assertEquals([$actionPrivilege], array_values($actualPrivileges->toArray())); }); $form = $this->getMock('Symfony\\Component\\Form\\FormInterface'); $form->expects($this->any())->method('get')->willReturnMap([['entity', $entityForm], ['action', $actionForm]]); $this->formFactory->expects($this->once())->method('create')->willReturn($form); $this->chainMetadataProvider->expects($this->once())->method('startProviderEmulation')->with(FrontendOwnershipMetadataProvider::ALIAS); $this->chainMetadataProvider->expects($this->once())->method('stopProviderEmulation'); $this->aclManager->expects($this->any())->method('getSid')->with($role)->willReturn($roleSecurityIdentity); $this->privilegeRepository->expects($this->any())->method('getPrivileges')->with($roleSecurityIdentity)->willReturn(new ArrayCollection([$firstEntityPrivilege, $secondEntityPrivilege, $unknownEntityPrivilege, $actionPrivilege])); $this->ownershipConfigProvider->expects($this->any())->method('hasConfig')->willReturnMap([[$firstClass, null, true], [$secondClass, null, true], [$unknownClass, null, false]]); $this->ownershipConfigProvider->expects($this->any())->method('getConfig')->willReturnMap([[$firstClass, null, $firstEntityConfig], [$secondClass, null, $secondEntityConfig]]); $this->handler->setRequest($request); $this->handler->createForm($role); $this->handler->process($role); }
/** * @param ConfigInterface $extendConfig * @param ConfigProviderInterface $extendConfigProvider * * @return bool */ protected function isApplicableField(ConfigInterface $extendConfig, ConfigProviderInterface $extendConfigProvider) { return !$extendConfig->is('is_deleted') && $extendConfig->is('owner', ExtendScope::OWNER_CUSTOM) && !$extendConfig->is('state', ExtendScope::STATE_NEW) && !in_array($extendConfig->getId()->getFieldType(), ['ref-one', 'ref-many']) && (!$extendConfig->has('target_entity') || !$extendConfigProvider->getConfig($extendConfig->get('target_entity'))->is('is_deleted')); }
/** * @param string $className * @param string $fieldName * * @return bool */ public function processRelationAsScalar($className, $fieldName) { /** @var Config $fieldConfig */ $fieldConfig = $this->configProvider->getConfig($className, $fieldName); return $fieldConfig->is('process_as_scalar'); }