/**
* @param BuildBefore $event
* @return bool
*/
public function onBuildBefore(BuildBefore $event)
{
$datagrid = $event->getDatagrid();
$config = $event->getConfig();
$entityClassName = $datagrid->getParameters()->get('class_name');
$fieldName = $datagrid->getParameters()->get('field_name');
$entityId = $datagrid->getParameters()->get('id');
$extendConfigProvider = $this->configManager->getProvider('extend');
$extendFieldConfig = $extendConfigProvider->getConfig($entityClassName, $fieldName);
$targetEntityName = $extendFieldConfig->get('target_entity');
$targetFieldNames = $extendFieldConfig->get('target_grid');
// build 'assigned' field expression
if ($entityId) {
$extendEntityConfig = $extendConfigProvider->getConfig($entityClassName);
$relations = $extendEntityConfig->get('relation');
$relation = $relations[$extendFieldConfig->get('relation_key')];
$targetFieldName = $relation['target_field_id']->getFieldName();
$fieldType = $extendFieldConfig->getId()->getFieldType();
$operator = $fieldType == 'oneToMany' ? '=' : 'MEMBER OF';
$whenExpr = '(:relation ' . $operator . ' o.' . $targetFieldName . ' OR o.id IN (:data_in))' . ' AND o.id NOT IN (:data_not_in)';
} else {
$whenExpr = 'o.id IN (:data_in) AND o.id NOT IN (:data_not_in)';
}
$assignedExpr = "CASE WHEN " . $whenExpr . " THEN true ELSE false END";
// build a query skeleton
$query = ['select' => ['o.id', $assignedExpr . ' as assigned'], 'from' => [['table' => $targetEntityName, 'alias' => 'o']]];
$config->offsetSetByPath('[source][query]', $query);
// enable AdditionalFieldsExtension to add all other fields
$config->offsetSetByPath('[options][entity_name]', $targetEntityName);
$config->offsetSetByPath('[options][additional_fields]', $targetFieldNames);
}
/**
* {@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;
}
/**
* Options:
* - grid_name - name of grid that will be used for entity selection
* - grid_parameters - parameters need to be passed to grid request
* - grid_render_parameters - render parameters need to be set for grid rendering
* - existing_entity_grid_id - grid row field name used as entity identifier
* - create_enabled - enables new entity creation
* - create_acl - ACL resource used to determine that create is allowed, by default CREATE for entity used
* - create_form_route - route name for creation form
* - create_form_route_parameters - route parameters for create_form_route_parameters
*
* {@inheritDoc}
*/
public function setDefaultOptions(OptionsResolverInterface $resolver)
{
$resolver->setDefaults(['existing_entity_grid_id' => 'id', 'create_enabled' => true, 'create_acl' => null, 'create_form_route' => null, 'create_form_route_parameters' => [], 'grid_name' => null, 'grid_parameters' => [], 'grid_render_parameters' => []]);
$resolver->setNormalizers(['create_enabled' => function (Options $options, $createEnabled) {
$createRouteName = $options->get('create_form_route');
$createEnabled = $createEnabled && !empty($createRouteName);
if ($createEnabled) {
$aclName = $options->get('create_acl');
if (empty($aclName)) {
$aclObjectName = 'Entity:' . $options->get('entity_class');
$createEnabled = $this->securityFacade->isGranted('CREATE', $aclObjectName);
} else {
$createEnabled = $this->securityFacade->isGranted($aclName);
}
}
return $createEnabled;
}, 'grid_name' => function (Options $options, $gridName) {
if (!empty($gridName)) {
return $gridName;
}
$formConfig = $this->configManager->getProvider('form')->getConfig($options->get('entity_class'));
if ($formConfig->has('grid_name')) {
return $formConfig->get('grid_name');
}
throw new InvalidConfigurationException('The option "grid_name" must be set.');
}]);
}
/**
* {@inheritdoc}
*/
public function buildForm(FormBuilderInterface $builder, array $options)
{
$configModel = $options['config_model'];
$data = array();
if ($configModel instanceof FieldConfigModel) {
$className = $configModel->getEntity()->getClassName();
$fieldName = $configModel->getFieldName();
$fieldType = $configModel->getType();
$configType = PropertyConfigContainer::TYPE_FIELD;
} else {
$className = $configModel->getClassName();
$fieldName = null;
$fieldType = null;
$configType = PropertyConfigContainer::TYPE_ENTITY;
}
foreach ($this->configManager->getProviders() as $provider) {
if ($provider->getPropertyConfig()->hasForm($configType, $fieldType)) {
$config = $provider->getConfig($className, $fieldName);
$builder->add($provider->getScope(), new ConfigScopeType($provider->getPropertyConfig()->getFormItems($configType, $fieldType), $config, $this->configManager, $configModel), array('block_config' => (array) $provider->getPropertyConfig()->getFormBlockConfig($configType)));
$data[$provider->getScope()] = $config->all();
}
}
if ($fieldType == 'optionSet') {
$data['extend']['set_options'] = $this->configManager->getEntityManager()->getRepository(OptionSet::ENTITY_NAME)->findOptionsByField($configModel->getId());
}
$builder->setData($data);
$builder->addEventSubscriber(new ConfigSubscriber($this->configManager));
}
protected function getEntityChoiceList($entityClassName, $relationType)
{
$choices = array();
$extendEntityConfig = $this->configManager->getProvider('extend');
/** @var EntityConfigId[] $entityIds */
$entityIds = $this->targetEntity ? array($extendEntityConfig->getId($this->targetEntity)) : $extendEntityConfig->getIds();
if (in_array($relationType, array(RelationTypeBase::ONE_TO_MANY, RelationTypeBase::MANY_TO_MANY))) {
$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('is_extend', false) || !$config->is('state', ExtendScope::STATE_NEW);
});
foreach ($entityIds as $entityId) {
$className = $entityId->getClassName();
if ($className != $entityClassName) {
$entityConfig = $this->configManager->getProvider('entity')->getConfig($className);
$choices[$className] = new ChoiceListItem($entityConfig->get('label'), array('data-icon' => $entityConfig->get('icon')));
}
}
return $choices;
}
public function testFlush()
{
$model = new EntityConfigModel(self::ENTITY_CLASS);
$entityConfigId = new EntityConfigId('entity', self::ENTITY_CLASS);
$entityConfig = new Config($entityConfigId);
$entityConfig->set('icon', 'test_icon');
$entityConfig->set('label', 'test_label');
$entityPropertyConfig = new PropertyConfigContainer(['entity' => ['items' => ['icon' => [], 'label' => ['options' => ['indexed' => true]]]]]);
$this->entityConfigProvider->expects($this->once())->method('getPropertyConfig')->will($this->returnValue($entityPropertyConfig));
$testConfigId = new EntityConfigId('test', self::ENTITY_CLASS);
$testConfig = new Config($testConfigId);
$testConfig->set('attr1', 'test_attr1');
$testPropertyConfig = new PropertyConfigContainer(['entity' => ['items' => ['attr1' => []]]]);
$this->testConfigProvider->expects($this->once())->method('getPropertyConfig')->will($this->returnValue($testPropertyConfig));
$this->modelManager->expects($this->once())->method('getEntityModel')->with($entityConfigId->getClassName())->will($this->returnValue($model));
$em = $this->getMockBuilder('Doctrine\\ORM\\EntityManager')->disableOriginalConstructor()->getMock();
$this->modelManager->expects($this->any())->method('getEntityManager')->will($this->returnValue($em));
$this->setFlushExpectations($em, [$model]);
$this->eventDispatcher->expects($this->at(2))->method('dispatch')->with(Events::PRE_FLUSH, new PreFlushConfigEvent(['entity' => $entityConfig, 'test' => $testConfig], $this->configManager));
$this->configManager->persist($entityConfig);
$this->configManager->persist($testConfig);
$this->configManager->flush();
$this->assertEquals(['icon' => 'test_icon', 'label' => 'test_label'], $model->toArray('entity'));
$this->assertEquals(['attr1' => 'test_attr1'], $model->toArray('test'));
$this->assertCount(3, $model->getIndexedValues());
$this->assertEquals('entity_config', $model->getIndexedValues()[0]->getScope());
$this->assertEquals('module_name', $model->getIndexedValues()[0]->getCode());
$this->assertEquals('entity_config', $model->getIndexedValues()[1]->getScope());
$this->assertEquals('entity_name', $model->getIndexedValues()[1]->getCode());
$this->assertEquals('entity', $model->getIndexedValues()[2]->getScope());
$this->assertEquals('label', $model->getIndexedValues()[2]->getCode());
}
/**
* {@inheritdoc}
*/
public function getConfiguration()
{
$configuration = parent::getConfiguration();
$className = $this->source->getEntity();
$metadata = $this->configManager->getEntityMetadata($className);
if (!$metadata || empty($metadata->routeView)) {
return $configuration;
}
$fromPart = $configuration->offsetGetByPath('[source][query][from]');
$entityAlias = null;
$doctrineMetadata = $this->doctrine->getManagerForClass($className)->getClassMetadata($className);
$identifiers = $doctrineMetadata->getIdentifier();
$primaryKey = array_shift($identifiers);
foreach ($fromPart as $piece) {
if ($piece['table'] == $className) {
$entityAlias = $piece['alias'];
break;
}
}
if (!$entityAlias || !$primaryKey || count($identifiers) > 1 || !$this->isActionSupported($primaryKey)) {
return $configuration;
}
$viewAction = ['view' => ['type' => 'navigate', 'label' => 'oro.report.datagrid.view', 'acl_resource' => 'VIEW;entity:' . $className, 'icon' => 'eye-open', 'link' => 'view_link', 'rowAction' => true]];
$properties = [$primaryKey => null, 'view_link' => ['type' => 'url', 'route' => $metadata->routeView, 'params' => [$primaryKey]]];
$configuration->offsetAddToArrayByPath('[source][query][select]', ["{$entityAlias}.{$primaryKey}"]);
$configuration->offsetAddToArrayByPath('[properties]', $properties);
$configuration->offsetAddToArrayByPath('[actions]', $viewAction);
return $configuration;
}
/**
* Generate doctrine proxy classes for extended entities
*/
public function generateProxies()
{
$em = $this->configManager->getEntityManager();
$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));
}
$extendConfigProvider = $this->configManager->getProvider('extend');
$extendConfigs = $extendConfigProvider->getConfigs(null, true);
$metadataFactory = $em->getMetadataFactory();
$proxyFactory = $em->getProxyFactory();
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);
}
}
}
/**
* 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;
}
/**
* @return ConfigProvider
*/
protected function getExtendConfigProvider()
{
if (!$this->extendConfigProvider) {
$this->extendConfigProvider = $this->configManager->getProvider('extend');
}
return $this->extendConfigProvider;
}
/**
* POST_SUBMIT event handler
*
* @param FormEvent $event
*/
public function postSubmit(FormEvent $event)
{
$form = $event->getForm();
$options = $form->getConfig()->getOptions();
/** @var ConfigIdInterface $configId */
$configId = $options['config_id'];
if (!$form->isValid()) {
return;
}
// change the entity state to "Requires update" if the attribute has "require_schema_update" option
// and the value of the attribute was changed
$configProvider = $this->configManager->getProvider($configId->getScope());
if ($configProvider->getPropertyConfig()->isSchemaUpdateRequired($form->getName(), $configId)) {
$newVal = $form->getData();
$oldVal = $this->configManager->getConfig($configId)->get($form->getName());
if ($this->isSchemaUpdateRequired($newVal, $oldVal)) {
$extendConfigProvider = $this->configManager->getProvider('extend');
$extendConfig = $extendConfigProvider->getConfig($configId->getClassName());
if ($extendConfig->is('state', ExtendScope::STATE_ACTIVE)) {
$extendConfig->set('state', ExtendScope::STATE_UPDATE);
$this->configManager->persist($extendConfig);
}
}
}
}
/**
* {@inheritdoc}
*/
public function buildView(FormView $view, FormInterface $form, array $options)
{
$vars = ['configs' => $options['configs']];
if ($form->getData()) {
$data = $form->getParent()->getData();
$fieldConfig = $this->cm->getProvider('extend')->getConfig($data, $form->getName());
if ($form->getData()) {
/** @var ConverterInterface|EntitySelectHandler $converter */
$converter = $options['converter'];
$result = [];
if ($converter instanceof EntitySelectHandler) {
$converter->initForEntity($fieldConfig->getId()->getClassName(), $fieldConfig->get('target_field'));
}
if (isset($options['configs']['multiple']) && $options['configs']['multiple']) {
foreach ($form->getData() as $item) {
$result[] = $converter->convertItem($item);
}
} else {
$result[] = $converter->convertItem($form->getData());
}
$vars['attr'] = ['data-selected-data' => json_encode($result)];
}
}
$view->vars = array_replace_recursive($view->vars, $vars);
}
/**
* {@inheritdoc}
*/
public function preUpdate()
{
$extendConfigProvider = $this->configManager->getProvider('extend');
$entityConfigs = $extendConfigProvider->getConfigs();
foreach ($entityConfigs as $entityConfig) {
if (!$entityConfig->is('is_extend')) {
continue;
}
$fieldConfigs = $extendConfigProvider->getConfigs($entityConfig->getId()->getClassName());
foreach ($fieldConfigs as $fieldConfig) {
if (!$fieldConfig->is('state', ExtendScope::STATE_NEW)) {
continue;
}
/** @var FieldConfigId $fieldConfigId */
$fieldConfigId = $fieldConfig->getId();
if (in_array($fieldConfigId->getFieldType(), ['file', 'image'])) {
// create a relation
$relationKey = $this->relationBuilder->addManyToOneRelation($entityConfig, 'Oro\\Bundle\\AttachmentBundle\\Entity\\File', $fieldConfigId->getFieldName(), 'id', ['importexport' => ['process_as_scalar' => true]], $fieldConfigId->getFieldType());
// set cascade persist
$relations = $entityConfig->get('relation');
$cascade = isset($relations[$relationKey]['cascade']) ? $relations[$relationKey]['cascade'] : [];
$cascade[] = 'persist';
$relations[$relationKey]['cascade'] = $cascade;
$entityConfig->set('relation', $relations);
$extendConfigProvider->persist($entityConfig);
}
}
}
}
/**
* @param LoggerInterface $logger
* @param bool $dryRun
*/
protected function runActivityLists(LoggerInterface $logger, $dryRun = false)
{
// @todo: this workaround should be removed in BAP-9156
$this->configManager->clear();
$targetEntities = $this->provider->getTargetEntityClasses(false);
$toSchema = clone $this->schema;
$hasSchemaChanges = false;
foreach ($targetEntities as $targetEntity) {
$associationName = ExtendHelper::buildAssociationName($targetEntity, ActivityListEntityConfigDumperExtension::ASSOCIATION_KIND);
$relationTableName = $this->nameGenerator->generateManyToManyJoinTableName(ActivityListEntityConfigDumperExtension::ENTITY_CLASS, $associationName, $targetEntity);
if (!$toSchema->hasTable($relationTableName)) {
$hasSchemaChanges = true;
$this->activityListExtension->addActivityListAssociation($toSchema, $this->metadataHelper->getTableNameByEntityClass($targetEntity));
}
}
if ($hasSchemaChanges) {
$comparator = new Comparator();
$platform = $this->connection->getDatabasePlatform();
$schemaDiff = $comparator->compare($this->schema, $toSchema);
$queries = $schemaDiff->toSql($platform);
foreach ($queries as $query) {
$this->logQuery($logger, $query);
if (!$dryRun) {
$this->connection->executeQuery($query);
}
}
}
}
/**
* {@inheritdoc}
*/
public function preUpdate()
{
$extendConfigProvider = $this->configManager->getProvider('extend');
$entityConfigs = $extendConfigProvider->getConfigs();
foreach ($entityConfigs as $entityConfig) {
if (!$entityConfig->is('is_extend')) {
continue;
}
$fieldConfigs = $extendConfigProvider->getConfigs($entityConfig->getId()->getClassName());
foreach ($fieldConfigs as $fieldConfig) {
if (!$fieldConfig->in('state', [ExtendScope::STATE_NEW, ExtendScope::STATE_UPDATE])) {
continue;
}
/** @var FieldConfigId $fieldConfigId */
$fieldConfigId = $fieldConfig->getId();
if (in_array($fieldConfigId->getFieldType(), ['file', 'image'])) {
$cascade = $fieldConfig->get('cascade', false, []);
if (!in_array('persist', $cascade, true)) {
$cascade[] = 'persist';
}
$this->relationBuilder->addManyToOneRelation($entityConfig, 'Oro\\Bundle\\AttachmentBundle\\Entity\\File', $fieldConfigId->getFieldName(), 'id', ['extend' => ['cascade' => $cascade], 'importexport' => ['process_as_scalar' => true]], $fieldConfigId->getFieldType());
}
}
}
}
/**
* {@inheritdoc}
*/
public function buildForm(FormBuilderInterface $builder, array $options)
{
$configModel = $options['config_model'];
$data = array();
if ($configModel instanceof FieldConfigModel) {
$className = $configModel->getEntity()->getClassName();
$fieldName = $configModel->getFieldName();
$fieldType = $configModel->getType();
$configType = PropertyConfigContainer::TYPE_FIELD;
/**
* Add read only field name and field type
*/
$builder->add('fieldName', 'text', array('label' => 'oro.entity_config.form.name.label', 'block' => 'general', 'disabled' => true, 'data' => $fieldName));
$builder->add('type', 'choice', array('label' => 'oro.entity_config.form.type.label', 'choices' => [], 'block' => 'general', 'disabled' => true, 'empty_value' => 'oro.entity_extend.form.data_type.' . $fieldType));
} else {
$className = $configModel->getClassName();
$fieldName = null;
$fieldType = null;
$configType = PropertyConfigContainer::TYPE_ENTITY;
}
foreach ($this->configManager->getProviders() as $provider) {
if ($provider->getPropertyConfig()->hasForm($configType, $fieldType)) {
$config = $this->configManager->getConfig($provider->getId($className, $fieldName, $fieldType));
$builder->add($provider->getScope(), new ConfigScopeType($provider->getPropertyConfig()->getFormItems($configType, $fieldType), $config, $this->configManager, $configModel), array('block_config' => $this->getFormBlockConfig($provider, $configType)));
$data[$provider->getScope()] = $config->all();
}
}
$builder->setData($data);
$builder->addEventSubscriber(new ConfigSubscriber($this->doctrine, $this->configManager, $this->translator, $this->dbTranslationMetadataCache));
}
/**
* {@inheritdoc}
*/
public function preUpdate()
{
$ownershipConfigProvider = $this->configManager->getProvider('ownership');
$extendConfigProvider = $this->configManager->getProvider('extend');
$entityConfigs = $extendConfigProvider->getConfigs();
foreach ($entityConfigs as $entityConfig) {
if (!$entityConfig->is('owner', ExtendScope::OWNER_CUSTOM)) {
continue;
}
if (!$entityConfig->is('state', ExtendScope::STATE_NEW)) {
continue;
}
if (!$ownershipConfigProvider->hasConfig($entityConfig->getId()->getClassName())) {
continue;
}
$ownershipConfig = $ownershipConfigProvider->getConfig($entityConfig->getId()->getClassName());
$ownerType = $ownershipConfig->get('owner_type');
if (empty($ownerType)) {
continue;
}
$this->createOwnerRelation($entityConfig, $this->getOwnerTargetEntityClassName($ownerType), $ownershipConfig->get('owner_field_name'));
if (in_array($ownerType, [OwnershipType::OWNER_TYPE_USER, OwnershipType::OWNER_TYPE_BUSINESS_UNIT]) && $ownershipConfig->has('organization_field_name')) {
$this->createOwnerRelation($entityConfig, $this->ownershipMetadataProvider->getOrganizationClass(), $ownershipConfig->get('organization_field_name'));
}
}
}
/**
* @param ConfigureMenuEvent $event
*/
public function onNavigationConfigure(ConfigureMenuEvent $event)
{
$menu = $event->getMenu();
$children = array();
$entitiesMenuItem = $menu->getChild('system_tab')->getChild('entities_list');
if ($entitiesMenuItem) {
/** @var ConfigProvider $entityConfigProvider */
$entityConfigProvider = $this->configManager->getProvider('entity');
/** @var ConfigProvider $entityExtendProvider */
$entityExtendProvider = $this->configManager->getProvider('extend');
$extendConfigs = $entityExtendProvider->getConfigs();
foreach ($extendConfigs as $extendConfig) {
if ($this->checkAvailability($extendConfig)) {
$config = $entityConfigProvider->getConfig($extendConfig->getId()->getClassname());
if (!class_exists($config->getId()->getClassName()) || !$this->securityFacade->hasLoggedUser() || !$this->securityFacade->isGranted('VIEW', 'entity:' . $config->getId()->getClassName())) {
continue;
}
$children[$config->get('label')] = array('label' => $this->translator->trans($config->get('label')), 'options' => array('route' => 'oro_entity_index', 'routeParameters' => array('entityName' => str_replace('\\', '_', $config->getId()->getClassName())), 'extras' => array('safe_label' => true, 'routes' => array('oro_entity_*'))));
}
}
sort($children);
foreach ($children as $child) {
$entitiesMenuItem->addChild($child['label'], $child['options']);
}
}
}
/**
* 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 string $scope
* @return array
*/
protected function getObjectName($scope = 'name')
{
if (empty($this->filterChoices[$scope])) {
$alias = 'ce';
$qb = $this->configManager->getEntityManager()->createQueryBuilder();
$qb->select($alias)->from(EntityConfigModel::ENTITY_NAME, $alias)->add('select', $alias . '.className')->distinct($alias . '.className');
$result = $qb->getQuery()->getArrayResult();
$options = ['name' => [], 'module' => []];
foreach ((array) $result as $value) {
$className = explode('\\', $value['className']);
$options['name'][$value['className']] = '';
$options['module'][$value['className']] = '';
if (strpos($value['className'], 'Extend\\Entity') === false) {
foreach ($className as $index => $name) {
if (count($className) - 1 == $index) {
$options['name'][$value['className']] = $name;
} elseif (!in_array($name, array('Bundle', 'Entity'))) {
$options['module'][$value['className']] .= $name;
}
}
} else {
$options['name'][$value['className']] = str_replace('Extend\\Entity\\', '', $value['className']);
$options['module'][$value['className']] = 'System';
}
}
$this->filterChoices = $options;
}
return $this->filterChoices[$scope];
}
/**
* {@inheritdoc}
*/
public function buildForm(FormBuilderInterface $builder, array $options)
{
$builder->add('fieldName', 'text', array('label' => 'Field Name', 'block' => 'type'));
$entityProvider = $this->configManager->getProvider('entity');
$extendProvider = $this->configManager->getProvider('extend');
$entityConfig = $extendProvider->getConfig($options['class_name']);
if ($entityConfig->is('relation')) {
$types = array();
foreach ($entityConfig->get('relation') as $relationKey => $relation) {
$fieldId = $relation['field_id'];
$targetFieldId = $relation['target_field_id'];
if (!$relation['assign'] || !$targetFieldId) {
continue;
}
if ($fieldId && $extendProvider->hasConfigById($fieldId) && !$extendProvider->getConfigById($fieldId)->is('state', ExtendManager::STATE_DELETED)) {
continue;
}
$entityLabel = $entityProvider->getConfig($targetFieldId->getClassName())->get('label');
$fieldLabel = $entityProvider->getConfigById($targetFieldId)->get('label');
$key = $relationKey . '||' . ($fieldId ? $fieldId->getFieldName() : '');
$types[$key] = 'Relation (' . $entityLabel . ') ' . $fieldLabel;
}
$this->types = array_merge($this->types, $types);
}
$builder->add('type', 'choice', array('choices' => $this->types, 'empty_value' => 'Please choice type...', 'block' => 'type'));
}
/**
* {@inheritdoc}
*/
public function isApplicableField($className, $fieldName)
{
$fieldModel = $this->configManager->getConfigFieldModel($className, $fieldName);
if (!$fieldModel) {
// this serializer works with non configurable entities as well
return true;
}
if ($fieldModel->getMode() === ConfigModelManager::MODE_HIDDEN) {
// exclude hidden fields
return false;
}
$extendConfigProvider = $this->configManager->getProvider('extend');
$extendConfig = $extendConfigProvider->getConfig($className, $fieldName);
if (!$this->allowExtendedFields && $extendConfig->is('is_extend')) {
// exclude extended fields if it is requested
return false;
}
if ($extendConfig->is('is_deleted') || $extendConfig->is('state', ExtendScope::STATE_NEW)) {
// exclude deleted and not created yet fields
return false;
}
if ($extendConfig->has('target_entity') && $extendConfigProvider->getConfig($extendConfig->get('target_entity'))->is('is_deleted')) {
// exclude associations with deleted custom entities
return false;
}
return true;
}
/**
* @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');
}
/**
* Returns a value of 'immutable' attribute for the given entity/field
*
* @param string $scope
* @param string $className
* @param string|null $fieldName
*
* @return mixed The returned value depends on a scope, for example in some scopes it can be only boolean,
* but other scopes can allow to use either boolean or array. More details can be found
* in corresponding entity_config.yml
*/
public function getImmutable($scope, $className, $fieldName = null)
{
$configProvider = $this->configManager->getProvider($scope);
if ($configProvider->hasConfig($className, $fieldName)) {
return $configProvider->getConfig($className, $fieldName)->get('immutable');
}
return null;
}
/**
* 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')));
}
/**
* {@inheritdoc}
*/
public function up(Schema $schema, QueryBag $queries)
{
$this->configManager->flushAllCaches();
if ($schema instanceof ExtendSchema) {
$queries->addQuery(new RefreshExtendConfigMigrationQuery($this->commandExecutor, $this->dataStorageExtension->get('initial_entity_config_state', []), $this->initialEntityConfigStatePath));
$queries->addQuery(new RefreshExtendCacheMigrationQuery($this->commandExecutor));
}
}
/**
* @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);
}
/**
* {@inheritdoc}
*/
public function buildForm(FormBuilderInterface $builder, array $options)
{
$this->config = $this->configManager->getProvider('extend')->getConfigById($options['config_id']);
$this->formFactory = $builder->getFormFactory();
$builder->add('target_entity', new TargetType($this->configManager, $options['config_id']), ['constraints' => [new Assert\NotBlank()]]);
$builder->addEventListener(FormEvents::PRE_SET_DATA, [$this, 'preSubmitData']);
$builder->addEventListener(FormEvents::PRE_SUBMIT, [$this, 'preSubmitData']);
}
/**
* 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));
}
