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'));
}
/**
* {@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]]);
}
}
public function testConfig()
{
$this->assertEquals($this->configManager, $this->configProvider->getConfigManager());
$this->assertEquals(true, $this->configProvider->hasConfig(DemoEntity::ENTITY_NAME));
$this->assertEquals($this->entityConfig, $this->configProvider->getConfig(DemoEntity::ENTITY_NAME));
$this->assertEquals('testScope', $this->configProvider->getScope());
$entityConfigId = new EntityConfigId('testScope', DemoEntity::ENTITY_NAME);
$fieldConfigId = new FieldConfigId('testScope', DemoEntity::ENTITY_NAME, 'testField', 'string');
$this->assertEquals($entityConfigId, $this->configProvider->getId(DemoEntity::ENTITY_NAME));
$this->assertEquals($fieldConfigId, $this->configProvider->getId(DemoEntity::ENTITY_NAME, 'testField', 'string'));
$entityConfigIdWithOtherScope = new EntityConfigId('otherScope', DemoEntity::ENTITY_NAME);
$this->assertEquals($this->entityConfig, $this->configProvider->getConfigById($entityConfigIdWithOtherScope));
}
/**
* @param Collection $collection
* @param ConfigIdInterface $fieldConfig
*
* @return array
*/
protected function getValueForCollection(Collection $collection, ConfigIdInterface $fieldConfig)
{
$extendConfig = $this->extendProvider->getConfigById($fieldConfig);
$titleFieldName = $extendConfig->get('target_title');
$value = $this->getEntityRouteOptions($extendConfig->get('target_entity'));
$values = [];
$priorities = [];
/** @var object $item */
foreach ($collection as $item) {
$value['route_params']['id'] = $item->getId();
$title = [];
foreach ($titleFieldName as $fieldName) {
$title[] = $this->propertyAccessor->getValue($item, $fieldName);
}
$values[] = ['id' => $item->getId(), 'link' => $value['route'] ? $this->router->generate($value['route'], $value['route_params']) : false, 'title' => implode(' ', $title)];
if ($item instanceof PriorityItem) {
$priorities[] = $item->getPriority();
}
}
// sort values by priority if needed
if (!empty($priorities) && count($priorities) === count($values)) {
array_multisort($priorities, $values);
}
$value['values'] = $values;
return $value;
}
/**
* @param FormEvent $event
*/
public function preSetData(FormEvent $event)
{
$form = $event->getForm();
$entityClass = $form->getConfig()->getDataClass();
/** @var FieldConfigId[] $fieldConfigIds */
$fieldConfigIds = $this->extendConfigProvider->getIds($entityClass);
foreach ($fieldConfigIds as $fieldConfigId) {
if ($fieldConfigId->getFieldType() === 'manyToOne') {
$fieldEntityConfig = $this->entityConfigProvider->getConfigById($fieldConfigId);
$fieldExtendConfig = $this->extendConfigProvider->getConfigById($fieldConfigId);
if (!$fieldExtendConfig->is('state', ExtendScope::STATE_ACTIVE)) {
continue;
}
$form->add($fieldConfigId->getFieldName(), 'entity', ['required' => false, 'class' => $fieldExtendConfig->get('target_entity'), 'property' => $fieldExtendConfig->get('target_field'), 'label' => $fieldEntityConfig->get('label')]);
}
}
}
/**
* Check if entity config is new (entity not generated yet) or was deleted
*
* @param EntityConfigId $entityConfigId
*
* @return bool
*/
protected function isIgnoredEntity(EntityConfigId $entityConfigId)
{
$entityConfig = $this->extendConfigProvider->getConfigById($entityConfigId);
if ($entityConfig->is('is_deleted') || $entityConfig->in('state', [ExtendScope::STATE_NEW, ExtendScope::STATE_DELETE])) {
return true;
}
return false;
}
/**
* @param ClassMetadataBuilder $metadataBuilder
* @param FieldConfigId $fieldId
* @param string $targetEntity
* @param FieldConfigId|null $targetFieldId
* @param string[] $cascade
*/
protected function buildManyToManyOwningSideRelation(ClassMetadataBuilder $metadataBuilder, FieldConfigId $fieldId, $targetEntity, FieldConfigId $targetFieldId = null, array $cascade = [])
{
$builder = $metadataBuilder->createManyToMany($fieldId->getFieldName(), $targetEntity);
if ($targetFieldId) {
$builder->inversedBy($targetFieldId->getFieldName());
}
$builder->setJoinTable($this->nameGenerator->generateManyToManyJoinTableName($fieldId->getClassName(), $fieldId->getFieldName(), $targetEntity));
foreach ($cascade as $cascadeType) {
$builder->{'cascade' . ucfirst($cascadeType)}();
}
$builder->build();
$extendFieldConfig = $this->extendConfigProvider->getConfigById($fieldId);
if (!$extendFieldConfig->is('without_default')) {
$this->buildDefaultRelation($metadataBuilder, $fieldId, $targetEntity);
}
}
/**
* Adds entities to $result
*
* @param array $result
* @param bool $applyExclusions
* @param bool $translate
*/
protected function addEntities(array &$result, $applyExclusions, $translate)
{
// only configurable entities are supported
$entityConfigs = $this->entityConfigProvider->getConfigs();
foreach ($entityConfigs as $entityConfig) {
$entityConfigId = $entityConfig->getId();
$isStateCorrect = $this->extendConfigProvider->getConfigById($entityConfigId)->in('state', [ExtendScope::STATE_ACTIVE, ExtendScope::STATE_UPDATE]);
if (false == $isStateCorrect) {
continue;
}
$className = $entityConfigId->getClassName();
if ($applyExclusions && $this->isIgnoredEntity($className)) {
continue;
}
$this->addEntity($result, $className, $entityConfig->get('label'), $entityConfig->get('plural_label'), $entityConfig->get('icon'), $translate);
}
}
/**
* Return view link options or simple text
*
* @param object $targetEntity
* @param ConfigIdInterface $fieldConfigId
*
* @throws \Doctrine\ORM\Mapping\MappingException
* @return array|string
*/
protected function getValueForSingleRelation($targetEntity, ConfigIdInterface $fieldConfigId)
{
$fieldConfig = $this->extendProvider->getConfigById($fieldConfigId);
$targetFieldName = $fieldConfig->get('target_field');
$targetClassName = $fieldConfig->get('target_entity');
if (!class_exists($targetClassName)) {
return '';
}
$title = (string) $this->propertyAccessor->getValue($targetEntity, $targetFieldName);
/** @var ClassMetadataInfo $targetMetadata */
$targetMetadata = $this->registry->getManager()->getClassMetadata($targetClassName);
$id = $this->propertyAccessor->getValue($targetEntity, $targetMetadata->getSingleIdentifierFieldName());
$routeOptions = $this->getEntityRouteOptions($targetClassName, $id);
if ($routeOptions['route'] && $this->securityFacade->isGranted('VIEW', $targetEntity)) {
return ['link' => $this->router->generate($routeOptions['route'], $routeOptions['route_params']), 'title' => $title];
}
return $title;
}
/**
* @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;
}
/**
* @param ConfigInterface $config
* @return bool
*/
public function filterFields(ConfigInterface $config)
{
$extendConfig = $this->extendProvider->getConfigById($config->getId());
/** @var FieldConfigId $fieldConfigId */
$fieldConfigId = $extendConfig->getId();
// skip system and not accessible fields
if (!$config->is('owner', ExtendScope::OWNER_CUSTOM) || !ExtendHelper::isFieldAccessible($config)) {
return false;
}
// skip invisible fields
if (!$this->viewProvider->getConfigById($config->getId())->is('is_displayable')) {
return false;
}
// skip relations if they are referenced to not accessible entity
$underlyingFieldType = $this->fieldTypeHelper->getUnderlyingType($fieldConfigId->getFieldType());
if (in_array($underlyingFieldType, RelationType::$anyToAnyRelations, true) && !ExtendHelper::isEntityAccessible($this->extendProvider->getConfig($extendConfig->get('target_entity')))) {
return false;
}
return true;
}
/**
* Check if reverse relation can be created
*
* @param ConfigProvider $extendProvider
* @param array $relation
* @param string $relationKey
*
* @return bool
*
* @SuppressWarnings(PHPMD.CyclomaticComplexity)
*/
protected function isAvailableRelation(ConfigProvider $extendProvider, array $relation, $relationKey)
{
/** @var FieldConfigId|false $fieldId */
$fieldId = $relation['field_id'];
/** @var FieldConfigId $targetFieldId */
$targetFieldId = $relation['target_field_id'];
if (!$relation['assign'] || !$targetFieldId) {
if (!$targetFieldId) {
return false;
}
// additional check for revers relation of manyToOne field type
$targetEntityConfig = $extendProvider->getConfig($targetFieldId->getClassName());
if (false === (!$relation['assign'] && !$fieldId && $targetFieldId && $targetFieldId->getFieldType() == RelationTypeBase::MANY_TO_ONE && $targetEntityConfig->get('relation') && $targetEntityConfig->get('relation')[$relationKey]['assign'])) {
return false;
}
}
if ($fieldId && $extendProvider->hasConfigById($fieldId) && $extendProvider->getConfigById($fieldId)->is('state', ExtendScope::STATE_DELETE)) {
return false;
}
if ($targetFieldId && !$extendProvider->hasConfig($targetFieldId->getClassName(), $targetFieldId->getFieldName())) {
return false;
}
return true;
}
public function __construct(ConfigProvider $configProvider, $configId)
{
$this->configProvider = $configProvider;
$this->configId = $configId;
$this->targetEntity = $this->configProvider->getConfigById($this->configId)->get('target_entity');
}
