/**
* @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));
}
/**
* Makes sure the class hierarchy was loaded
*/
protected function ensureHierarchyInitialized()
{
if (null === $this->hierarchy) {
$this->hierarchy = [];
$entityConfigs = $this->extendConfigProvider->getConfigs();
foreach ($entityConfigs as $entityConfig) {
if ($entityConfig->in('state', [ExtendScope::STATE_NEW, ExtendScope::STATE_DELETE])) {
continue;
}
if ($entityConfig->is('is_deleted')) {
continue;
}
$className = $entityConfig->getId()->getClassName();
$parents = [];
$this->loadParents($parents, $className);
if (empty($parents)) {
continue;
}
// remove proxies if they are in list of parents
$parents = array_filter($parents, function ($parentClassName) {
return strpos($parentClassName, ExtendHelper::ENTITY_NAMESPACE) !== 0;
});
if (empty($parents)) {
continue;
}
$this->hierarchy[$className] = $parents;
}
}
}
/**
* Generate doctrine proxy classes for extended entities for the given entity manager
*
* @param EntityManager $em
*/
protected function generateEntityManagerProxies(EntityManager $em)
{
$isAutoGenerated = $em->getConfiguration()->getAutoGenerateProxyClasses();
if (!$isAutoGenerated) {
$proxyDir = $em->getConfiguration()->getProxyDir();
if (!empty($this->cacheDir) && $this->kernelCacheDir !== $this->cacheDir && strpos($proxyDir, $this->kernelCacheDir) === 0) {
$proxyDir = $this->cacheDir . substr($proxyDir, strlen($this->kernelCacheDir));
}
$metadataFactory = $em->getMetadataFactory();
$proxyFactory = $em->getProxyFactory();
$extendConfigs = $this->extendConfigProvider->getConfigs(null, true);
foreach ($extendConfigs as $extendConfig) {
if (!$extendConfig->is('is_extend')) {
continue;
}
if ($extendConfig->in('state', [ExtendScope::STATE_NEW])) {
continue;
}
$entityClass = $extendConfig->getId()->getClassName();
$proxyFileName = $proxyDir . DIRECTORY_SEPARATOR . '__CG__' . str_replace('\\', '', $entityClass) . '.php';
$metadata = $metadataFactory->getMetadataFor($entityClass);
$proxyFactory->generateProxyClasses([$metadata], $proxyDir);
clearstatcache(true, $proxyFileName);
}
}
}
/**
* {@inheritdoc}
*/
public function resolve(Route $route, RouteCollectionAccessor $routes)
{
if ($route->getOption('group') !== self::ROUTE_GROUP) {
return;
}
if ($this->hasAttribute($route, self::ACTIVITY_PLACEHOLDER)) {
$activities = array_map(function (ConfigInterface $config) {
// convert to entity alias
return $this->entityAliasResolver->getPluralAlias($config->getId()->getClassName());
}, $this->groupingConfigProvider->filter(function (ConfigInterface $config) {
// filter activity entities
$groups = $config->get('groups');
return !empty($groups) && in_array(ActivityScope::GROUP_ACTIVITY, $groups, true);
}));
if (!empty($activities)) {
$activities = $this->adjustRoutes($route, $routes, $activities);
if (!empty($activities)) {
$route->setRequirement(self::ACTIVITY_ATTRIBUTE, implode('|', $activities));
}
}
$this->completeRouteRequirements($route);
} elseif ($this->hasAttribute($route, self::ENTITY_PLACEHOLDER)) {
$this->completeRouteRequirements($route);
}
}
/**
* Handle prePersist.
*
* @param LifecycleEventArgs $args
* @throws \LogicException when getOwner method isn't implemented for entity with ownership type
*/
public function prePersist(LifecycleEventArgs $args)
{
$token = $this->getSecurityContext()->getToken();
if (!$token) {
return;
}
$user = $token->getUser();
if (!$user) {
return;
}
$entity = $args->getEntity();
if ($this->configProvider->hasConfig(get_class($entity))) {
$config = $this->configProvider->getConfig(get_class($entity));
$ownerType = $config->get('owner_type');
if ($ownerType && $ownerType !== OwnershipType::OWNER_TYPE_NONE) {
if (!method_exists($entity, 'getOwner')) {
throw new \LogicException(sprintf('Method getOwner must be implemented for %s entity', get_class($entity)));
}
if (!$entity->getOwner()) {
/**
* Automatically set current user as record owner
*/
if (OwnershipType::OWNER_TYPE_USER == $ownerType && method_exists($entity, 'setOwner')) {
$entity->setOwner($user);
}
}
}
}
}
protected function getEntityChoiceList($entityClassName, $relationType)
{
$configManager = $this->configProvider->getConfigManager();
$choices = array();
if ($this->targetEntity) {
$entityIds = array($this->configProvider->getId($this->targetEntity));
} else {
$entityIds = $configManager->getIds('extend');
}
if (in_array($relationType, array('oneToMany', 'manyToMany'))) {
$entityIds = array_filter($entityIds, function (EntityConfigId $configId) use($configManager) {
$config = $configManager->getConfig($configId);
return $config->is('is_extend');
});
}
$entityIds = array_filter($entityIds, function (EntityConfigId $configId) use($configManager) {
$config = $configManager->getConfig($configId);
return $config->is('is_extend', false) || !$config->is('state', ExtendScope::STATE_NEW);
});
foreach ($entityIds as $entityId) {
$className = $entityId->getClassName();
if ($className != $entityClassName) {
list($moduleName, $entityName) = ConfigHelper::getModuleAndEntityNames($className);
$choices[$className] = $moduleName . ':' . $entityName;
}
}
return $choices;
}
/**
* {@inheritdoc}
*/
public function buildForm(FormBuilderInterface $builder, array $options)
{
if (empty($options['data_class'])) {
return;
}
$className = $options['data_class'];
if (!$this->doctrineHelper->isManageableEntity($className)) {
return;
}
if (!$this->entityConfigProvider->hasConfig($className)) {
return;
}
$uniqueKeys = $this->entityConfigProvider->getConfig($className)->get('unique_key');
if (empty($uniqueKeys)) {
return;
}
/* @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 string $dataClass Parent entity class name
* @param File|Attachment $entity File entity
* @param string $fieldName Field name where new file/image field was added
*
* @return \Symfony\Component\Validator\ConstraintViolationListInterface
*/
public function validate($dataClass, $entity, $fieldName = '')
{
/** @var Config $entityAttachmentConfig */
if ($fieldName === '') {
$entityAttachmentConfig = $this->attachmentConfigProvider->getConfig($dataClass);
$mimeTypes = $this->getMimeArray($entityAttachmentConfig->get('mimetypes'));
if (!$mimeTypes) {
$mimeTypes = array_merge($this->getMimeArray($this->config->get('oro_attachment.upload_file_mime_types')), $this->getMimeArray($this->config->get('oro_attachment.upload_image_mime_types')));
}
} else {
$entityAttachmentConfig = $this->attachmentConfigProvider->getConfig($dataClass, $fieldName);
/** @var FieldConfigId $fieldConfigId */
$fieldConfigId = $entityAttachmentConfig->getId();
if ($fieldConfigId->getFieldType() === 'file') {
$configValue = 'upload_file_mime_types';
} else {
$configValue = 'upload_image_mime_types';
}
$mimeTypes = $this->getMimeArray($this->config->get('oro_attachment.' . $configValue));
}
$fileSize = $entityAttachmentConfig->get('maxsize') * 1024 * 1024;
foreach ($mimeTypes as $id => $value) {
$mimeTypes[$id] = trim($value);
}
return $this->validator->validate($entity->getFile(), [new FileConstraint(['maxSize' => $fileSize, 'mimeTypes' => $mimeTypes])]);
}
/**
* Handle prePersist.
*
* @param LifecycleEventArgs $args
* @throws \LogicException when getOwner method isn't implemented for entity with ownership type
*/
public function prePersist(LifecycleEventArgs $args)
{
$token = $this->getSecurityContext()->getToken();
if (!$token) {
return;
}
$user = $token->getUser();
if (!$user) {
return;
}
$entity = $args->getEntity();
$className = ClassUtils::getClass($entity);
if ($this->configProvider->hasConfig($className)) {
$accessor = PropertyAccess::createPropertyAccessor();
$config = $this->configProvider->getConfig($className);
$ownerType = $config->get('owner_type');
$ownerFieldName = $config->get('owner_field_name');
// set default owner for organization and user owning entities
if ($ownerType && in_array($ownerType, [OwnershipType::OWNER_TYPE_ORGANIZATION, OwnershipType::OWNER_TYPE_USER]) && !$accessor->getValue($entity, $ownerFieldName)) {
$owner = null;
if (OwnershipType::OWNER_TYPE_USER == $ownerType) {
$owner = $user;
} elseif (OwnershipType::OWNER_TYPE_ORGANIZATION == $ownerType && $token instanceof OrganizationContextTokenInterface) {
$owner = $token->getOrganizationContext();
}
$accessor->setValue($entity, $ownerFieldName, $owner);
}
//set organization
$this->setDefaultOrganization($token, $config, $entity);
}
}
/**
* @param ConfigureMenuEvent $event
*/
public function onNavigationConfigure(ConfigureMenuEvent $event)
{
/** @var ItemInterface $reportsMenuItem */
$reportsMenuItem = $event->getMenu()->getChild('reports_tab');
if ($reportsMenuItem && $this->securityFacade->hasLoggedUser()) {
$qb = $this->em->getRepository('OroReportBundle:Report')->createQueryBuilder('report')->orderBy('report.name', 'ASC');
$reports = $this->aclHelper->apply($qb)->execute();
if (!empty($reports)) {
$this->addDivider($reportsMenuItem);
$reportMenuData = [];
foreach ($reports as $report) {
$config = $this->entityConfigProvider->getConfig($report->getEntity());
if ($this->checkAvailability($config)) {
$entityLabel = $config->get('plural_label');
if (!isset($reportMenuData[$entityLabel])) {
$reportMenuData[$entityLabel] = [];
}
$reportMenuData[$entityLabel][$report->getId()] = $report->getName();
}
}
ksort($reportMenuData);
$this->buildReportMenu($reportsMenuItem, $reportMenuData);
}
}
}
/**
* {@inheritdoc}
*/
public function process(ContextInterface $context)
{
/** @var ConfigContext $context */
$definition = $context->getResult();
if (empty($definition)) {
// an entity configuration does not exist
return;
}
$entityClass = $context->getClassName();
if (!isset($definition[ConfigUtil::LABEL])) {
$entityName = $this->entityClassNameProvider->getEntityClassName($entityClass);
if ($entityName) {
$definition[ConfigUtil::LABEL] = $entityName;
}
}
if (!isset($definition[ConfigUtil::PLURAL_LABEL])) {
$entityPluralName = $this->entityClassNameProvider->getEntityClassPluralName($entityClass);
if ($entityPluralName) {
$definition[ConfigUtil::PLURAL_LABEL] = $entityPluralName;
}
}
if (!isset($definition[ConfigUtil::DESCRIPTION]) && $this->entityConfigProvider->hasConfig($entityClass)) {
$definition[ConfigUtil::DESCRIPTION] = new Label($this->entityConfigProvider->getConfig($entityClass)->get('description'));
}
$context->setResult($definition);
}
/**
* Return available in template variables
*
* @param string $entityName
* @return array
*/
public function getTemplateVariables($entityName)
{
$userClassName = $this->getUser() ? get_class($this->getUser()) : false;
$allowedData = array('entity' => array(), 'user' => array());
$ids = $this->configProvider->getIds();
foreach ($ids as $entityConfigId) {
// export variables of asked entity and current user entity class
$className = $entityConfigId->getClassName();
if ($className == $entityName || $className == $userClassName) {
$fields = $this->configProvider->filter(function (ConfigInterface $config) {
return $config->is('available_in_template');
}, $className);
$fields = array_values(array_map(function (ConfigInterface $field) {
return $field->getId()->getFieldName();
}, $fields));
switch ($className) {
case $entityName:
$allowedData['entity'] = $fields;
break;
case $userClassName:
$allowedData['user'] = $fields;
break;
}
if ($entityName == $userClassName) {
$allowedData['user'] = $allowedData['entity'];
}
}
}
return $allowedData;
}
/**
* Checks if the entity can has notes
*
* @param object $entity
* @return bool
*/
public function isAttachmentAssociationEnabled($entity)
{
if (null === $entity || !is_object($entity)) {
return false;
}
$className = ClassUtils::getClass($entity);
return $this->attachmentConfigProvider->hasConfig($className) && $this->attachmentConfigProvider->getConfig($className)->is('enabled') && $this->entityConfigProvider->hasConfig(AttachmentScope::ATTACHMENT, ExtendHelper::buildAssociationName($className));
}
/**
* Checks if the entity can have comments
*
* @param object|null $entity
*
* @return bool
*/
public function isApplicable($entity)
{
if (!is_object($entity) || !$this->doctrineHelper->isManageableEntity($entity) || !$this->securityFacade->isGranted('oro_comment_view')) {
return false;
}
$className = ClassUtils::getClass($entity);
return $this->commentConfigProvider->hasConfig($className) && $this->commentConfigProvider->getConfig($className)->is('enabled') && $this->entityConfigProvider->hasConfig(Comment::ENTITY_NAME, ExtendHelper::buildAssociationName($className));
}
/**
* @param mixed $entity
* @param bool $show
*
* @return bool
*/
public function isEntityAuditable($entity, $show)
{
if ($show || !is_object($entity)) {
return $show;
}
$className = ClassUtils::getClass($entity);
return $this->configProvider->hasConfig($className) && $this->configProvider->getConfig($className)->is('auditable');
}
/**
* {@inheritdoc}
*/
public function supports(array $schema)
{
if (!$this->groupingConfigProvider->hasConfig($schema['class'])) {
return false;
}
$groups = $this->groupingConfigProvider->getConfig($schema['class'])->get('groups');
return !empty($groups) && in_array(ActivityScope::GROUP_ACTIVITY, $groups);
}
/**
* Adds entities to $result
*
* @param array $result
*/
protected function addEntities(array &$result)
{
// only configurable entities are supported
$configs = $this->entityConfigProvider->getConfigs();
foreach ($configs as $config) {
$this->addEntity($result, $config->getId()->getClassName(), $config->get('label'), $config->get('plural_label'), $config->get('icon'));
}
}
/**
* Checks if the entity can be shared
*
* @param object $entity
* @return bool
*/
public function isShareEnabled($entity)
{
if (null === $entity || !is_object($entity)) {
return false;
}
$className = ClassUtils::getClass($entity);
return $this->securityFacade->isGranted('SHARE', $entity) && $this->configProvider->hasConfig($className) && $this->configProvider->getConfig($className)->get('share_scopes');
}
public function buildForm(FormBuilderInterface $builder, array $options)
{
$this->config = $this->configProvider->getConfigById($options['config_id']);
$this->formFactory = $builder->getFormFactory();
$builder->add('target_entity', new TargetType($this->configProvider, $options['config_id']), ['constraints' => [new Assert\NotBlank()]]);
$builder->addEventListener(FormEvents::PRE_SET_DATA, array($this, 'preSubmitData'));
$builder->addEventListener(FormEvents::PRE_SUBMIT, array($this, 'preSubmitData'));
}
/**
* Checks if the entity can has notes
*
* @param object $entity
* @return bool
*/
public function isNoteAssociationEnabled($entity)
{
if (null === $entity || !is_object($entity)) {
return false;
}
$className = ClassUtils::getClass($entity);
return $this->noteConfigProvider->hasConfig($className) && $this->noteConfigProvider->getConfig($className)->is('enabled') && $this->entityConfigProvider->hasConfig(Note::ENTITY_NAME, ExtendHelper::buildAssociationName($className));
}
/**
* Gets translated field name by its name
*
* @param string $className
* @param string $fieldName
*
* @return string
*/
protected function getFieldLabel($className, $fieldName)
{
if (!$this->entityConfigProvider->hasConfig($className, $fieldName)) {
return $fieldName;
}
$fieldLabel = $this->entityConfigProvider->getConfig($className, $fieldName)->get('label');
return $this->translator->trans($fieldLabel);
}
/**
* @param $entity
* @return string
*/
public function getOwnerType($entity)
{
$ownerClassName = ClassUtils::getRealClass(get_class($entity));
if (!$this->configProvider->hasConfig($ownerClassName)) {
return;
}
$config = $this->configProvider->getConfig($ownerClassName)->all();
return $config['owner_type'];
}
/**
* @param object $entity
* @return string
*/
public function getOwnerType($entity)
{
$ownerClassName = ClassUtils::getRealClass($entity);
if (!$this->configProvider->hasConfig($ownerClassName)) {
return null;
}
$config = $this->configProvider->getConfig($ownerClassName);
return $config->get('owner_type');
}
/**
* @SuppressWarnings(PHPMD.ExcessiveMethodLength)
*/
public function testCreateEntityMetadataByClass()
{
$this->doctrineHelper->expects($this->once())->method('getMetadataFor')->with(self::CLASS_NAME)->will($this->returnValue($this->classMetadata));
$this->entityExtendConfigProvider->expects($this->any())->method('getConfigs')->with(static::CLASS_NAME)->will($this->returnValue([]));
$this->classMetadata->name = static::CLASS_NAME;
$this->classMetadata->expects($this->any())->method('getIdentifierFieldNames')->will($this->returnValue(['id']));
// Test creation of entity metadata
$entityMetadataCallIndex = 0;
$entityMetadata = $this->createEntityMetadata();
$metadataFactoryCallIndex = 0;
$this->metadataFactory->expects($this->at($metadataFactoryCallIndex++))->method('createEntityMetadata')->with([], $this->isType('array'))->will($this->returnValue($entityMetadata));
// Test adding doctrine fields
$doctrineFieldNames = ['id', 'foo_field', 'bar_field'];
$doctrineFieldNamesWithoutId = ['foo_field', 'bar_field'];
$idFieldNames = ['id'];
$this->classMetadata->expects($this->any())->method('getIdentifierFieldNames')->will($this->returnValue($idFieldNames));
$this->classMetadata->expects($this->any())->method('getFieldNames')->will($this->returnValue($doctrineFieldNames));
$this->classMetadata->expects($this->any())->method('getFieldMapping')->will($this->returnCallback(function ($fieldName) {
return ['fieldName' => $fieldName];
}));
foreach ($doctrineFieldNamesWithoutId as $fieldName) {
$fieldMapping = ['fieldName' => $fieldName];
$fieldMetadata = $this->createFieldMetadata();
$this->metadataFactory->expects($this->at($metadataFactoryCallIndex++))->method('createFieldMetadata')->with(['field_name' => $fieldName], $fieldMapping)->will($this->returnValue($fieldMetadata));
$entityMetadata->expects($this->at($entityMetadataCallIndex++))->method('addFieldMetadata')->with($fieldMetadata);
}
// Test adding doctrine associations
$associationMappings = ['foo_association' => ['foo' => 'bar'], 'bar_association' => ['bar' => 'baz']];
$this->classMetadata->expects($this->any())->method('getAssociationNames')->will($this->returnValue(array_keys($associationMappings)));
$this->classMetadata->expects($this->any())->method('getAssociationMapping')->will($this->returnCallback(function ($association) use($associationMappings) {
return $associationMappings[$association];
}));
foreach ($associationMappings as $fieldName => $associationMapping) {
$fieldMetadata = $this->createFieldMetadata();
$this->metadataFactory->expects($this->at($metadataFactoryCallIndex++))->method('createFieldMetadata')->with(['field_name' => $fieldName], $associationMapping)->will($this->returnValue($fieldMetadata));
$entityMetadata->expects($this->at($entityMetadataCallIndex++))->method('addFieldMetadata')->with($fieldMetadata);
}
// Test adding doctrine inverse associations
$allMetadata = [self::CLASS_NAME => $this->classMetadata, 'Namespace\\FooEntity' => $fooClassMetadata = $this->createClassMetadata(), 'Namespace\\BarEntity' => $barClassMetadata = $this->createClassMetadata(), 'Namespace\\FooBarEntity' => $fooBarClassMetadata = $this->createClassMetadata()];
$expectedClassesData = ['Namespace\\FooEntity' => ['associationMappings' => ['foo_association' => ['foo' => 'bar', 'type' => ClassMetadataInfo::ONE_TO_MANY]], 'expectedFields' => ['foo_association' => ['field_name' => 'Namespace_FooEntity_foo_association', 'merge_modes' => [MergeModes::UNITE], 'source_field_name' => 'foo_association', 'source_class_name' => 'Namespace\\FooEntity']]], 'Namespace\\BarEntity' => ['associationMappings' => ['bar_association' => ['bar' => 'baz', 'type' => ClassMetadataInfo::ONE_TO_MANY], 'skipped_many_to_many' => ['type' => ClassMetadataInfo::MANY_TO_MANY], 'skipped_mapped_by' => ['mappedBy' => self::CLASS_NAME]], 'expectedFields' => ['bar_association' => ['field_name' => 'Namespace_BarEntity_bar_association', 'merge_modes' => [MergeModes::UNITE], 'source_field_name' => 'bar_association', 'source_class_name' => 'Namespace\\BarEntity']]], 'Namespace\\FooBarEntity' => ['associationMappings' => ['bar_association' => ['bar' => 'baz', 'type' => ClassMetadataInfo::ONE_TO_ONE]], 'expectedFields' => ['bar_association' => ['field_name' => 'Namespace_FooBarEntity_bar_association', 'merge_modes' => [MergeModes::REPLACE], 'source_field_name' => 'bar_association', 'source_class_name' => 'Namespace\\FooBarEntity']]]];
$this->doctrineHelper->expects($this->once())->method('getAllMetadata')->will($this->returnValue(array_values($allMetadata)));
foreach ($expectedClassesData as $className => $expectedData) {
$metadata = $allMetadata[$className];
$metadata->expects($this->once())->method('getName')->will($this->returnValue($className));
$metadata->expects($this->once())->method('getAssociationsByTargetClass')->with(self::CLASS_NAME)->will($this->returnValue($expectedData['associationMappings']));
foreach ($expectedData['expectedFields'] as $fieldName => $expectedOptions) {
$expectedAssociationMapping = $expectedData['associationMappings'][$fieldName];
$expectedAssociationMapping['mappedBySourceEntity'] = false;
$fieldMetadata = $this->createFieldMetadata();
$this->metadataFactory->expects($this->at($metadataFactoryCallIndex++))->method('createFieldMetadata')->with($expectedOptions, $expectedAssociationMapping)->will($this->returnValue($fieldMetadata));
$entityMetadata->expects($this->at($entityMetadataCallIndex++))->method('addFieldMetadata')->with($fieldMetadata);
}
}
// Test event dispatcher
$this->eventDispatcher->expects($this->once())->method('dispatch')->with(MergeEvents::BUILD_METADATA, new EntityMetadataEvent($entityMetadata));
$this->assertEquals($entityMetadata, $this->metadataBuilder->createEntityMetadataByClass(self::CLASS_NAME));
}
/**
* @param ClassMetadataBuilder $metadataBuilder
* @param string $className
*/
public function build(ClassMetadataBuilder $metadataBuilder, $className)
{
$extendConfig = $this->extendConfigProvider->getConfig($className);
foreach ($this->builders as $builder) {
if ($builder->supports($extendConfig)) {
$builder->build($metadataBuilder, $extendConfig);
}
}
}
public function testIsNoteAssociationEnabled()
{
$config = new Config(new EntityConfigId('note', static::TEST_ENTITY_REFERENCE));
$config->set('enabled', true);
$this->noteConfigProvider->expects($this->once())->method('hasConfig')->with(static::TEST_ENTITY_REFERENCE)->will($this->returnValue(true));
$this->noteConfigProvider->expects($this->once())->method('getConfig')->with(static::TEST_ENTITY_REFERENCE)->will($this->returnValue($config));
$this->entityConfigProvider->expects($this->once())->method('hasConfig')->with(Note::ENTITY_NAME, ExtendHelper::buildAssociationName(static::TEST_ENTITY_REFERENCE))->will($this->returnValue(true));
$this->assertTrue($this->filter->isNoteAssociationEnabled(new TestEntity(1)));
}
/**
* {@inheritdoc}
*/
public function beforeValueRender(ValueRenderEvent $event)
{
$fieldConfig = $this->configProvider->getConfigById($event->getFieldConfigId());
$contactInformationType = $fieldConfig->get('contact_information');
// if some contact information type is defined -- applies proper template for its value
if (null !== $contactInformationType && isset($this->contactInformationMap[$contactInformationType])) {
$event->setFieldViewValue(['value' => $event->getFieldValue(), 'entity' => $event->getEntity(), 'template' => $this->contactInformationMap[$contactInformationType]]);
}
}
protected function prepareConfigProvider(array $configValues, $className)
{
/** @var \PHPUnit_Framework_MockObject_MockObject|ConfigIdInterface $configId */
$configId = $this->getMock('Oro\\Bundle\\EntityConfigBundle\\Config\\Id\\ConfigIdInterface');
$entityConfig = new Config($configId);
$entityConfig->setValues($configValues);
$this->configProvider->expects($this->once())->method('hasConfig')->with($this->equalTo($className))->will($this->returnValue(true));
$this->configProvider->expects($this->once())->method('getConfig')->with($this->equalTo($className))->will($this->returnValue($entityConfig));
}
/**
* @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 Tag $tag
*
* @return array ['' => [count], $alias => [count, icon, label, class => true]]
*/
public function getTagEntitiesStatistic(Tag $tag)
{
$groupedResult = $this->getGroupedTagEntities($tag);
return array_reduce($groupedResult, function ($result, array $entityResult) {
$result['']['count'] += $entityResult['cnt'];
$entityClass = $entityResult['entityClass'];
$alias = $this->entityAliasResolver->getAlias($entityClass);
$result[$alias] = ['count' => $entityResult['cnt'], 'icon' => $this->entityConfigProvider->getConfig($entityClass)->get('icon'), 'label' => $this->entityConfigProvider->getConfig($entityClass)->get('plural_label'), 'class' => true];
return $result;
}, ['' => ['count' => 0]]);
}
