/** * @param string $id * @param string $entityName * @param string $fieldName * * @return array * * @Route( * "/detailed/{id}/{entityName}/{fieldName}", * name="oro_entity_detailed", * defaults={"id"=0, "fieldName"=""} * ) * @Template */ public function detailedAction($id, $entityName, $fieldName) { $entityClass = $this->get('oro_entity.routing_helper')->resolveEntityClass($entityName); if (!class_exists($entityClass)) { throw $this->createNotFoundException(); } $this->checkAccess('VIEW', $entityClass); $entityProvider = $this->get('oro_entity_config.provider.entity'); $extendProvider = $this->get('oro_entity_config.provider.extend'); $relationConfig = $extendProvider->getConfig($entityClass, $fieldName); $relationTargetEntity = $relationConfig->get('target_entity'); if (!class_exists($relationTargetEntity)) { throw $this->createNotFoundException(); } /** @var ConfigInterface[] $fields */ $fields = $extendProvider->filter(function (ConfigInterface $config) use($relationConfig) { /** @var FieldConfigId $fieldConfigId */ $fieldConfigId = $config->getId(); return ExtendHelper::isFieldAccessible($config) && in_array($fieldConfigId->getFieldName(), (array) $relationConfig->get('target_detailed'), true); }, $relationConfig->get('target_entity')); $entity = $this->getDoctrine()->getRepository($relationTargetEntity)->find($id); if (!$entity) { return $this->createNotFoundException(); } $dynamicRow = array(); foreach ($fields as $field) { /** @var FieldConfigId $fieldConfigId */ $fieldConfigId = $field->getId(); $fieldName = $fieldConfigId->getFieldName(); $label = $entityProvider->getConfigById($fieldConfigId)->get('label') ?: $fieldName; $dynamicRow[$label] = FieldAccessor::getValue($entity, $fieldName); } return array('dynamic' => $dynamicRow, 'entity' => $entity); }
/** * {@inheritdoc} */ protected function getFields(DatagridConfiguration $config) { $entityClassName = $this->entityClassResolver->getEntityClass($this->getEntityName($config)); if (!$this->configManager->hasConfig($entityClassName)) { return []; } $entityConfigProvider = $this->configManager->getProvider('entity'); $extendConfigProvider = $this->configManager->getProvider('extend'); $viewConfigProvider = $this->configManager->getProvider('view'); $datagridConfigProvider = $this->configManager->getProvider('datagrid'); $fields = []; $fieldIds = $entityConfigProvider->getIds($entityClassName); /** @var FieldConfigId $fieldId */ foreach ($fieldIds as $fieldId) { $extendConfig = $extendConfigProvider->getConfigById($fieldId); if ($extendConfig->is('owner', ExtendScope::OWNER_CUSTOM) && ExtendHelper::isFieldAccessible($extendConfig) && $datagridConfigProvider->getConfigById($fieldId)->is('is_visible')) { $viewConfig = $viewConfigProvider->getConfig($entityClassName, $fieldId->getFieldName()); $fields[] = ['id' => $fieldId, 'priority' => $viewConfig->get('priority', false, 0)]; } } ArrayUtil::sortBy($fields, true); return array_map(function ($field) { return $field['id']; }, $fields); }
/** * 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)); }
/** * 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)); }
/** * {@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} */ protected function getFields(DatagridConfiguration $config) { $entityClassName = $this->entityClassResolver->getEntityClass($this->getEntityName($config)); if (!$this->configManager->hasConfig($entityClassName)) { return []; } $fieldNames = $config->offsetGetByPath(self::ADDITIONAL_FIELDS_CONFIG_PATH, []); $fields = []; $extendConfigProvider = $this->configManager->getProvider('extend'); foreach ($fieldNames as $fieldName) { if (!$extendConfigProvider->hasConfig($entityClassName, $fieldName)) { continue; } $extendConfig = $extendConfigProvider->getConfig($entityClassName, $fieldName); if (ExtendHelper::isFieldAccessible($extendConfig)) { $fields[] = $extendConfig->getId(); } } return $fields; }
/** * {@inheritdoc} */ public function isIgnoredRelation(ClassMetadata $metadata, $associationName) { if (!$this->configManager->hasConfig($metadata->name, $associationName)) { return false; } $extendFieldConfig = $this->configManager->getFieldConfig('extend', $metadata->name, $associationName); if (!ExtendHelper::isFieldAccessible($extendFieldConfig)) { return true; } if ($this->excludeHiddenFields && $this->configManager->isHiddenModel($metadata->name, $associationName)) { return true; } if ($extendFieldConfig->has('target_entity')) { $targetEntity = $extendFieldConfig->get('target_entity'); if (!ExtendHelper::isEntityAccessible($this->configManager->getEntityConfig('extend', $targetEntity))) { return true; } if ($this->excludeHiddenEntities && $this->configManager->isHiddenModel($targetEntity)) { return true; } } return false; }
/** * {@inheritdoc} */ public function isApplicableField($className, $fieldName) { if (null === $this->configManager->getConfigModelId($className, $fieldName)) { // this serializer works with non configurable entities as well return true; } if (true === $this->configManager->isHiddenModel($className, $fieldName)) { // 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 (!ExtendHelper::isFieldAccessible($extendConfig)) { return false; } if ($extendConfig->has('target_entity') && !ExtendHelper::isEntityAccessible($extendConfigProvider->getConfig($extendConfig->get('target_entity')))) { return false; } return true; }
/** * @return string[] */ public function getFields() { if (empty($this->fields)) { $this->fields = []; $fieldConfigs = $this->configManager->getConfigs('extend', self::CALENDAR_PROPERTY_CLASS); foreach ($fieldConfigs as $fieldConfig) { if (!ExtendHelper::isFieldAccessible($fieldConfig)) { continue; } /** @var FieldConfigId $fieldId */ $fieldId = $fieldConfig->getId(); $fieldType = $fieldId->getFieldType(); $underlyingFieldType = $this->fieldTypeHelper->getUnderlyingType($fieldType); if (in_array($underlyingFieldType, RelationType::$toManyRelations, true)) { // ignore to-many relations continue; } $this->fields[$fieldId->getFieldName()] = $fieldType; } } return $this->fields; }
/** * @param ConfigInterface $extendConfig * @param ConfigProvider $extendConfigProvider * * @return bool */ protected function isApplicableField(ConfigInterface $extendConfig, ConfigProvider $extendConfigProvider) { return $extendConfig->is('owner', ExtendScope::OWNER_CUSTOM) && ExtendHelper::isFieldAccessible($extendConfig) && !in_array($extendConfig->getId()->getFieldType(), RelationType::$toAnyRelations, true) && (!$extendConfig->has('target_entity') || ExtendHelper::isEntityAccessible($extendConfigProvider->getConfig($extendConfig->get('target_entity')))); }
/** * @param string $class * * @return array */ protected function getExtendFieldNames($class) { $configProvider = $this->get('oro_entity_config.provider.extend'); $configs = $configProvider->filter(function (ConfigInterface $extendConfig) { return $extendConfig->is('owner', ExtendScope::OWNER_CUSTOM) && ExtendHelper::isFieldAccessible($extendConfig) && !$extendConfig->has('target_entity') && !$extendConfig->is('is_serialized'); }, $class); return array_map(function (ConfigInterface $config) { return $config->getId()->getFieldName(); }, $configs); }
/** * @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; }
/** * @param string $activityClassName * @param string $activityAssociationName * * @return bool */ protected function isActivityAssociationEnabled($activityClassName, $activityAssociationName) { if (!$this->extendConfigProvider->hasConfig($activityClassName, $activityAssociationName)) { return false; } return ExtendHelper::isFieldAccessible($this->extendConfigProvider->getConfig($activityClassName, $activityAssociationName)); }
/** * Check if the given field is ready to be used in a business logic. * * @param string $className * @param string $fieldName * * @return bool */ protected function isFieldAccessible($className, $fieldName) { return $this->extendConfigProvider->hasConfig($className, $fieldName) && ExtendHelper::isFieldAccessible($this->extendConfigProvider->getConfig($className, $fieldName)); }
/** * @param ClassMetadata $classMetadata * * @return ConfigInterface[] */ protected function getUnmappedDynamicFieldsConfigs(ClassMetadata $classMetadata) { return array_filter($this->entityExtendProvider->getConfigs($classMetadata->name), function (ConfigInterface $config) use($classMetadata) { return !$classMetadata->hasField($config->getId()->getFieldName()) && !$classMetadata->hasAssociation($config->getId()->getFieldName()) && !$config->is('is_deleted') && $config->is('owner', ExtendScope::OWNER_CUSTOM) && ExtendHelper::isFieldAccessible($config) && !in_array($config->getId()->getFieldType(), RelationType::$toAnyRelations, true) && (!$config->has('target_entity') || ExtendHelper::isEntityAccessible($this->entityExtendProvider->getConfig($config->get('target_entity')))); }); }