/**
* {@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 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 (!$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 reverseTransform($entityClass, $value)
{
if ($this->doctrineHelper->isManageableEntityClass($entityClass)) {
$metadata = $this->doctrineHelper->getEntityMetadataForClass($entityClass);
$idFields = $metadata->getIdentifierFieldNames();
$value = count($idFields) === 1 ? $this->reverseTransformSingleId($value, $metadata->getTypeOfField(reset($idFields))) : $this->reverseTransformCombinedEntityId($value, $idFields, $metadata);
}
return $value;
}
/**
* {@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 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();
}
}
/**
* @param array $definition
* @param ConfigContext $context
*/
protected function setCustomizationHandler(array &$definition, ConfigContext $context)
{
$entityClass = $context->getClassName();
$definition[ConfigUtil::POST_SERIALIZE] = $this->getRootCustomizationHandler($context, $entityClass, isset($definition[ConfigUtil::POST_SERIALIZE]) ? $definition[ConfigUtil::POST_SERIALIZE] : null);
if (!$this->doctrineHelper->isManageableEntityClass($entityClass)) {
// we can set customization handlers for associations only for manageable entity,
// because for other types of entities we do not have metadata
return;
}
if (isset($definition[ConfigUtil::FIELDS]) && is_array($definition[ConfigUtil::FIELDS])) {
$this->processFields($context, $definition[ConfigUtil::FIELDS], $entityClass, $this->doctrineHelper->getEntityMetadataForClass($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;
}
$this->addSortFilter($context->getFilters(), $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 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 */
/** @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 */
$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 */
$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 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);
}
