Programming Language PHP
Namespace Oro\Component\ChainProcessor
Class ContextInterface
Total Examples 50
50 code examples of PHP Oro\Component\ChainProcessor\ContextInterface extracted from open source projects
/**
* @inheritDoc
*/
public function process(ContextInterface $context)
{
/** @var TransitionContext $context */
if (!$context->getResultType() instanceof TemplateResultType) {
return;
}
$context->setResult($this->createCompleteResponse($context));
$context->setProcessed(true);
}
/**
* @param ContextInterface|TransitionContext $context
*/
public function process(ContextInterface $context)
{
if ($context->isSaved() || !$context->getResultType() instanceof TemplateResultType) {
return;
}
$response = new Response();
$response->setContent(
$this->twig->render($this->getTemplate($context), $context->get('template_parameters'))
);
$context->setResult($response);
$context->setProcessed(true);
}
/**
* @param ContextInterface|TransitionContext $context
*/
public function process(ContextInterface $context)
{
if (!$this->isApplicable($context)) {
return;
}
$templateData = array_merge($this->getTemplateData($context), $context->get('template_parameters'));
$response = new Response();
$response->setContent($this->twig->render($this->getTemplate($context), $templateData));
$context->setResult($response);
$context->setProcessed(true);
}
/**
* @param ContextInterface|TransitionContext $context
*/
public function process(ContextInterface $context)
{
if (!$this->isApplicable($context)) {
return;
}
$transitionForm = $context->getForm();
$context->set(
'template_parameters',
[
'transition' => $context->getTransition(),
'workflowItem' => $context->getWorkflowItem(),
'saved' => false,
'form' => $transitionForm->createView(),
'formErrors' => $transitionForm->getErrors(true),
]
);
}
/**
* @param ContextInterface|TransitionContext $context
*/
public function process(ContextInterface $context)
{
if ($context->getTransition()->isEmptyInitOptions()) {
return;
}
$initData = $context->get(TransitionContext::INIT_DATA);
$attribute = $context->getTransition()->getInitContextAttribute();
$initData[$attribute] = $this->buttonSearchContextProvider->getButtonSearchContext();
$context->set(TransitionContext::INIT_DATA, $initData);
$context->set(TransitionContext::ENTITY_ID, null);
}
/**
* @param ContextInterface|TransitionContext $context
*/
public function process(ContextInterface $context)
{
if (!$context->isStartTransition()) {
return;
}
$context->set(TransitionContext::ENTITY_ID, $context->getRequest()->get('entityId', null));
$context->set(TransitionContext::INIT_DATA, []);
}
/**
* @param ContextInterface|TransitionContext $context
*/
public function process(ContextInterface $context)
{
$resultType = $context->getResultType();
if (!$resultType instanceof LayoutPageResultType) {
return;
}
$this->helper->processTransitionTranslations($context->getTransition());
$context->setResult(
[
'workflowName' => $context->getWorkflow()->getLabel(),
'transitionName' => $context->getTransitionName(),
'data' => [
'transitionFormView' => $context->getForm()->createView(),
'transition' => $context->getTransition(),
'workflowItem' => $context->getWorkflowItem(),
'formRouteName' => $resultType->getFormRouteName(),
'originalUrl' => $context->getRequest()->get('originalUrl', '/'),
],
]
);
$context->setProcessed(true);
}
/**
* @param ContextInterface|TransitionContext $context
*/
public function process(ContextInterface $context)
{
$resultType = $context->getResultType();
if (!$resultType instanceof LayoutPageResultType) {
return;
}
$this->helper->processTransitionTranslations($context->getTransition());
$transitionName = $context->getTransitionName();
$request = $context->getRequest();
$context->setResult(
[
'workflowName' => $context->getWorkflow()->getLabel(),
'transitionName' => $transitionName,
'data' => [
'transitionFormView' => $context->getForm()->createView(),
'workflowName' => $context->getWorkflowName(),
'workflowItem' => $context->getWorkflowItem(),
'transitionName' => $transitionName,
'transition' => $context->getTransition(),
'entityId' => $request->get('entityId', 0),
'originalUrl' => $request->get('originalUrl', '/'),
'formRouteName' => $resultType->getFormRouteName(),
],
]
);
$context->setProcessed(true);
}
/**
* @param ContextInterface|TransitionContext $context
*/
public function process(ContextInterface $context)
{
$resultType = $context->getResultType();
if (!$resultType instanceof LayoutDialogResultType) {
return;
}
$context->setResult(
[
'data' => [
'transition' => $context->getTransition(),
'transitionFormView' => $context->getForm()->createView(),
'workflowItem' => $context->getWorkflowItem(),
'formRouteName' => $resultType->getFormRouteName(),
'originalUrl' => null,
],
]
);
$context->setProcessed(true);
}
/**
* @param ContextInterface|TransitionContext $context
*/
public function process(ContextInterface $context)
{
$resultType = $context->getResultType();
if (!$resultType instanceof LayoutDialogResultType) {
return;
}
$context->setResult(
[
'data' => [
'workflowName' => $context->getWorkflowName(),
'workflowItem' => $context->getWorkflowItem(),
'transition' => $context->getTransition(),
'transitionName' => $context->getTransitionName(),
'transitionFormView' => $context->getForm()->createView(),
'entityId' => $context->getRequest()->get('entityId', 0),
'formRouteName' => $resultType->getFormRouteName(),
'originalUrl' => null,
],
]
);
$context->setProcessed(true);
}
/**
* @param ContextInterface|TransitionContext $context
*/
public function process(ContextInterface $context)
{
if (!$this->isApplicable($context)) {
return;
}
$data = [
'workflowItem' => ['result' => $context->getWorkflowItem()->getResult()->toArray()],
];
$context->setResult(new JsonResponse($data));
$context->setProcessed(true);
}
/**
* @param ContextInterface|TransitionContext $context
*/
public function process(ContextInterface $context)
{
if (!$context->hasError()) {
return;
}
$response = new Response();
$response->setStatusCode(
$context->get('responseCode') ?: Response::HTTP_INTERNAL_SERVER_ERROR,
$context->get('responseMessage') ?: $context->getError()->getMessage()
);
$context->setResult($response);
$context->setProcessed(true);
}
/**
* @param ContextInterface|TransitionContext $context
*/
public function process(ContextInterface $context)
{
//skip if custom failure handling were performed already or no failures met
if (!$this->isApplicable($context)) {
return;
}
try {
throw $context->getError();
} catch (HttpException $e) {
$responseCode = $e->getStatusCode();
} catch (WorkflowNotFoundException $e) {
$responseCode = Response::HTTP_NOT_FOUND;
} catch (UnknownAttributeException $e) {
$responseCode = Response::HTTP_BAD_REQUEST;
} catch (InvalidTransitionException $e) {
$responseCode = Response::HTTP_BAD_REQUEST;
} catch (ForbiddenTransitionException $e) {
$responseCode = Response::HTTP_FORBIDDEN;
} catch (\Throwable $e) {
$responseCode = Response::HTTP_INTERNAL_SERVER_ERROR;
} finally {
$responseMessage = $e->getMessage();
}
$this->logger->error(
'[TransitionHandler] Could not perform transition.',
[
'exception' => $context->getError(),
'transition' => $context->getTransition(),
'workflowItem' => $context->getWorkflowItem(),
]
);
$context->set('responseCode', $responseCode);
$context->set('responseMessage', $responseMessage);
}
/**
* @param ContextInterface|TransitionContext $context
*/
public function process(ContextInterface $context)
{
$transition = $context->getTransition();
$attributeNames = array_keys($transition->getFormOptions()['attribute_fields']);
$data = $context->getForm()->getData()->getValues($attributeNames);
$initData = $context->get(TransitionContext::INIT_DATA) ?: [];
$context->set(
TransitionContext::INIT_DATA,
array_merge(
$data,
$initData
)
);
}
/**
* @inheritDoc
*/
public function process(ContextInterface $context)
{
/** @var ListContext $context */
if ($context->hasResult()) {
// data already retrieved
return;
}
$context->setResult(
$this->searchEntityRepository->getSearchEntities(
$context->getVersion(),
$context->getRequestType(),
$context->getFilterValues()->get('searchable')?->getValue()
)
);
}
/**
* @inheritDoc
*/
public function process(ContextInterface $context)
{
/** @var ListContext $context */
if ($context->hasResult()) {
// result data are already retrieved
return;
}
$criteria = $context->getCriteria();
if (null === $criteria) {
// something going wrong, it is expected that the criteria exists
return;
}
$entities = $this->searchEntityListFilterHelper->getEntities($context, 'entities');
if ($context->hasErrors()) {
// the "entities" filter has some invalid data
return;
}
if (!$entities) {
// the "entities" filter does not have any entities allowed for the current logged in user
$context->setResult([]);
$context->setTotalCountCallback(function () {
return 0;
});
return;
}
$criteria = $context->getCriteria();
$limit = $criteria->getMaxResults();
$searchResult = $this->searchIndex->simpleSearch(
$context->getFilterValues()->get('searchText')?->getValue(),
$criteria->getFirstResult(),
(null !== $limit && $context->getConfig()->getHasMore()) ? $limit + 1 : $limit,
$entities
);
$context->setResult($this->buildSearchResult($searchResult->toArray(), $limit, $context->getRequestType()));
$context->setTotalCountCallback(function () use ($searchResult) {
return $searchResult->getRecordsCount();
});
}
/**
* @inheritdoc
*/
public function process(ContextInterface $context)
{
/** @var Context $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->normalizer->normalize($value, $config);
}
$context->setResult($normalizedData);
// skip default normalization
$context->skipGroup(ApiActionGroup::NORMALIZE_DATA);
}
/**
* @inheritdoc
*/
public function process(ContextInterface $context)
{
/** @var Context $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->normalizer->normalize($value, $config);
}
$context->setResult($normalizedData);
// skip default normalization
$context->skipGroup(ApiActionGroup::NORMALIZE_DATA);
}
/**
* @inheritdoc
*/
public function process(ContextInterface $context)
{
/** @var Context $context */
if (!$context->hasResult()) {
// no result
return;
}
$data = $context->getResult();
if (empty($data)) {
// nothing to do because of empty result
return;
}
$context->setResult(
$this->normalizer->normalize($data, $context->getConfig())
);
// skip default normalization
$context->skipGroup(ApiActionGroup::NORMALIZE_DATA);
}
/**
* @inheritdoc
*/
public function process(ContextInterface $context)
{
/** @var Context $context */
if (!$context->hasResult()) {
// no result
return;
}
$data = $context->getResult();
if (empty($data)) {
// nothing to do because of empty result
return;
}
$context->setResult(
$this->normalizer->normalize($data, $context->getConfig())
);
// skip default normalization
$context->skipGroup(ApiActionGroup::NORMALIZE_DATA);
}
/**
* @inheritdoc
*/
public function process(ContextInterface $context)
{
/** @var SubresourceContext $context */
if ($context->hasResult()) {
// the suggestions are already loaded
return;
}
$suggestions = [];
$filterHelper = new FilterHelper($context->getFilters(), $context->getFilterValues());
$data = $this->apiEntityManager->getSuggestionResult(
$context->getParentId(),
$filterHelper->getPageNumber(),
$filterHelper->getPageSize(),
(bool) $filterHelper->getBooleanFilterValue('exclude-current-user')
);
$titlePropertyPath = null;
if (!$context->isProcessed(LoadTitleMetaProperty::OPERATION_NAME)) {
$titlePropertyPath = ConfigUtil::getPropertyPathOfMetaProperty(
LoadTitleMetaProperty::TITLE_META_PROPERTY_NAME,
$context->getConfig()
);
}
foreach ($data['result'] as $item) {
$suggestion = new EntityIdentifier($item['id'], $item['entity']);
if ($titlePropertyPath) {
$suggestion->setAttribute($titlePropertyPath, $item['title']);
}
$suggestions[] = $suggestion;
}
if ($titlePropertyPath) {
$context->setProcessed(LoadTitleMetaProperty::OPERATION_NAME);
}
$context->setResult($suggestions);
}
/**
* @inheritdoc
*/
public function process(ContextInterface $context)
{
/** @var ListContext $context */
$data = $context->getResult();
if (empty($data) || !$context->isSuccessResponse()) {
// no data or the result document contains info about errors
return;
}
$sectionNames = [];
foreach ($data as $item) {
$sectionNames[] = $item['id'];
}
$context->setResult($sectionNames);
}
/**
* @inheritdoc
*/
public function process(ContextInterface $context)
{
/** @var ListContext $context */
if ($context->hasResult()) {
// data already retrieved
return;
}
// Here we need to check if an access to system configuration is granted,
// because it is possible that some configuration sections will be accessible
// even if "Access system configuration" capability is disabled.
// So, such sections will be added by separate loaders in additional to existing sections.
$isAccessToSystemConfigurationGranted = true;
$aclResource = $context->getConfig()->getAclResource();
if ($aclResource && !$this->authorizationChecker->isGranted($aclResource)) {
$isAccessToSystemConfigurationGranted = false;
}
$sections = [];
if ($isAccessToSystemConfigurationGranted) {
$sectionIds = $this->configRepository->getSectionIds();
foreach ($sectionIds as $sectionId) {
$sections[] = $this->configRepository->getSection(
$sectionId,
$context->get(GetScope::CONTEXT_PARAM)
);
}
}
$context->setResult($sections);
}
/**
* @inheritdoc
*/
public function process(ContextInterface $context)
{
/** @var SingleItemContext $context */
if ($context->hasResult()) {
// data already retrieved
return;
}
$section = $this->configRepository->getSection(
$context->getId(),
$context->get(GetScope::CONTEXT_PARAM)
);
if (!$section) {
throw new NotFoundHttpException();
}
$context->setResult($section);
}
/**
* @inheritdoc
*/
public function process(ContextInterface $context)
{
$context->setResult(new TestResourceWithoutIdentifier());
}
/**
* @inheritdoc
*/
public function process(ContextInterface $context)
{
/** @var Context $context */
$resultName = 'test';
// test that it is possible to add a filter for "get" action for resources without identifier
$filters = $context->getFilters();
$filterValues = $context->getFilterValues();
$filterKeys = [
AddFiltersToResourceWithoutIdentifier::FILTER1_KEY,
AddFiltersToResourceWithoutIdentifier::FILTER2_KEY,
];
foreach ($filterKeys as $filterKey) {
if ($filters->has($filterKey)) {
$filterValue = $filterValues->get($filterKey);
if (null !== $filterValue) {
$val = $filterValue->getValue();
if ($val instanceof \DateTime) {
$val = $val->format('j/n/Y');
}
$resultName .= sprintf(' (%s value: %s)', $filterKey, $val);
}
}
}
$entity = new TestResourceWithoutIdentifier();
$entity->setName($resultName);
$context->setResult($entity);
}
/**
* @inheritdoc
*/
public function process(ContextInterface $context)
{
/** @var GetContext $context */
if ($context->hasResult()) {
// data already loaded
return;
}
$magazineModel = null;
$em = $this->doctrineHelper->getEntityManagerForClass(TestMagazine::class);
/** @var TestMagazine|null $magazineEntity */
$magazineEntity = $em->find(TestMagazine::class, $context->getId());
if (null !== $magazineEntity) {
$magazineModel = new TestMagazineModel2();
$magazineModel->setId($magazineEntity->getId());
$magazineModel->setName($magazineEntity->getName());
foreach ($magazineEntity->getArticles() as $articleEntity) {
$articleModel = new TestArticleModel2();
$articleModel->setId($articleEntity->getId());
$articleModel->setHeadline($articleEntity->getHeadline());
$articleModel->setBody($articleEntity->getBody());
$magazineModel->addArticle($articleModel);
}
$bestArticleEntity = $magazineEntity->getBestArticle();
if (null !== $bestArticleEntity) {
$bestArticleModel = new TestArticleModel2();
$bestArticleModel->setId($bestArticleEntity->getId());
$bestArticleModel->setHeadline($bestArticleEntity->getHeadline());
$bestArticleModel->setBody($bestArticleEntity->getBody());
$magazineModel->setBestArticle($bestArticleModel);
}
}
$context->setResult($magazineModel);
}
/**
* @inheritdoc
*/
public function process(ContextInterface $context)
{
/** @var GetContext $context */
if ($context->hasResult()) {
// data already loaded
return;
}
$magazineModel = null;
$em = $this->doctrineHelper->getEntityManagerForClass(TestMagazine::class);
/** @var TestMagazine|null $magazineEntity */
$magazineEntity = $em->find(TestMagazine::class, $context->getId());
if (null !== $magazineEntity) {
$magazineModel = new TestMagazineModel1();
$magazineModel->setId($magazineEntity->getId());
$magazineModel->setName($magazineEntity->getName());
foreach ($magazineEntity->getArticles() as $articleEntity) {
$articleModel = new TestArticleModel1();
$articleModel->setId($articleEntity->getId());
$articleModel->setHeadline($articleEntity->getHeadline());
$articleModel->setBody($articleEntity->getBody());
$magazineModel->addArticle($articleModel);
}
$bestArticleEntity = $magazineEntity->getBestArticle();
if (null !== $bestArticleEntity) {
$bestArticleModel = new TestArticleModel1();
$bestArticleModel->setId($bestArticleEntity->getId());
$bestArticleModel->setHeadline($bestArticleEntity->getHeadline());
$bestArticleModel->setBody($bestArticleEntity->getBody());
$magazineModel->setBestArticle($bestArticleModel);
}
}
$context->setResult($magazineModel);
}
/**
* @inheritdoc
*/
public function process(ContextInterface $context)
{
$context->removeResult();
}
/**
* @inheritdoc
*/
public function process(ContextInterface $context)
{
/** @var Context $context */
if (!$context->hasResult()) {
return;
}
$exception = $context->getResult();
if (!$exception instanceof \Throwable) {
throw new RuntimeException(sprintf(
'The result should be an instance of Throwable, "%s" given.',
\is_object($exception) ? \get_class($exception) : gettype($exception)
));
}
if (!$exception instanceof \Exception) {
$exception = new \ErrorException(
$exception->getMessage(),
$exception->getCode(),
E_ERROR,
$exception->getFile(),
$exception->getLine(),
$exception
);
}
$context->addError(Error::createByException($exception));
$context->removeResult();
}
/**
* @inheritdoc
*/
public function process(ContextInterface $context)
{
/** @var ChangeSubresourceContext $context */
$associationName = $context->getAssociationName();
$data = $context->getResult();
if (!\is_array($data) || !\array_key_exists($associationName, $data) || \count($data) !== 1) {
// unsupported data
return;
}
$resultData = $data[$associationName];
if ($resultData instanceof Collection) {
$resultData = $resultData->toArray();
}
$context->setResult($resultData);
}
/**
* @inheritdoc
*/
public function process(ContextInterface $context)
{
/** @var Context $context */
$entities = $context->getResult();
if (!is_array($entities) && !$entities instanceof \Traversable) {
return;
}
$validatedEntities = [];
$config = $context->getConfig();
foreach ($entities as $entity) {
$isGranted = true;
if (null !== $config && $config->hasAclResource()) {
$aclResource = $config->getAclResource();
if ($aclResource) {
$isGranted = $this->authorizationChecker->isGranted($aclResource, $entity);
}
} else {
$isGranted = $this->authorizationChecker->isGranted($this->permission, $entity);
}
if ($isGranted) {
$validatedEntities[] = $entity;
}
}
$context->setResult($validatedEntities);
}
/**
* @inheritdoc
*/
public function process(ContextInterface $context)
{
/** @var Context $context */
$data = $context->getResult();
if (!\is_array($data) || empty($data)) {
// empty or not supported result data
return;
}
$metadata = $context->getMetadata();
if (null === $metadata) {
// only API resources with metadata are supported
return;
}
$infoRecords = $this->processData($data, $metadata);
$context->setResult($data);
if (!empty($infoRecords)) {
if ($context->getInfoRecords()) {
foreach ($infoRecords as $key => $val) {
$context->addInfoRecord($key, $val);
}
} else {
$context->setInfoRecords($infoRecords);
}
}
}
/**
* @inheritdoc
*/
public function process(ContextInterface $context)
{
/** @var Context $context */
if (!$context->hasResult()) {
// no result
return;
}
$data = $context->getResult();
if (empty($data)) {
// nothing to do because of empty result
return;
}
$data = $this->objectNormalizer->normalizeObjects(
[$data],
$context->getConfig(),
$context->getNormalizationContext()
);
$context->setResult(reset($data));
}
/**
* @inheritdoc
*/
public function process(ContextInterface $context)
{
/** @var Context $context */
if (!$context->hasResult()) {
// no result
return;
}
$data = $context->getResult();
if (empty($data)) {
// nothing to do because of empty result
return;
}
$context->setResult(
$this->objectNormalizer->normalizeObjects(
$data,
$context->getConfig(),
$context->getNormalizationContext()
)
);
}
/**
* @inheritdoc
*/
public function process(ContextInterface $context)
{
/** @var Context $context */
if ($context->hasResult()) {
// data already retrieved
return;
}
$query = $context->getQuery();
if (!$query instanceof QueryBuilder) {
// unsupported query
return;
}
$config = $context->getConfig();
if (null === $config) {
// only configured API resources are supported
return;
}
$context->setResult(
$this->loadNormalizedData($query, $config, $context->getNormalizationContext())
);
// data returned by the EntitySerializer are already normalized
$context->skipGroup(ApiActionGroup::NORMALIZE_DATA);
}
/**
* @inheritdoc
*/
public function process(ContextInterface $context)
{
/** @var Context $context */
if ($context->hasResult()) {
// data already retrieved
return;
}
$query = $context->getQuery();
if (!$query instanceof QueryBuilder) {
// unsupported query
return;
}
$config = $context->getConfig();
if (null === $config) {
// only configured API resources are supported
return;
}
$context->setResult(
$this->loadNormalizedData($query, $config, $context->getNormalizationContext())
);
// data returned by the EntitySerializer are already normalized
$context->skipGroup(ApiActionGroup::NORMALIZE_DATA);
}
/**
* @inheritdoc
*/
public function process(ContextInterface $context)
{
/** @var ListContext $context */
if ($context->hasResult()) {
// data already retrieved
return;
}
$query = $context->getQuery();
if (!$query instanceof QueryBuilder) {
// unsupported query
return;
}
$config = $context->getConfig();
if (null === $config) {
// only configured API resources are supported
return;
}
$context->setResult(
$this->entitySerializer->serialize(
$query,
$config,
$context->getNormalizationContext()
)
);
// data returned by the EntitySerializer are already normalized
$context->skipGroup(ApiActionGroup::NORMALIZE_DATA);
}
/**
* @inheritdoc
*/
public function process(ContextInterface $context)
{
/** @var ListContext $context */
if ($context->hasResult()) {
// data already retrieved
return;
}
$query = $context->getQuery();
if (!$query instanceof QueryBuilder) {
// unsupported query
return;
}
$config = $context->getConfig();
if (null === $config) {
// only configured API resources are supported
return;
}
$context->setResult(
$this->entitySerializer->serialize(
$query,
$config,
$context->getNormalizationContext()
)
);
// data returned by the EntitySerializer are already normalized
$context->skipGroup(ApiActionGroup::NORMALIZE_DATA);
}
/**
* @inheritdoc
*/
public function process(ContextInterface $context)
{
/** @var FormContext $context */
$model = $context->getResult();
if (!\is_object($model)) {
// a model does not exist
return;
}
$entityMapper = $context->getEntityMapper();
if (null === $entityMapper) {
// the entity mapper was not initialized
return;
}
$entityClass = $context->getClassName();
$config = $context->getConfig();
if (null !== $config) {
$parentResourceClass = $config->getParentResourceClass();
if ($parentResourceClass) {
$entityClass = $parentResourceClass;
}
}
$context->setResult(
$entityMapper->getEntity($model, $entityClass)
);
}
/**
* @inheritdoc
*/
public function process(ContextInterface $context)
{
/** @var FormContext $context */
$entity = $context->getResult();
if (!\is_object($entity)) {
// an entity does not exist
return;
}
$entityMapper = $context->getEntityMapper();
if (null === $entityMapper) {
// the entity mapper was not initialized
return;
}
$context->setResult(
$entityMapper->getModel($entity, $context->getClassName())
);
}
/**
* @inheritdoc
*/
public function process(ContextInterface $context)
{
/** @var MetadataContext $context */
if ($context->hasResult()) {
// metadata is already loaded
return;
}
$entityMetadata = null;
$entityClass = $context->getClassName();
$config = $context->getConfig();
if ($this->doctrineHelper->isManageableEntityClass($entityClass)) {
$entityMetadata = $this->entityMetadataLoader->loadEntityMetadata(
$entityClass,
$config,
$context->getWithExcludedProperties(),
$context->getTargetAction()
);
} else {
$entityMetadata = $this->objectMetadataLoader->loadObjectMetadata(
$entityClass,
$config,
$context->getWithExcludedProperties(),
$context->getTargetAction()
);
}
$this->associationMetadataLoader->completeAssociationMetadata($entityMetadata, $config, $context);
$context->setResult($entityMetadata);
}
/**
* @inheritdoc
*/
public function process(ContextInterface $context)
{
/** @var Context $context */
if (!$context->hasResult()) {
// result deleted or not supported
return;
}
$entityClass = $context->getManageableEntityClass($this->doctrineHelper);
if (!$entityClass) {
// only manageable entities or resources based on manageable entities are supported
return;
}
$deleteHandler = $this->deleteHandlerRegistry->getHandler($entityClass);
$this->processDelete($context->getResult(), $deleteHandler, $entityClass);
$context->removeResult();
}
/**
* @inheritdoc
*/
public function process(ContextInterface $context)
{
/** @var Context $context */
if (!$context->hasResult()) {
// result deleted or not supported
return;
}
$entityClass = $context->getManageableEntityClass($this->doctrineHelper);
if (!$entityClass) {
// only manageable entities or resources based on manageable entities are supported
return;
}
$deleteHandler = $this->deleteHandlerRegistry->getHandler($entityClass);
$this->processDelete($context->getResult(), $deleteHandler);
$context->removeResult();
}
/**
* @inheritdoc
*/
public function process(ContextInterface $context)
{
/** @var CollectResourcesContext $context */
$actionsConfig = [];
$version = $context->getVersion();
$resources = $context->getResult();
$requestType = $context->getRequestType();
/** @var ApiResource $resource */
foreach ($resources as $resource) {
$entityClass = $resource->getEntityClass();
$actions = $this->getActionsConfig($entityClass, $version, $requestType);
if (null !== $actions) {
$actionsConfig[$entityClass] = $actions;
$excludedActions = $this->getExcludedActions($actions);
if (!empty($excludedActions)) {
$resource->setExcludedActions($excludedActions);
}
}
}
$context->set(self::ACTIONS_CONFIG_KEY, $actionsConfig);
}
/**
* @inheritdoc
*/
public function process(ComponentContextInterface $context)
{
/** @var ByStepNormalizeResultContext $context */
if (!$context->getFirstGroup() || $context->getFirstGroup() !== $context->getLastGroup()) {
throw new \LogicException(\sprintf(
'Both the first and the last groups must be specified for the "%s" action'
. ' and these groups must be equal. First Group: "%s". Last Group: "%s".',
$this->getAction(),
$context->getFirstGroup(),
$context->getLastGroup()
));
}
$context->resetSkippedGroups();
$context->setSourceGroup(null);
$context->setFailedGroup(null);
parent::process($context);
}
/**
* @inheritdoc
*/
public function process(ComponentContextInterface $context)
{
/** @var ApiContext $context */
if (!$context->getFirstGroup() || $context->getFirstGroup() !== $context->getLastGroup()) {
throw new \LogicException(\sprintf(
'Both the first and the last groups must be specified for the "%s" action'
. ' and these groups must be equal. First Group: "%s". Last Group: "%s".',
$this->getAction(),
$context->getFirstGroup(),
$context->getLastGroup()
));
}
$context->resetSkippedGroups();
parent::process($context);
}
/**
* @inheritdoc
*/
public function process(ContextInterface $context)
{
/** @var BatchUpdateContext $context */
$data = $context->getResult();
if (null !== $data) {
// data were already loaded
return;
}
$context->setResult(
$this->loadData($context->getFile()->getFileName(), $context->getFileManager())
);
}
/**
* @inheritdoc
*/
public function process(ContextInterface $context)
{
/** @var BatchUpdateContext $context */
if ($context->isProcessed(self::OPERATION_NAME)) {
// included data were already added
return;
}
$includedData = $context->getIncludedData();
if (null === $includedData) {
// included data were not loaded
return;
}
$data = $context->getResult();
if (null === $data) {
// data were not loaded
return;
}
$usedIncludedItems = [];
$processedItemStatuses = $context->getProcessedItemStatuses();
foreach ($data as $itemIndex => $item) {
$includedItems = $this->getIncludedItems($item, $includedData, $usedIncludedItems);
if (null === $includedItems) {
$processedItemStatuses[$itemIndex] = BatchUpdateItemStatus::HAS_ERRORS;
} elseif ($includedItems) {
$includeAccessor = $includedData->getIncludeAccessor();
foreach ($includedItems as $includedItemIndex => $includedItem) {
$usedIncludedItems[$includedItemIndex] = true;
[$type, $id] = $includeAccessor->getItemIdentifier($includedItem);
$includedItemSectionName = $includedData->getIncludedItemSectionName($type, $id);
$data[$itemIndex][$includedItemSectionName][] = $includedItem;
}
}
}
$context->setResult($data);
$context->setProcessedItemStatuses($processedItemStatuses);
$context->setProcessed(self::OPERATION_NAME);
}
/**
* @inheritdoc
*/
public function process(ContextInterface $context)
{
/** @var GetSubresourceContext $context */
if ($context->hasResult()) {
// data already retrieved
return;
}
$operationId = $context->getParentId();
$operation = $this->doctrineHelper->getEntity(AsyncOperation::class, $operationId);
if (null === $operation) {
throw new NotFoundHttpException('The asynchronous operation does not exist.');
}
if (!$this->authorizationChecker->isGranted('VIEW', $operation)) {
throw new AccessDeniedException('No access to the asynchronous operation.');
}
$filterHelper = new FilterHelper($context->getFilters(), $context->getFilterValues());
$offset = $filterHelper->getPageNumber() > 1
? $filterHelper->getPageSize() * ($filterHelper->getPageNumber() - 1)
: 0;
$limit = $filterHelper->getPageSize();
$errors = $this->errorManager->readErrors($this->fileManager, $operationId, $offset, $limit);
$context->setResult($errors);
// set callback to be used to calculate total count
$context->setTotalCountCallback(function () use ($operationId) {
return $this->errorManager->getTotalErrorCount($this->fileManager, $operationId);
});
}