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