/** * {@inheritdoc} */ public function process(ContextInterface $context) { /** @var GetListContext $context */ $documentBuilder = $this->documentBuilderFactory->createDocumentBuilder(); try { if ($context->hasErrors()) { $documentBuilder->setErrorCollection($context->getErrors()); // remove errors from the Context to avoid processing them by other processors $context->resetErrors(); } elseif ($context->hasResult()) { $result = $context->getResult(); if (empty($result)) { $documentBuilder->setDataCollection($result); } else { $documentBuilder->setDataCollection($result, $context->getMetadata()); } } $context->setResult($documentBuilder->getDocument()); } catch (\Exception $e) { $context->setResponseStatusCode(Response::HTTP_INTERNAL_SERVER_ERROR); $error = new Error(); $error->setInnerException($e); $documentBuilder = $this->documentBuilderFactory->createDocumentBuilder(); $documentBuilder->setErrorObject($error); $context->setResult($documentBuilder->getDocument()); } }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { /** @var GetListContext $context */ if ($context->hasResult()) { // result data are already retrieved return; } $query = $context->getQuery(); if ($query instanceof QueryBuilder) { $context->setResult($query->getQuery()->getResult()); } elseif ($query instanceof Query) { $context->setResult($query->getResult()); } }
/** * {@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 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 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 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 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 GetContext $context */ if ($context->hasResult()) { // data already retrieved return; } $query = $context->getQuery(); if (!$query instanceof QueryBuilder) { // unsupported query return; } $config = $context->getConfig(); if (null === $config) { // an entity configuration does not exist return; } $result = $this->entitySerializer->serialize($query, $config); if (empty($result)) { $result = null; } elseif (count($result) === 1) { $result = reset($result); } else { throw new \RuntimeException('The result must have one or zero items.'); } $context->setResult($result); // data returned by the EntitySerializer are already normalized $context->skipGroup('normalize_data'); }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { /** @var CollectPublicResourcesContext $context */ $context->setResult($context->getResult()->filter(function (PublicResource $resource) { return !$this->entityExclusionProvider->isIgnoredEntity($resource->getEntityClass()); })); }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { if ($context->hasResult()) { // a definition is already built return; } $context->setResult(ConfigUtil::getInitialConfig()); }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { $config = $context->getResult(); if (null !== $config) { // a config already exists return; } $context->setResult(null); }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { /** @var ConfigContext $context */ $definition = $context->getResult(); if (empty($definition)) { // nothing to normalize return; } $this->normalizeDefinition($definition); $context->setResult($definition); }
/** * {@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 ConfigContext $context */ $definition = $context->getResult(); if (empty($definition)) { // an entity configuration does not exist return; } $this->normalizeAttribute($definition, ConfigUtil::LABEL); $this->normalizeAttribute($definition, ConfigUtil::PLURAL_LABEL); $this->normalizeAttribute($definition, ConfigUtil::DESCRIPTION); $context->setResult($definition); }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { /** @var GetContext $context */ if (!$context->hasResult()) { // no result return; } $data = $context->getResult(); if (empty($data)) { // nothing to do because of empty result return; } $config = $context->getConfig(); $context->setResult($this->objectNormalizer->normalizeObject($data, $config)); }
/** * {@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 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 normalization is not needed return; } $fields = array_keys($definition[ConfigUtil::FIELDS]); foreach ($fields as $fieldName) { $fieldConfig = $definition[ConfigUtil::FIELDS][$fieldName]; if (null !== $fieldConfig && is_array($fieldConfig)) { $this->normalizeAttribute($fieldConfig, ConfigUtil::LABEL); $this->normalizeAttribute($fieldConfig, ConfigUtil::DESCRIPTION); $definition[ConfigUtil::FIELDS][$fieldName] = $fieldConfig; } } $context->setResult($definition); }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { /** @var GetListContext $context */ if ($context->hasResult()) { // result data are already retrieved return; } $query = $context->getQuery(); if (!$query instanceof SearchQuery) { // unsupported query return; } $searchResult = $this->searchIndex->query($query); $context->setResult($searchResult->toArray()); // set callback to be used to calculate total count $context->setTotalCountCallback(function () use($searchResult) { return $searchResult->getRecordsCount(); }); }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { /** @var GetListContext $context */ if (!$context->hasResult()) { // no result return; } $data = $context->getResult(); if (empty($data)) { // nothing to do because of empty result return; } $config = $context->getConfig(); $normalizedData = []; foreach ($data as $key => $value) { $normalizedData[$key] = $this->objectNormalizer->normalizeObject($value, $config); } $context->setResult($normalizedData); }
/** * {@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 */ /** @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 */ $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 GetListContext $context */ if ($context->hasResult()) { // data already retrieved return; } $query = $context->getQuery(); if (!$query instanceof QueryBuilder) { // unsupported query return; } $config = $context->getConfig(); if (null === $config) { // an entity configuration does not exist return; } $context->setResult($this->entitySerializer->serialize($query, $config)); // data returned by the EntitySerializer are already normalized $context->skipGroup('normalize_data'); }
/** * {@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 NormalizeValueContext $context */ if (!$context->hasRequirement()) { $context->setRequirement(self::REQUIREMENT); } if ($context->hasResult()) { $value = $context->getResult(); if (null !== $value && is_string($value)) { $orderBy = []; $items = explode(RestRequest::ARRAY_DELIMITER, $value); foreach ($items as $item) { $item = trim($item); if (0 === strpos($item, '-')) { $orderBy[substr($item, 1)] = Criteria::DESC; } else { $orderBy[$item] = Criteria::ASC; } } $context->setResult($orderBy); } } }
/** * {@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; } $classMetadata = $this->doctrineHelper->getEntityMetadataForClass($entityClass); $entityMetadata = $this->entityMetadataFactory->createEntityMetadata($classMetadata); $fields = $classMetadata->getFieldNames(); foreach ($fields as $fieldName) { $entityMetadata->addField($this->entityMetadataFactory->createFieldMetadata($classMetadata, $fieldName)); } $associations = $classMetadata->getAssociationNames(); foreach ($associations as $associationName) { $entityMetadata->addAssociation($this->entityMetadataFactory->createAssociationMetadata($classMetadata, $associationName)); } $context->setResult($entityMetadata); }