/**
* {@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))));
}
