/** * {@inheritdoc} */ public function process(ContextInterface $context) { /** @var ConfigContext $context */ /** @var array $definition */ $definition = $context->getResult(); if (empty($definition) || !array_key_exists(ConfigUtil::FIELDS, $definition)) { // virtual fields is added only if a definition of fields exists return; } $entityClass = $context->getClassName(); $virtualFields = $this->virtualFieldProvider->getVirtualFields($entityClass); if (!empty($virtualFields)) { foreach ($virtualFields as $field) { $query = $this->virtualFieldProvider->getVirtualFieldQuery($entityClass, $field); $propertyPath = $this->getPropertyPath($query); if (!empty($propertyPath)) { $definition[ConfigUtil::FIELDS][$field][ConfigUtil::PROPERTY_PATH] = $propertyPath; if (!empty($query['select']['label']) && $context->hasExtra(DescriptionsConfigExtra::NAME)) { $definition[ConfigUtil::FIELDS][$field][ConfigUtil::LABEL] = new Label($query['select']['label']); } } } $context->setResult($definition); } }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { /** @var GetListContext $context */ if ($context->hasQuery()) { // a query is already built return; } $entityClass = $context->getClassName(); if (!$this->doctrineHelper->isManageableEntityClass($entityClass)) { // only manageable entities are supported return; } $filters = $context->getFilters(); if (!$filters->has(self::SORT_FILTER_KEY)) { $filters->add(self::SORT_FILTER_KEY, new SortFilter(DataType::ORDER_BY, 'Result sorting. One or several fields separated by comma, for example \'field1,-field2\'.', function () use($entityClass) { return $this->doctrineHelper->getOrderByIdentifier($entityClass); }, function ($value) { $result = []; if (null !== $value) { foreach ($value as $field => $order) { $result[] = (Criteria::DESC === $order ? '-' : '') . $field; } } return implode(RestRequest::ARRAY_DELIMITER, $result); })); } }
/** * {@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); }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { /** @var ConfigContext $context */ $definition = $context->getResult(); if (empty($definition) || empty($definition[ConfigUtil::FIELDS]) || !is_array($definition[ConfigUtil::FIELDS])) { // a configuration of fields does not exist or a description is not needed return; } $entityClass = $context->getClassName(); if (!$this->entityConfigProvider->hasConfig($entityClass)) { // only configurable entities are supported return; } $fields = array_keys($definition[ConfigUtil::FIELDS]); foreach ($fields as $fieldName) { $fieldConfig = $definition[ConfigUtil::FIELDS][$fieldName]; $config = $this->findFieldConfig($entityClass, $fieldName, $fieldConfig); if (null !== $config) { if (null === $fieldConfig) { $fieldConfig = []; } if (!isset($fieldConfig[ConfigUtil::LABEL])) { $fieldConfig[ConfigUtil::LABEL] = new Label($config->get('label')); } $definition[ConfigUtil::FIELDS][$fieldName] = $fieldConfig; } } $context->setResult($definition); }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { /** @var ConfigContext $context */ /** @var array|null $definition */ $definition = $context->getResult(); if (empty($definition) || ConfigUtil::isExcludeAll($definition)) { // nothing to do return $definition; } $entityClass = $context->getClassName(); if (!$this->doctrineHelper->isManageableEntityClass($entityClass)) { return $definition; } $expandRelations = $context->get(ExpandRelatedEntitiesConfigExtra::NAME); $associations = $this->doctrineHelper->getEntityMetadataForClass($entityClass)->getAssociationMappings(); foreach ($associations as $fieldName => $mapping) { if (!$this->isAssociationCompletionRequired($fieldName, $definition)) { continue; } if (!in_array($fieldName, $expandRelations)) { continue; } $extras = array_filter($context->getExtras(), function ($item) { if ($item instanceof ExpandRelatedEntitiesConfigExtra || $item instanceof FilterFieldsConfigExtra) { return false; } return true; }); $config = $this->configProvider->getConfig($mapping['targetEntity'], $context->getVersion(), $context->getRequestType(), $extras); $definition[ConfigUtil::FIELDS][$fieldName] = $config; } $context->setResult([ConfigUtil::EXCLUSION_POLICY => ConfigUtil::EXCLUSION_POLICY_NONE, ConfigUtil::FIELDS => $definition[ConfigUtil::FIELDS]]); }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { /** @var Context $context */ $entityClass = $context->getClassName(); if (!$this->doctrineHelper->isManageableEntityClass($entityClass)) { // only manageable entities are supported return; } $filters = $context->getFilters(); if ($filters->has(self::FILTER_KEY)) { // filters have been already set return; } $fieldFilter = new FieldsFilter(DataType::STRING, self::FILTER_KEY_DESCRIPTION); $fieldFilter->setArrayAllowed(true); $filters->add(sprintf(self::FILTER_KEY_TEMPLATE, $this->entityClassTransformer->transform($entityClass)), $fieldFilter); $associations = $this->doctrineHelper->getEntityMetadata($entityClass)->getAssociationMappings(); if (!$associations) { // no associations - no sense to add associations fields filters return; } $associationKeys = array_keys($associations); foreach ($associationKeys as $association) { $filters->add(sprintf(self::FILTER_KEY_TEMPLATE, $association), $fieldFilter); } }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { /** @var MetadataContext $context */ if ($context->hasResult()) { // metadata is already loaded return; } $entityClass = $context->getClassName(); if (!$this->doctrineHelper->isManageableEntityClass($entityClass)) { // only manageable entities are supported return; } // filter excluded fields on this stage though there is another processor doing the same // it is done due to performance reasons $allowedFields = $this->getAllowedFields($context->getConfig()); $classMetadata = $this->doctrineHelper->getEntityMetadataForClass($entityClass); $entityMetadata = $this->entityMetadataFactory->createEntityMetadata($classMetadata); $fields = $classMetadata->getFieldNames(); foreach ($fields as $fieldName) { if (!isset($allowedFields[$fieldName])) { continue; } $entityMetadata->addField($this->entityMetadataFactory->createFieldMetadata($classMetadata, $fieldName)); } $associations = $classMetadata->getAssociationNames(); foreach ($associations as $associationName) { if (!isset($allowedFields[$associationName])) { continue; } $entityMetadata->addAssociation($this->entityMetadataFactory->createAssociationMetadata($classMetadata, $associationName)); } $context->setResult($entityMetadata); }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { /** @var Context $context */ $entityClass = $context->getClassName(); if (empty($entityClass)) { throw new \RuntimeException('The name of an entity class must be set in the context.'); } }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { /** @var Context $context */ if ($context->hasQuery()) { // a query is already built return; } $this->aclHelper->applyAclToCriteria($context->getClassName(), $context->getCriteria(), $this->permission); }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { /** @var SingleItemContext $context */ $entityId = $context->getId(); if (!is_string($entityId)) { // an entity identifier is already normalized return; } $context->setId($this->entityIdTransformer->reverseTransform($context->getClassName(), $entityId)); }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { /** @var Context $context */ $entityClass = $context->getClassName(); if (false !== strpos($entityClass, '\\')) { // an entity class is already normalized return; } $context->setClassName($this->valueNormalizer->normalizeValue($entityClass, DataType::ENTITY_PLURAL_ALIAS, $context->getRequestType())); }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { /** @var Context $context */ $entityClass = $context->getClassName(); if (!$this->doctrineHelper->isManageableEntityClass($entityClass)) { // only manageable entities are supported return; } $criteria = $context->getCriteria(); $this->setJoinAliases($criteria); $this->completeJoins($criteria); }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { /** @var ConfigContext $context */ if ($context->hasResult()) { // config is already set return; } $config = $this->loadConfig($context->getClassName(), $context->getVersion()); if (null !== $config) { $context->setResult($config); } }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { /** @var MetadataContext $context */ if ($context->hasResult()) { // config is already set return; } $config = $this->configBag->getMetadata($context->getClassName(), $context->getVersion()); if (!empty($config)) { $context->setResult($config); } }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { /** @var Context $context */ $entityClass = $context->getClassName(); if (!$this->doctrineHelper->isManageableEntityClass($entityClass)) { // only manageable entities are supported return; } if (!$this->securityContext->isGranted($this->permission, new ObjectIdentity('entity', $entityClass))) { throw new AccessDeniedException(); } }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { /** @var RelationConfigContext $context */ $config = $context->getResult(); if (null !== $config) { // a config already exists return; } $config = $this->loadConfig($context->getClassName(), $context->getVersion()); if (null !== $config) { $this->addConfigToContext($context, $config); } }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { /** @var GetListContext $context */ if ($context->hasQuery()) { // a query is already built return; } $entityClass = $context->getClassName(); if (!$this->doctrineHelper->isManageableEntityClass($entityClass)) { // only manageable entities are supported return; } $this->addSortFilter($context->getFilters(), $entityClass); }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { /** @var ConfigContext $context */ $filters = $context->getFilters(); if (null === $filters) { // a filters' configuration does not exist return; } $entityClass = $context->getClassName(); if (!$this->doctrineHelper->isManageableEntityClass($entityClass)) { // only manageable entities are supported return; } $context->setFilters($this->removeDuplicates($filters, $entityClass)); }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { /** @var GetListContext $context */ if ($context->hasQuery()) { // a query is already built return; } $entityClass = $context->getClassName(); if (!$this->doctrineHelper->isManageableEntityClass($entityClass)) { // only manageable entities are supported return; } $query = $this->doctrineHelper->getEntityRepositoryForClass($entityClass)->createQueryBuilder('e'); $this->doctrineHelper->applyCriteria($query, $context->getCriteria()); $context->setQuery($query); }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { /** @var ConfigContext $context */ $definition = $context->getResult(); if (!isset($definition[ConfigUtil::FIELDS]) || !is_array($definition[ConfigUtil::FIELDS]) || !ConfigUtil::isExcludeAll($definition)) { // expected normalized configs return; } $entityClass = $context->getClassName(); if (!$this->doctrineHelper->isManageableEntityClass($entityClass)) { // only manageable entities are supported return; } if ($this->updateRelations($definition, $entityClass)) { $context->setResult($definition); } }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { /** @var ConfigContext $context */ $definition = $context->getResult(); if (null === $definition || !isset($definition[ConfigUtil::FIELDS]) || !is_array($definition[ConfigUtil::FIELDS])) { // a configuration of fields does not exist or a fix is not needed return; } $entityClass = $context->getClassName(); $reservedFieldNames = array_intersect(array_keys($definition[ConfigUtil::FIELDS]), ['id', 'type']); foreach ($reservedFieldNames as $fieldName) { if ('type' === $fieldName || 'id' === $fieldName && !$this->isIdentifierField($entityClass, $fieldName)) { $this->renameReservedField($definition[ConfigUtil::FIELDS], $entityClass, $fieldName); } } $context->setResult($definition); }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { /** @var GetListContext $context */ if ($context->hasQuery()) { // a query is already built return; } $entityClass = $context->getClassName(); if (!$this->doctrineHelper->isManageableEntityClass($entityClass)) { // only manageable entities are supported return; } $filterValues = $context->getFilterValues(); if ($filterValues->has(self::SORT_FILTER_KEY)) { $filterValue = $filterValues->get(self::SORT_FILTER_KEY); $filterValue->setValue($this->normalizeValue($filterValue->getValue(), $entityClass)); } }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { /** @var ConfigContext $context */ $filters = $context->getFilters(); if (empty($filters)) { // nothing to normalize return; } $fields = ConfigUtil::getArrayValue($filters, ConfigUtil::FIELDS); if (ConfigUtil::isExcludeAll($filters)) { $fields = ConfigUtil::removeExclusions($fields); } else { $entityClass = $context->getClassName(); if ($this->doctrineHelper->isManageableEntityClass($entityClass)) { $fields = ConfigUtil::removeExclusions($this->completeFilters($fields, $entityClass, $context->getResult())); } } $context->setFilters([ConfigUtil::EXCLUSION_POLICY => ConfigUtil::EXCLUSION_POLICY_ALL, ConfigUtil::FIELDS => $fields]); }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { /** @var ConfigContext $context */ /** @var array|null $definition */ $definition = $context->getResult(); if (empty($definition) || !is_array($definition[ConfigUtil::FIELDS])) { // nothing to do return; } $fieldsDefinition = $definition[ConfigUtil::FIELDS]; $entityClass = $context->getClassName(); if (!$this->doctrineHelper->isManageableEntityClass($entityClass)) { return; } $filterFieldsConfig = $context->get(FilterFieldsConfigExtra::NAME); $this->filterFields($entityClass, $fieldsDefinition, $filterFieldsConfig); $this->filterAssociations($entityClass, $fieldsDefinition, $filterFieldsConfig); $context->setResult([ConfigUtil::EXCLUSION_POLICY => ConfigUtil::EXCLUSION_POLICY_ALL, ConfigUtil::FIELDS => $fieldsDefinition]); }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { /** @var ConfigContext $context */ /** @var array|null $definition */ $definition = $context->getResult(); if (empty($definition) || ConfigUtil::isExcludeAll($definition)) { // nothing to normalize return; } if (ConfigUtil::getArrayValue($definition, ConfigUtil::DEFINITION)) { $definition = ConfigUtil::getArrayValue($definition, ConfigUtil::DEFINITION); } $fields = ConfigUtil::getArrayValue($definition, ConfigUtil::FIELDS); $entityClass = $context->getClassName(); if ($this->doctrineHelper->isManageableEntityClass($entityClass)) { $fields = $this->completeDefinition($fields, $entityClass, $context->getVersion(), $context->getRequestType(), $context->getExtras()); } $context->setResult([ConfigUtil::EXCLUSION_POLICY => ConfigUtil::EXCLUSION_POLICY_ALL, ConfigUtil::FIELDS => $fields]); }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { /** @var ConfigContext $context */ $maxRelatedEntities = $context->getMaxRelatedEntities(); if (null === $maxRelatedEntities || $maxRelatedEntities < 0) { // there is no limit to the number of related entities return; } $definition = $context->getResult(); if (empty($definition)) { // nothing to update return; } $entityClass = $context->getClassName(); if (!$this->doctrineHelper->isManageableEntityClass($entityClass)) { // only manageable entities are supported return; } $this->setLimits($definition, $entityClass, $maxRelatedEntities); $context->setResult($definition); }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { /** @var Context $context */ $entityClass = $context->getClassName(); if (!$this->doctrineHelper->isManageableEntityClass($entityClass)) { // only manageable entities are supported return; } $indexedAssociations = $this->doctrineHelper->getIndexedAssociations($this->doctrineHelper->getEntityMetadata($entityClass)); if (!$indexedAssociations) { // no associations - no sense to add include filters return; } $filters = $context->getFilters(); if ($filters->has(self::FILTER_KEY)) { // filters have been already set return; } $includeFilter = new IncludeFilter(DataType::STRING, 'Inclusion of related resources. Comma-separated paths, e.g. "articles,comments,author"'); $includeFilter->setArrayAllowed(true); $filters->add(self::FILTER_KEY, $includeFilter); }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { /** @var GetContext $context */ if ($context->hasQuery()) { // a query is already built return; } $entityClass = $context->getClassName(); if (!$this->doctrineHelper->isManageableEntityClass($entityClass)) { // only manageable entities are supported return; } $query = $this->doctrineHelper->getEntityRepositoryForClass($entityClass)->createQueryBuilder('e'); $this->doctrineHelper->applyCriteria($query, $context->getCriteria()); $entityId = $context->getId(); $idFields = $this->doctrineHelper->getEntityIdentifierFieldNamesForClass($entityClass); if (count($idFields) === 1) { // single identifier if (is_array($entityId)) { throw new \UnexpectedValueException(sprintf('The entity identifier cannot be an array because the entity "%s" has single primary key.', $entityClass)); } $query->andWhere(sprintf('e.%s = :id', reset($idFields)))->setParameter('id', $entityId); } else { // combined identifier if (!is_array($entityId)) { throw new \UnexpectedValueException(sprintf('The entity identifier must be an array because the entity "%s" has composite primary key.', $entityClass)); } $counter = 1; foreach ($idFields as $field) { if (!array_key_exists($field, $entityId)) { throw new \UnexpectedValueException(sprintf('The entity identifier array must have the key "%s" because ' . 'the entity "%s" has composite primary key.', $field, $entityClass)); } $query->andWhere(sprintf('e.%s = :id%d', $field, $counter))->setParameter(sprintf('id%d', $counter), $entityId[$field]); $counter++; } } $context->setQuery($query); }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { /** @var RelationConfigContext $context */ $config = $context->getResult(); if (null !== $config && ConfigUtil::isRelationInitialized($config)) { // a config already exists return; } $entityClass = $context->getClassName(); if (!$this->doctrineHelper->isManageableEntityClass($entityClass)) { // only manageable entities are supported return; } if (null === $config) { $config = []; } $targetIdFields = $this->doctrineHelper->getEntityIdentifierFieldNamesForClass($entityClass); if (!isset($config[ConfigUtil::EXCLUSION_POLICY])) { $config[ConfigUtil::EXCLUSION_POLICY] = ConfigUtil::EXCLUSION_POLICY_ALL; } $config[ConfigUtil::FIELDS] = count($targetIdFields) === 1 ? reset($targetIdFields) : array_fill_keys($targetIdFields, null); $context->setResult($config); }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { /** @var ConfigContext $context */ $filters = $context->getFilters(); if (empty($filters) || empty($filters[ConfigUtil::FIELDS])) { // a configuration of filters does not exist return; } $entityClass = $context->getClassName(); if (!$this->entityConfigProvider->hasConfig($entityClass)) { // only configurable entities are supported return; } foreach ($filters[ConfigUtil::FIELDS] as $filterKey => &$filterConfig) { if (!isset($filterConfig[ConfigUtil::DESCRIPTION])) { $config = $this->findFieldConfig($entityClass, $filterKey, $filterConfig); if (null !== $config) { $filterConfig[ConfigUtil::DESCRIPTION] = new Label($config->get('label')); } } } $context->setFilters($filters); }