/**
* @param Route $route
* @param RouteCollectionAccessor $routes
* @param string[] $entities
*
* @return string[] Entity requirements for the default controller
*/
protected function adjustRoutes(Route $route, RouteCollectionAccessor $routes, $entities)
{
$result = [];
$routeName = $routes->getName($route);
foreach ($entities as $className) {
$entity = $this->entityAliasResolver->getPluralAlias($className);
$result[] = $entity;
$result[] = $this->entityClassNameHelper->getUrlSafeClassName($className);
$existingRoute = $routes->getByPath(str_replace(self::ENTITY_PLACEHOLDER, $entity, $route->getPath()), $route->getMethods());
if ($existingRoute) {
// move existing route before the current route
$existingRouteName = $routes->getName($existingRoute);
$routes->remove($existingRouteName);
$routes->insert($existingRouteName, $existingRoute, $routeName, true);
//additional route for entities which has api, but it not recognize urls like
// /api/rest/latest/Oro_Bundle_AddressBundle_Entity_Country
//TODO: This should be removed in scope of https://magecore.atlassian.net/browse/BAP-8650
$dictionaryRoute = $routes->cloneRoute($existingRoute);
$dictionaryRoute->setPath(str_replace(self::ENTITY_PLACEHOLDER, $this->entityClassNameHelper->getUrlSafeClassName($className), $route->getPath()));
$routes->insert($routes->generateRouteName($existingRouteName), $dictionaryRoute, $existingRouteName, true);
} else {
// add an additional strict route based on the base route and current entity
$strictRoute = $routes->cloneRoute($route);
$strictRoute->setPath(str_replace(self::ENTITY_PLACEHOLDER, $entity, $strictRoute->getPath()));
$strictRoute->setDefault(self::ENTITY_ATTRIBUTE, $entity);
$routes->insert($routes->generateRouteName($routeName), $strictRoute, $routeName, true);
}
}
return $result;
}
/**
* {@inheritdoc}
*/
public function resolve(Route $route, RouteCollectionAccessor $routes)
{
if ($route->getOption('group') !== self::ROUTE_GROUP) {
return;
}
if ($this->hasAttribute($route, self::ACTIVITY_PLACEHOLDER)) {
$activities = array_map(function (ConfigInterface $config) {
// convert to entity alias
return $this->entityAliasResolver->getPluralAlias($config->getId()->getClassName());
}, $this->groupingConfigProvider->filter(function (ConfigInterface $config) {
// filter activity entities
$groups = $config->get('groups');
return !empty($groups) && in_array(ActivityScope::GROUP_ACTIVITY, $groups, true);
}));
if (!empty($activities)) {
$activities = $this->adjustRoutes($route, $routes, $activities);
if (!empty($activities)) {
$route->setRequirement(self::ACTIVITY_ATTRIBUTE, implode('|', $activities));
}
}
$this->completeRouteRequirements($route);
} elseif ($this->hasAttribute($route, self::ENTITY_PLACEHOLDER)) {
$this->completeRouteRequirements($route);
}
}
/**
* Get class alias of specified entity
*
* @param object $object
* @param bool $isPlural
*
* @return null|string
*/
public function getClassAlias($object, $isPlural = false)
{
if (!is_object($object)) {
return null;
}
$className = ClassUtils::getRealClass($object);
return $isPlural ? $this->entityAliasResolver->getPluralAlias($className) : $this->entityAliasResolver->getAlias($className);
}
/**
* {@inheritdoc}
*/
public function buildForm(FormBuilderInterface $builder, array $options)
{
if (!$this->isApplicable($options)) {
return;
}
$className = $options['data_class'];
$alias = $this->entityAliasResolver->getPluralAlias($className);
$builder->add('contexts', 'oro_activity_contexts_select', ['label' => 'oro.activity.contexts.label', 'tooltip' => 'oro.activity.contexts.tooltip', 'required' => false, 'read_only' => false, 'mapped' => false, 'configs' => ['route_name' => 'oro_activity_form_autocomplete_search', 'route_parameters' => ['activity' => $alias, 'name' => $alias]]]);
$builder->addEventListener(FormEvents::POST_SET_DATA, [$this, 'addDefaultContextListener']);
}
/**
* {@inheritdoc}
*/
public function reverseTransform($entityType, $throwException = true)
{
try {
return $this->entityAliasResolver->getClassByPluralAlias($entityType);
} catch (EntityAliasNotFoundException $e) {
if ($throwException) {
throw $e;
}
}
return null;
}
/**
* @param Tag $tag
*
* @return array ['' => [count], $alias => [count, icon, label, class => true]]
*/
public function getTagEntitiesStatistic(Tag $tag)
{
$groupedResult = $this->getGroupedTagEntities($tag);
return array_reduce($groupedResult, function ($result, array $entityResult) {
$result['']['count'] += $entityResult['cnt'];
$entityClass = $entityResult['entityClass'];
$alias = $this->entityAliasResolver->getAlias($entityClass);
$result[$alias] = ['count' => $entityResult['cnt'], 'icon' => $this->entityConfigProvider->getConfig($entityClass)->get('icon'), 'label' => $this->entityConfigProvider->getConfig($entityClass)->get('plural_label'), 'class' => true];
return $result;
}, ['' => ['count' => 0]]);
}
/**
* @return array [[entity plural alias, url safe class name], ...]
*/
protected function getSupportedEntities()
{
if (null === $this->supportedEntities) {
$entities = $this->dictionaryProvider->getSupportedEntityClasses();
$this->supportedEntities = [];
foreach ($entities as $className) {
$this->supportedEntities[] = [$this->entityAliasResolver->getPluralAlias($className), $this->entityClassNameHelper->getUrlSafeClassName($className)];
}
}
return $this->supportedEntities;
}
/**
* @return string[]
*/
protected function getSupportedActivities()
{
if (null === $this->supportedActivities) {
$this->supportedActivities = array_map(function (ConfigInterface $config) {
// convert to entity alias
return $this->entityAliasResolver->getPluralAlias($config->getId()->getClassName());
}, $this->groupingConfigProvider->filter(function (ConfigInterface $config) {
// filter activity entities
$groups = $config->get('groups');
return !empty($groups) && in_array(ActivityScope::GROUP_ACTIVITY, $groups, true);
}));
}
return $this->supportedActivities;
}
/**
* @return array [[entity class, entity plural alias], ...]
*/
protected function getSupportedEntities()
{
if (null === $this->supportedEntities) {
$resources = $this->resourcesLoader->getResources(Version::LATEST, [RequestType::REST, RequestType::JSON_API]);
$this->supportedEntities = [];
foreach ($resources as $resource) {
$className = $resource->getEntityClass();
$pluralAlias = $this->entityAliasResolver->getPluralAlias($className);
if (!empty($pluralAlias)) {
$this->supportedEntities[] = [$className, $pluralAlias];
}
}
}
return $this->supportedEntities;
}
/**
* @param int $expectedCallsOfGetAllMetadata
*/
protected function initialiseAliases($expectedCallsOfGetAllMetadata)
{
$this->metadataFactory->expects($this->exactly($expectedCallsOfGetAllMetadata))->method('getAllMetadata')->willReturn([new ClassMetadata('Test\\Entity1'), new ClassMetadata('Test\\Entity2')]);
$entityAliasProvider = $this->getMock('Oro\\Bundle\\EntityBundle\\Provider\\EntityAliasProviderInterface');
$entityAliasProvider->expects($this->any())->method('getEntityAlias')->willReturnMap([['Test\\Entity1', new EntityAlias('entity1_alias', 'entity1_plural_alias')], ['Test\\Entity2', new EntityAlias('entity2_alias', 'entity2_plural_alias')]]);
$this->entityAliasResolver->addProvider($entityAliasProvider);
}
/**
* @param Route $route
* @param RouteCollectionAccessor $routes
* @param string[] $entities
*/
protected function adjustRoutes(Route $route, RouteCollectionAccessor $routes, $entities)
{
$routeName = $routes->getName($route);
foreach ($entities as $className) {
$entity = $this->entityAliasResolver->getPluralAlias($className);
if (empty($entity)) {
continue;
}
$existingRoute = $routes->getByPath(str_replace(self::ENTITY_PLACEHOLDER, $entity, $route->getPath()), $route->getMethods());
if ($existingRoute) {
// move existing route before the current route
$existingRouteName = $routes->getName($existingRoute);
$routes->remove($existingRouteName);
$routes->insert($existingRouteName, $existingRoute, $routeName, true);
} else {
// add an additional strict route based on the base route and current entity
$strictRoute = $routes->cloneRoute($route);
$strictRoute->setPath(str_replace(self::ENTITY_PLACEHOLDER, $entity, $strictRoute->getPath()));
$strictRoute->setDefault(self::ENTITY_ATTRIBUTE, $entity);
$requirements = $strictRoute->getRequirements();
unset($requirements[self::ENTITY_ATTRIBUTE]);
$strictRoute->setRequirements($requirements);
if ($this->hasAttribute($route, self::ID_PLACEHOLDER)) {
$this->setIdRequirement($strictRoute, $className);
}
$routes->insert($routes->generateRouteName($routeName), $strictRoute, $routeName, true);
}
}
}
/**
* Returns the context for the given activity class and id
*
* @param string $class The FQCN of the activity entity
* @param $id
*
* @return array
*/
public function getActivityContext($class, $id)
{
$currentUser = $this->securityTokenStorage->getToken()->getUser();
$userClass = ClassUtils::getClass($currentUser);
$entity = $this->doctrineHelper->getEntity($class, $id);
$result = [];
if (!$entity || !$entity instanceof ActivityInterface) {
return $result;
}
$targets = $entity->getActivityTargetEntities();
$entityProvider = $this->configManager->getProvider('entity');
foreach ($targets as $target) {
$targetClass = ClassUtils::getClass($target);
$targetId = $target->getId();
if ($userClass === $targetClass && $currentUser->getId() === $targetId) {
continue;
}
$item = [];
$config = $entityProvider->getConfig($targetClass);
$safeClassName = $this->entityClassNameHelper->getUrlSafeClassName($targetClass);
$item = $this->prepareItemTitle($item, $targetClass, $target, $targetId);
$item['activityClassAlias'] = $this->entityAliasResolver->getPluralAlias($class);
$item['entityId'] = $id;
$item['targetId'] = $targetId;
$item['targetClassName'] = $safeClassName;
$item['icon'] = $config->get('icon');
$item['link'] = $this->getContextLink($targetClass, $targetId);
$item = $this->dispatchContextTitle($item, $targetClass);
$result[] = $item;
}
return $result;
}
/**
* {@inheritdoc}
*/
public function handle(ApiDoc $annotation, array $annotations, Route $route, \ReflectionMethod $method)
{
if ($route->getOption('group') !== DictionaryEntityRouteOptionsResolver::ROUTE_GROUP) {
return;
}
$pluralAlias = $route->getDefault(DictionaryEntityRouteOptionsResolver::ENTITY_ATTRIBUTE);
if (!$pluralAlias) {
return;
}
$className = $this->entityAliasResolver->getClassByPluralAlias($pluralAlias);
$pluralName = $this->entityClassNameProvider->getEntityClassPluralName($className);
if ($pluralName) {
$annotation->setDescription(strtr(static::DESCRIPTION_TEMPLATE, ['{plural_name}' => $pluralName]));
$annotation->setDocumentation(strtr(static::DOCUMENTATION_TEMPLATE, ['{plural_name}' => $pluralName]));
} else {
$annotation->setDescription(strtr(static::FALLBACK_DESCRIPTION_TEMPLATE, ['{class}' => $className]));
$annotation->setDocumentation(strtr(static::FALLBACK_DOCUMENTATION_TEMPLATE, ['{class}' => $className]));
}
}
/**
* Adjust query for tag-results-grid (tag search result grid)
* after datasource has been built
*
* @param BuildAfter $event
*/
public function onBuildAfter(BuildAfter $event)
{
$datagrid = $event->getDatagrid();
$datasource = $datagrid->getDatasource();
if ($datasource instanceof OrmDatasource) {
$parameters = $datagrid->getParameters();
$queryBuilder = $datasource->getQueryBuilder();
$this->securityProvider->applyAcl($queryBuilder, 'tt');
$queryBuilder->setParameter('tag', $parameters->get('tag_id', 0));
$from = $parameters->get('from', '');
if (strlen($from) > 0) {
try {
$entityClass = $this->entityAliasResolver->getClassByAlias($from);
$queryBuilder->andWhere('tt.entityName = :entityClass')->setParameter('entityClass', $entityClass);
} catch (EntityAliasNotFoundException $e) {
$queryBuilder->andWhere('1 = 0');
}
}
}
}
/**
* Returns the context for the given activity class and id
*
* @param string $class The FQCN of the activity entity
* @param $id
*
* @return array
*/
public function getActivityContext($class, $id)
{
$criteria = Criteria::create();
$criteria->andWhere(Criteria::expr()->eq('id', $id));
$currentUser = $this->securityTokenStorage->getToken()->getUser();
$userClass = ClassUtils::getClass($currentUser);
$queryBuilder = $this->activityManager->getActivityTargetsQueryBuilder($class, $criteria, null, null, null, null, function (QueryBuilder $qb, $targetEntityClass) use($currentUser, $userClass) {
if ($targetEntityClass === $userClass) {
// Exclude current user from result
$qb->andWhere($qb->expr()->neq(QueryUtils::getSelectExprByAlias($qb, 'entityId'), $currentUser->getId()));
}
});
if (null === $queryBuilder) {
return [];
}
$result = $queryBuilder->getQuery()->getResult();
if (empty($result)) {
return $result;
}
$entityProvider = $this->configManager->getProvider('entity');
foreach ($result as &$item) {
$config = $entityProvider->getConfig($item['entity']);
$metadata = $this->configManager->getEntityMetadata($item['entity']);
$safeClassName = $this->entityClassNameHelper->getUrlSafeClassName($item['entity']);
$link = null;
if ($metadata) {
$link = $this->router->generate($metadata->getRoute(), ['id' => $item['id']]);
} elseif ($link === null && ExtendHelper::isCustomEntity($item['entity'])) {
// Generate view link for the custom entity
$link = $this->router->generate('oro_entity_view', ['id' => $item['id'], 'entityName' => $safeClassName]);
}
$item['activityClassAlias'] = $this->entityAliasResolver->getPluralAlias($class);
$item['entityId'] = $id;
$item['targetId'] = $item['id'];
$item['targetClassName'] = $safeClassName;
$item['icon'] = $config->get('icon');
$item['link'] = $link;
unset($item['id'], $item['entity']);
}
return $result;
}
/**
* @dataProvider testOnBuildAfterDataProvider
*
* @param string $alias
* @param string|null $entityClass
* @param EntityAliasNotFoundException $exception
*/
public function testOnBuildAfter($alias, $entityClass = null, EntityAliasNotFoundException $exception = null)
{
$this->event->expects($this->once())->method('getDatagrid')->will($this->returnValue($this->datagrid));
$qb = $this->assertOrmDataSource();
$this->assertAclCall($qb);
$tagId = 100;
$this->parameters->expects($this->at(0))->method('get')->with('tag_id', 0)->will($this->returnValue($tagId));
$qb->expects($this->at(0))->method('setParameter')->with('tag', $tagId);
$this->parameters->expects($this->at(1))->method('get')->with('from', '')->will($this->returnValue($alias));
if (strlen($alias) > 0) {
$earMockBuilder = $this->entityAliasResolver->expects($this->once())->method('getClassByAlias')->with($alias);
if (null !== $entityClass) {
$earMockBuilder->willReturn($entityClass);
$qb->expects($this->at(1))->method('andWhere')->with('tt.entityName = :entityClass')->willReturn($qb);
$qb->expects($this->at(2))->method('setParameter')->with('entityClass', $entityClass);
} else {
$earMockBuilder->willThrowException($exception);
$qb->expects($this->at(1))->method('1 = 0');
}
}
$this->listener->onBuildAfter($this->event);
}
/**
* @param Route $route
* @param RouteCollectionAccessor $routes
* @param string[] $entities
*
* @return string[] The list of entities handled by the default controller
*/
protected function adjustRoutes(Route $route, RouteCollectionAccessor $routes, $entities)
{
$result = [];
$routeName = $routes->getName($route);
foreach ($entities as $className) {
$entity = $this->entityAliasResolver->getPluralAlias($className);
$existingRoute = $routes->getByPath(str_replace(self::ENTITY_PLACEHOLDER, $entity, $route->getPath()), $route->getMethods());
if ($existingRoute) {
// move existing route before the current route
$existingRouteName = $routes->getName($existingRoute);
$routes->remove($existingRouteName);
$routes->insert($existingRouteName, $existingRoute, $routeName, true);
} else {
// add an additional strict route based on the base route and current entity
$strictRoute = $routes->cloneRoute($route);
$strictRoute->setPath(str_replace(self::ENTITY_PLACEHOLDER, $entity, $strictRoute->getPath()));
$strictRoute->setDefault(self::ENTITY_ATTRIBUTE, $entity);
$routes->insert($routes->generateRouteName($routeName), $strictRoute, $routeName, true);
$result[] = $entity;
$result[] = $this->entityClassNameHelper->getUrlSafeClassName($className);
}
}
return $result;
}
/**
* Returns the context for the given activity class and id
*
* @param string $class The FQCN of the activity entity
* @param $id
*
* @return array
*/
public function getActivityContext($class, $id)
{
$currentUser = $this->securityTokenStorage->getToken()->getUser();
$userClass = ClassUtils::getClass($currentUser);
$entity = $this->doctrineHelper->getEntity($class, $id);
$result = [];
if (!$entity || !$entity instanceof ActivityInterface) {
return $result;
}
$targets = $entity->getActivityTargetEntities();
$entityProvider = $this->configManager->getProvider('entity');
foreach ($targets as $target) {
$targetClass = ClassUtils::getClass($target);
$targetId = $target->getId();
if ($userClass === $targetClass && $currentUser->getId() === $targetId) {
continue;
}
$item = [];
$config = $entityProvider->getConfig($targetClass);
$metadata = $this->configManager->getEntityMetadata($targetClass);
$safeClassName = $this->entityClassNameHelper->getUrlSafeClassName($targetClass);
$link = null;
if ($metadata) {
$link = $this->router->generate($metadata->getRoute(), ['id' => $targetId]);
} elseif ($link === null && ExtendHelper::isCustomEntity($targetClass)) {
// Generate view link for the custom entity
$link = $this->router->generate('oro_entity_view', ['id' => $targetId, 'entityName' => $safeClassName]);
}
if ($fields = $this->mapper->getEntityMapParameter($targetClass, 'title_fields')) {
$text = [];
foreach ($fields as $field) {
$text[] = $this->mapper->getFieldValue($target, $field);
}
$item['title'] = implode(' ', $text);
} else {
$item['title'] = $this->translator->trans('oro.entity.item', ['%id%' => $targetId]);
}
$item['activityClassAlias'] = $this->entityAliasResolver->getPluralAlias($class);
$item['entityId'] = $id;
$item['targetId'] = $targetId;
$item['targetClassName'] = $safeClassName;
$item['icon'] = $config->get('icon');
$item['link'] = $link;
$result[] = $item;
}
return $result;
}
/**
* @param string $entityClass
*
* @return string|null
*/
protected function getEntityResourceUri($entityClass)
{
$uri = null;
if ($this->entityAliasResolver->hasAlias($entityClass)) {
try {
$uri = $this->router->generate('oro_rest_api_cget', ['entity' => $this->entityAliasResolver->getPluralAlias($entityClass)]);
} catch (RoutingException $e) {
// ignore any exceptions
}
}
if ($uri) {
$baseUrl = $this->router->getContext()->getBaseUrl();
if ($baseUrl) {
$uri = substr($uri, strlen($baseUrl));
}
}
return $uri;
}
/**
* Returns the context for the given activity class and id
*
* @param string $class The FQCN of the activity entity
* @param $id
*
* @return array
*/
public function getActivityContext($class, $id)
{
$currentUser = $this->securityTokenStorage->getToken()->getUser();
$userClass = ClassUtils::getClass($currentUser);
$entity = $this->doctrineHelper->getEntity($class, $id);
$result = [];
if (!$entity || !$entity instanceof ActivityInterface) {
return $result;
}
$targets = $entity->getActivityTargetEntities();
$entityProvider = $this->configManager->getProvider('entity');
foreach ($targets as $target) {
$targetClass = ClassUtils::getClass($target);
$targetId = $target->getId();
if ($userClass === $targetClass && $currentUser->getId() === $targetId) {
continue;
}
$item = [];
$config = $entityProvider->getConfig($targetClass);
$safeClassName = $this->entityClassNameHelper->getUrlSafeClassName($targetClass);
if (!array_key_exists('title', $item) || !$item['title']) {
if ($fields = $this->mapper->getEntityMapParameter($targetClass, 'title_fields')) {
$text = [];
foreach ($fields as $field) {
$text[] = $this->mapper->getFieldValue($target, $field);
}
$item['title'] = implode(' ', $text);
} else {
$item['title'] = $this->translator->trans('oro.entity.item', ['%id%' => $targetId]);
}
}
$item['activityClassAlias'] = $this->entityAliasResolver->getPluralAlias($class);
$item['entityId'] = $id;
$item['targetId'] = $targetId;
$item['targetClassName'] = $safeClassName;
$item['icon'] = $config->get('icon');
$item['link'] = $this->getContextLink($targetClass, $targetId);
$event = new PrepareContextTitleEvent($item, $targetClass);
$this->dispatcher->dispatch(PrepareContextTitleEvent::EVENT_NAME, $event);
$item = $event->getItem();
$result[] = $item;
}
return $result;
}
/**
* {@inheritdoc}
*/
public function isIgnoredEntity($className)
{
return !$this->entityAliasResolver->hasAlias($className);
}
/**
* @param Route $route
*
* @return string|null
*/
protected function getEntityClass(Route $route)
{
$pluralAlias = $route->getDefault(RestRouteOptionsResolver::ENTITY_ATTRIBUTE);
return $pluralAlias ? $this->entityAliasResolver->getClassByPluralAlias($pluralAlias) : null;
}
/**
* Resolves the entity class name by entity alias
*
* @param string $entityAlias The alias or plural alias of the entity
* @param bool $isPluralAlias Determines whether the entity name may be a singular of plural alias
*
* @return string The FQCN of an entity
*/
protected function getEntityClassByAlias($entityAlias, $isPluralAlias)
{
return $isPluralAlias ? $this->entityAliasResolver->getClassByPluralAlias($entityAlias) : $this->entityAliasResolver->getClassByAlias($entityAlias);
}
/**
* {@inheritdoc}
*/
protected function normalizeValue($value)
{
return $this->entityAliasResolver->getClassByPluralAlias($value);
}
/**
* {@inheritdoc}
*/
public function reverseTransform($entityType)
{
return $this->entityAliasResolver->getClassByPluralAlias($entityType);
}
/**
* {@inheritdoc}
*/
public function warmUp($cacheDir)
{
$this->entityAliasResolver->warmUp($cacheDir);
}
