/** * {@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 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 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 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 Context $context */ if ($this->isJsonApiRequest($context->getRequestHeaders())) { $context->setRequestType(RequestType::JSON_API); } }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { /** @var Context $context */ if (!$context->hasErrors()) { // no errors return; } $errors = $context->getErrors(); $error = $errors[0]; $exception = $error->getInnerException(); if (null !== $exception) { $underlyingException = ExceptionUtil::getProcessorUnderlyingException($exception); if ($underlyingException instanceof HttpExceptionInterface) { $exception = $underlyingException; } } else { $message = $error->getDetail(); if (empty($message)) { $message = $error->getTitle(); } if (empty($message)) { $message = 'Unknown error.'; } $exception = new \RuntimeException($message); } throw $exception; }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { $result = $context->getResult(); if (array_key_exists(JsonApiDocument::DATA, $result) && !is_array($result[JsonApiDocument::DATA])) { throw new \RuntimeException(sprintf('The "%s" section must be an array.', JsonApiDocument::DATA)); } }
/** * {@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)) { // 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 $context Context */ /** @var $context Context */ if (null !== $context->getResponseStatusCode()) { // the status code is already set return; } $statusCode = Response::HTTP_OK; if ($context->hasErrors()) { $groupedCodes = []; foreach ($context->getErrors() as $error) { $code = $error->getStatusCode() ?: Response::HTTP_INTERNAL_SERVER_ERROR; $groupCode = (int) floor($code / 100) * 100; $groupedCodes[$groupCode][] = $code; } if (!empty($groupedCodes)) { $maxGroup = max(array_keys($groupedCodes)); $statusCode = $maxGroup; if (count($groupedCodes[$maxGroup]) === 1) { $statusCode = array_pop($groupedCodes[$maxGroup]); } } else { $statusCode = Response::HTTP_INTERNAL_SERVER_ERROR; } } $context->setResponseStatusCode($statusCode); }
/** * {@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) { /** @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 GetListContext $context */ if (!in_array(RequestType::REST, $context->getRequestType(), true)) { parent::process($context); } else { // reuse REST API sorting filter $filters = $context->getFilters(); $sortFilterKey = $this->getSortFilterKey(); if ($sortFilterKey !== RestSetDefaultSorting::SORT_FILTER_KEY && $filters->has(RestSetDefaultSorting::SORT_FILTER_KEY)) { $filter = $filters->get(RestSetDefaultSorting::SORT_FILTER_KEY); $filters->remove(RestSetDefaultSorting::SORT_FILTER_KEY); $filters->add($sortFilterKey, $filter); } if ($filters->has($sortFilterKey)) { $filter = $filters->get($sortFilterKey); if ($filter instanceof SortFilter) { $entityClass = $context->getClassName(); $filter->setDefaultValue(function () use($entityClass) { return $this->getDefaultValue($entityClass); }); } } } }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { /** @var Context $context */ if (!$context->hasConfigExtra(MaxRelatedEntitiesConfigExtra::NAME)) { $context->addConfigExtra(new MaxRelatedEntitiesConfigExtra(self::DEFAULT_MAX_RELATED_ENTITIES)); } }
/** * {@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) { if ($context->hasResult()) { // a definition is already built return; } $context->setResult(ConfigUtil::getInitialConfig()); }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { /** @var Context $context */ $responseHeaders = $context->getResponseHeaders(); if (!$responseHeaders->has('Content-Type')) { $context->getResponseHeaders()->set('Content-Type', self::JSON_API_CONTENT_TYPE); } }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { /** @var Context $context */ $requestType = $context->getRequestType(); if (empty($requestType)) { throw new \RuntimeException('The type of a request must be set in the context.'); } }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { /** @var NormalizeValueContext $context */ $arrayDelimiter = $context->getArrayDelimiter(); if (empty($arrayDelimiter)) { $context->setArrayDelimiter(self::ARRAY_DELIMITER); } }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { if (!$context->hasResult()) { throw new NotFoundHttpException('Unsupported request.'); } elseif (null === $context->getResult()) { throw new NotFoundHttpException('An entity with the requested identifier does not exist.'); } }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { /** @var SingleItemContext $context */ $entityId = $context->getId(); if (empty($entityId)) { throw new \RuntimeException('The identifier of an entity must be set in the context.'); } }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { /** @var Context $context */ if (null !== $context->getCriteria()) { // the Criteria object is already initialized return; } $context->setCriteria(new Criteria($this->entityClassResolver)); }
/** * {@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 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 CollectPublicResourcesContext $context */ $resources = $context->getResult(); $entities = $this->dictionaryProvider->getSupportedEntityClasses(); foreach ($entities as $entityClass) { $resources->add(new PublicResource($entityClass)); } }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { /** @var ConfigContext $context */ if ($context->hasFilters()) { // a filters' definition is already built return; } $context->setFilters(ConfigUtil::getInitialConfig()); }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { /** @var Context $context */ $version = $context->getVersion(); if (null === $version) { $context->setVersion(Version::LATEST); } elseif (0 === strpos($version, 'v')) { $context->setVersion(substr($version, 1)); } }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { /** @var GetListContext $context */ $filterCollection = $context->getFilters(); $filters = $filterCollection->all(); foreach ($filters as $filterKey => $filter) { $filterCollection->remove($filterKey); $filterCollection->add(sprintf(self::FILTER_KEY_TEMPLATE, $filterKey), $filter); } }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { /** @var NormalizeValueContext $context */ if (!$context->hasRequirement()) { $this->processRequirement($context); } if ($context->hasResult()) { $this->processNormalization($context); } }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { /** @var Context $context */ $xInclude = $context->getRequestHeaders()->get(Context::INCLUDE_HEADER); if (empty($xInclude) || is_array($xInclude)) { // no X-Include header or it is already normalized return; } $context->getRequestHeaders()->set(Context::INCLUDE_HEADER, array_filter(array_map('trim', explode(';', $xInclude)))); }