/**
* 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;
}
/**
* Add "WHERE" parameter
*
* @deprecated Since 1.8 use criteria to add conditions
*
* @param string $keyWord
* @param string $fieldName
* @param string $condition
* @param string $fieldValue
* @param string $fieldType
*
* @return Query
*/
public function where($keyWord, $fieldName, $condition, $fieldValue, $fieldType = self::TYPE_TEXT)
{
$expr = Criteria::expr();
$fieldName = Criteria::implodeFieldTypeName($fieldType, $fieldName);
switch ($condition) {
case self::OPERATOR_CONTAINS:
$expr = $expr->contains($fieldName, $fieldValue);
break;
case self::OPERATOR_NOT_CONTAINS:
$expr = $expr->notContains($fieldName, $fieldValue);
break;
case self::OPERATOR_EQUALS:
$expr = $expr->eq($fieldName, $fieldValue);
break;
case self::OPERATOR_NOT_EQUALS:
$expr = $expr->neq($fieldName, $fieldValue);
break;
case self::OPERATOR_GREATER_THAN:
$expr = $expr->gt($fieldName, $fieldValue);
break;
case self::OPERATOR_GREATER_THAN_EQUALS:
$expr = $expr->gte($fieldName, $fieldValue);
break;
case self::OPERATOR_LESS_THAN:
$expr = $expr->lt($fieldName, $fieldValue);
break;
case self::OPERATOR_LESS_THAN_EQUALS:
$expr = $expr->lte($fieldName, $fieldValue);
break;
case self::OPERATOR_IN:
$expr = $expr->in($fieldName, $fieldValue);
break;
case self::OPERATOR_NOT_IN:
$expr = $expr->notIn($fieldName, $fieldValue);
break;
default:
throw new ExpressionSyntaxError(sprintf('Unsupported operator "%s"', $condition));
}
if ($keyWord === self::KEYWORD_AND) {
$this->criteria->andWhere($expr);
} else {
$this->criteria->orWhere($expr);
}
return $this;
}
/**
* @return \Doctrine\Common\Collections\ExpressionBuilder|mixed
*/
protected function parseCompositeCondition()
{
$expressions = [];
$this->stream->next();
while (!$this->stream->current->test(Token::PUNCTUATION_TYPE, ')')) {
$type = null;
if ($this->stream->current->test(Token::OPERATOR_TYPE)) {
$type = $this->stream->current->value;
}
list($typeX, $expression) = $this->parseSimpleCondition($type);
$expressions[] = ['type' => $typeX, 'expr' => $expression];
}
$expr = Criteria::expr();
if ($expressions) {
$expressions = array_reverse($expressions);
$typeX = $expressions[0]['type'];
$expressions = array_map(function ($item) use($typeX, $expressions) {
if ($item['type'] !== $typeX && $item != end($expressions)) {
throw new ExpressionSyntaxError(sprintf('Syntax error. Composite operators of different types are not allowed on single level.'), $this->stream->current->cursor);
}
return $item['expr'];
}, $expressions);
$expr = call_user_func_array([$expr, str_replace('Where', 'X', $typeX)], $expressions);
} else {
throw new ExpressionSyntaxError(sprintf('Syntax error in composite expression.'), $this->stream->current->cursor);
}
$this->stream->next();
return $expr;
}
