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