/**
* @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;
}
/**
* {@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);
}
}
}
}
/**
* 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.');
}]);
}
/**
* @param string $className The entity class name
* @param string $fieldName The entity field name
* @param string $attrName The entity config attribute name
* @param string $scope The entity config scope name
* @return array
*/
public function getFieldConfigValue($className, $fieldName, $attrName, $scope = 'entity')
{
if (!$this->configManager->hasConfig($className, $fieldName)) {
return null;
}
return $this->configManager->getProvider($scope)->getConfig($className, $fieldName)->get($attrName);
}
/**
* Returns the context for the given activity class and id
*
* @param string $class The FQCN of the activity entity
* @param $id
*
* @return array
*/
public function getActivityContext($class, $id)
{
$currentUser = $this->securityTokenStorage->getToken()->getUser();
$userClass = ClassUtils::getClass($currentUser);
$entity = $this->doctrineHelper->getEntity($class, $id);
$result = [];
if (!$entity || !$entity instanceof ActivityInterface) {
return $result;
}
$targets = $entity->getActivityTargetEntities();
$entityProvider = $this->configManager->getProvider('entity');
foreach ($targets as $target) {
$targetClass = ClassUtils::getClass($target);
$targetId = $target->getId();
if ($userClass === $targetClass && $currentUser->getId() === $targetId) {
continue;
}
$item = [];
$config = $entityProvider->getConfig($targetClass);
$safeClassName = $this->entityClassNameHelper->getUrlSafeClassName($targetClass);
$item = $this->prepareItemTitle($item, $targetClass, $target, $targetId);
$item['activityClassAlias'] = $this->entityAliasResolver->getPluralAlias($class);
$item['entityId'] = $id;
$item['targetId'] = $targetId;
$item['targetClassName'] = $safeClassName;
$item['icon'] = $config->get('icon');
$item['link'] = $this->getContextLink($targetClass, $targetId);
$item = $this->dispatchContextTitle($item, $targetClass);
$result[] = $item;
}
return $result;
}
/**
* {@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);
}
/**
* 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);
}
}
}
/**
* {@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 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']);
}
}
}
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;
}
/**
* {@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 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());
}
}
}
}
/**
* @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 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'));
}
}
}
/**
* 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;
}
/**
* @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');
}
/**
* {@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']);
}
/**
* @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 ConfigManager $configManager
* @param FieldTypeHelper $fieldTypeHelper
* @param EventDispatcherInterface $dispatcher
*/
public function __construct(ConfigManager $configManager, FieldTypeHelper $fieldTypeHelper, EventDispatcherInterface $dispatcher)
{
$this->fieldTypeHelper = $fieldTypeHelper;
$this->eventDispatcher = $dispatcher;
$this->extendProvider = $configManager->getProvider('extend');
$this->entityProvider = $configManager->getProvider('entity');
$this->viewProvider = $configManager->getProvider('view');
$this->propertyAccessor = PropertyAccess::createPropertyAccessor();
}
/**
* Returns class names according to share scopes using entity config. The goal is to determine on which
* database tables search should be performed.
*
* @param string $entityClass
*
* @return array
*/
public function getClassNamesBySharingScopeConfig($entityClass)
{
$classNames = [];
$shareScopes = $this->configManager->getProvider('security')->getConfig($entityClass)->get('share_scopes');
if (!$shareScopes) {
return $classNames;
}
return $this->getClassNamesBySharingScopes($shareScopes);
}
/**
* {@inheritdoc}
*/
public function setDefaultOptions(OptionsResolverInterface $resolver)
{
$resolver->setDefaults(['enum_code' => null, 'class' => null, 'query_builder' => function (EntityRepository $repo) {
return $repo->createQueryBuilder('o')->orderBy('o.priority');
}, 'property' => 'name', 'multiple' => null]);
$resolver->setNormalizers(['class' => function (Options $options, $value) {
return !empty($value) ? $value : ExtendHelper::buildEnumValueClassName($options['enum_code']);
}, 'multiple' => function (Options $options, $value) {
return $value !== null ? $value : $this->configManager->getProvider('enum')->getConfig($options['class'])->is('multiple');
}]);
}
/**
* {@inheritdoc}
*/
public function getSupportedEntityClasses()
{
$result = [];
$extendConfigProvider = $this->configManager->getProvider('extend');
foreach ($extendConfigProvider->getConfigs(null, true) as $extendConfig) {
if (ExtendHelper::isEnumValueEntityAccessible($extendConfig)) {
$result[] = $extendConfig->getId()->getClassName();
}
}
return $result;
}
/**
* @param ConfigManager $configManager
* @param FieldTypeHelper $fieldTypeHelper
* @param DateTimeFormatter $dateTimeFormatter
* @param UrlGeneratorInterface $router
*/
public function __construct(ConfigManager $configManager, FieldTypeHelper $fieldTypeHelper, DateTimeFormatter $dateTimeFormatter, UrlGeneratorInterface $router)
{
$this->configManager = $configManager;
$this->fieldTypeHelper = $fieldTypeHelper;
$this->dateTimeFormatter = $dateTimeFormatter;
$this->router = $router;
$this->extendProvider = $configManager->getProvider('extend');
$this->entityProvider = $configManager->getProvider('entity');
$this->viewProvider = $configManager->getProvider('view');
$this->propertyAccessor = PropertyAccess::createPropertyAccessor();
}
/**
* @return array
*/
protected function getChannelEntities()
{
$customEntities = $this->configManager->getProvider('extend')->map(function (ConfigInterface $extendConfig) {
$isCustom = $extendConfig->is('is_extend') && $extendConfig->get('owner') === ExtendScope::OWNER_CUSTOM && $extendConfig->in('state', [ExtendScope::STATE_ACTIVE, ExtendScope::STATE_UPDATED]);
return $isCustom ? $extendConfig->getId()->getClassName() : false;
});
$customEntities = array_filter($customEntities);
$entities = array_map(function ($setting) {
return $setting['name'];
}, $this->settings->getSettings(SettingsProvider::DATA_PATH));
return array_unique(array_merge($customEntities, $entities));
}
/**
* @param string $sourceEntityClass
* @param string $targetEntityClass
* @param string $associationKind
*/
public function createManyToOneAssociation($sourceEntityClass, $targetEntityClass, $associationKind)
{
$relationName = ExtendHelper::buildAssociationName($targetEntityClass, $associationKind);
$entityConfigProvider = $this->configManager->getProvider('entity');
$targetEntityConfig = $entityConfigProvider->getConfig($targetEntityClass);
$label = $targetEntityConfig->get('label', false, ConfigHelper::getTranslationKey('entity', 'label', $targetEntityClass, $relationName));
$description = ConfigHelper::getTranslationKey('entity', 'description', $targetEntityClass, $relationName);
$targetEntityPrimaryKeyColumns = $this->getPrimaryKeyColumnNames($targetEntityClass);
$targetFieldName = array_shift($targetEntityPrimaryKeyColumns);
// add relation to owning entity
$this->relationBuilder->addManyToOneRelation($this->configManager->getProvider('extend')->getConfig($sourceEntityClass), $targetEntityClass, $relationName, $targetFieldName, ['entity' => ['label' => $label, 'description' => $description], 'view' => ['is_displayable' => false], 'form' => ['is_enabled' => false]]);
}
/**
* {@inheritdoc}
*/
public function buildForm(FormBuilderInterface $builder, array $options)
{
$builder->addEventListener(FormEvents::POST_SUBMIT, function () use($options) {
/** @var FieldConfigId $fieldConfigId */
$fieldConfigId = $options['config_id'];
$entityConfig = $this->configManager->getProvider('extend')->getConfig($fieldConfigId->getClassName());
if ($entityConfig->is('state', ExtendScope::STATE_ACTIVE) && !$this->hasRelation($entityConfig, $this->getRelationKey($fieldConfigId))) {
$entityConfig->set('state', ExtendScope::STATE_UPDATE);
$this->configManager->persist($entityConfig);
$this->configManager->flush();
}
});
}
/**
* Gets the list of configs for entities which can be the target of the association
*
* @return array
*/
protected function getTargetEntities()
{
if (null === $this->targetEntities) {
$targetEntityClasses = $this->identifyProvider->getTargetIdentityEntities();
$configs = $this->configManager->getProvider('extend')->getConfigs();
foreach ($configs as $config) {
if ($config->is('upgradeable') && in_array($config->getId()->getClassName(), $targetEntityClasses)) {
$this->targetEntities[] = $config->getId()->getClassName();
}
}
}
return $this->targetEntities;
}
/**
* Checks if the form type should be read-only or not
*
* @param $options
*
* @return bool
*/
protected function isReadOnly($options)
{
/** @var EntityConfigId $configId */
$configId = $options['config_id'];
$className = $configId->getClassName();
if (!empty($className)) {
$shareScopes = $this->configManager->getProvider('security')->getConfig($className)->get('share_scopes');
// do not set as read-only if value is empty array - checkboxes were unchecked, but entity supports sharing
// set as read-only if value equivalent to null - entity doesn't support sharing
if ($shareScopes !== null) {
return false;
}
}
return true;
}
