/**
* {@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 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 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)
{
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)
{
if ($context->hasResult()) {
// a definition is already built
return;
}
$context->setResult(ConfigUtil::getInitialConfig());
}
/**
* {@inheritdoc}
*/
public function process(ContextInterface $context)
{
if (!$context->hasResult()) {
// no result
return;
}
$data = $context->getResult();
if ($data instanceof Proxy && !$data->__isInitialized()) {
$data->__load();
}
}
/**
* {@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 */
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)
{
if (!$context->hasResult()) {
// no result
return;
}
$data = $context->getResult();
foreach ($data as $value) {
if ($value instanceof Proxy && !$value->__isInitialized()) {
$value->__load();
}
}
}
/**
* {@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 MetadataContext $context */
if (!$context->hasResult()) {
// metadata is not loaded
return;
}
$config = $context->getConfig();
if (empty($config)) {
// a configuration does not exist
return;
}
$this->loadMetadataForRelatedEntities($context->getResult(), $config, $context);
}
/**
* {@inheritdoc}
*/
public function process(ContextInterface $context)
{
/** @var GetListContext $context */
if (!$context->hasResult()) {
$query = $context->getQuery();
if (null === $query) {
throw new NotFoundHttpException('Unsupported request.');
} else {
throw new NotFoundHttpException(sprintf('Unsupported query type: %s.', is_object($query) ? get_class($query) : gettype($query)));
}
} elseif (!is_array($context->getResult())) {
throw new NotFoundHttpException('Getting a list of entities failed.');
}
}
/**
* {@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 MetadataContext $context */
if (!$context->hasResult()) {
// metadata is not loaded
return;
}
$config = $context->getConfig();
if (empty($config)) {
// a configuration does not exist
return;
}
/** @var EntityMetadata $entityMetadata */
$entityMetadata = $context->getResult();
$this->normalizeMetadata($entityMetadata, $config);
}
/**
* {@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 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()) {
// 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 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);
}
