/**
* @dataProvider applyTestCases
*
* @param mixed $from
* @param string $expectedQuery
*/
public function testApply($from, $expectedQuery)
{
$query = new Query();
$query->from($from);
$this->aclHelper->apply($query);
$this->assertEquals($expectedQuery, $query->getStringQuery());
}
public function testWhere()
{
$query = new Query();
$query->setMappingConfig($this->config);
$query->from('Oro\\Bundle\\DataBundle\\Entity\\Product');
$query->where('or', 'all_data', '=', 'test', 'string');
$queryParams = $query->getOptions();
$this->assertEquals('or', $queryParams[0]['type']);
$this->assertEquals('all_data', $queryParams[0]['fieldName']);
}
public function testEvent()
{
$query = new Query();
$event = new BeforeSearchEvent($query);
$this->assertEquals($query, $event->getQuery());
$anotherQuery = new Query();
$anotherQuery->from('test');
$event->setQuery($anotherQuery);
$this->assertEquals($anotherQuery, $event->getQuery());
}
public function testWhere()
{
$query = new Query();
$query->setMappingConfig($this->config);
$query->from('Oro\\Bundle\\DataBundle\\Entity\\Product');
$query->where('or', 'all_data', '=', 'test', 'string');
$whereExpression = $query->getCriteria()->getWhereExpression();
$this->assertEquals('string.all_data', $whereExpression->getField());
$this->assertEquals(Comparison::EQ, $whereExpression->getOperator());
$this->assertEquals('test', $whereExpression->getValue()->getValue());
}
public function testBeforeSearchEvent()
{
$query = new Query();
$query->from('testEntity')->andWhere('name', '~', 'string');
$this->securityFacade->expects($this->once())->method('getOrganizationId')->will($this->returnValue(5));
$event = new BeforeSearchEvent($query);
$this->listener->beforeSearchEvent($event);
$wherePart = $query->getOptions();
$this->assertCount(2, $wherePart);
$expexted = ['fieldName' => 'organization', 'condition' => 'in', 'fieldValue' => [5, 0], 'fieldType' => 'integer', 'type' => 'and'];
$this->assertEquals($expexted, $wherePart[1]);
}
/**
* Applies ACL conditions to the search query
*
* @param Query $query
* @param string $permission
*
* @return Query
*/
public function apply(Query $query, $permission = 'VIEW')
{
$queryFromEntities = $query->getFrom();
// in query, from record !== '*'
if ($queryFromEntities[0] === '*') {
$queryFromEntities = $this->mappingProvider->getEntitiesListAliases();
}
$allowedAliases = [];
$ownerExpressions = [];
$expr = $query->getCriteria()->expr();
if (!empty($queryFromEntities)) {
foreach ($queryFromEntities as $entityAlias) {
$className = $this->mappingProvider->getEntityClass($entityAlias);
if ($className) {
$ownerField = sprintf('%s_owner', $entityAlias);
$condition = $this->ownershipDataBuilder->getAclConditionData($className, $permission);
if (count($condition) === 0 || !($condition[0] === null && $condition[3] === null)) {
$allowedAliases[] = $entityAlias;
// in case if we should not limit data for entity
if (count($condition) === 0 || $condition[1] === null) {
$ownerExpressions[] = $expr->gte('integer.' . $ownerField, SearchListener::EMPTY_OWNER_ID);
continue;
}
$owners = [SearchListener::EMPTY_OWNER_ID];
if (!empty($condition[1])) {
$owners = $condition[1];
if (is_array($owners) && count($owners) === 1) {
$owners = $owners[0];
}
}
if (is_array($owners)) {
$ownerExpressions[] = $expr->in('integer.' . $ownerField, $owners);
} else {
$ownerExpressions[] = $expr->eq('integer.' . $ownerField, $owners);
}
}
}
}
}
if (!empty($ownerExpressions)) {
$query->getCriteria()->andWhere(new CompositeExpression(CompositeExpression::TYPE_OR, $ownerExpressions));
}
$query->from($allowedAliases);
$this->addOrganizationLimits($query, $expr);
return $query;
}
/**
* Parse from statement of expression and fills Query's from.
*/
protected function parseFromExpression()
{
$this->stream->expect(Token::KEYWORD_TYPE, Query::KEYWORD_FROM);
switch (true) {
// if got string token after "from" - pass it directly into Query
case true === $this->stream->current->test(Token::STRING_TYPE):
$this->query->from($this->stream->current->value);
$this->stream->next();
break;
// if got operator (only '*' is supported in from statement)
// if got operator (only '*' is supported in from statement)
case true === $this->stream->current->test(Token::OPERATOR_TYPE, '*'):
$this->query->from(['*']);
$this->stream->next();
break;
// if got opening bracket (punctuation '(') - collect all arguments
// if got opening bracket (punctuation '(') - collect all arguments
case true === $this->stream->current->test(Token::PUNCTUATION_TYPE, '('):
$this->query->from($this->parseArguments());
break;
default:
throw new ExpressionSyntaxError(sprintf('Wrong "from" statement of the expression.'), $this->stream->current->cursor);
}
}
/**
* Apply special behavior of class inheritance processing
*
* @param Query $query
*/
protected function applyModesBehavior(Query $query)
{
// process abstract indexes
// make hashes increasing performance
$fromParts = (array) $query->getFrom();
$fromHash = array_combine($fromParts, $fromParts);
$aliases = $this->mapper->getEntitiesListAliases();
$aliasesHash = array_flip($aliases);
if (!isset($fromHash['*'])) {
foreach ($fromParts as $part) {
$entityName = $part;
$isAlias = false;
if (isset($aliasesHash[$part])) {
// find real name by alias
$entityName = $aliasesHash[$part];
$isAlias = true;
}
$mode = $this->mapper->getEntityModeConfig($entityName);
$descendants = $this->mapper->getRegisteredDescendants($entityName);
if (false !== $descendants) {
// add descendants to from clause
foreach ($descendants as $fromPart) {
if ($isAlias) {
$fromPart = $aliases[$fromPart];
}
if (!isset($fromHash[$fromPart])) {
$fromHash[$fromPart] = $fromPart;
}
}
}
if ($mode === Mode::ONLY_DESCENDANTS) {
unset($fromHash[$part]);
}
}
}
$collectedParts = array_values($fromHash);
if ($collectedParts !== $fromParts) {
$query->from($collectedParts);
}
}
/**
* Ensure that items loaded to search index
*
* @throws \LogicException
*/
protected function ensureItemsLoaded()
{
$query = new Query();
$query->from('oro_test_item');
$requestCounts = 20;
do {
$result = $this->container->get('oro_search.search.engine')->search($query);
$isLoaded = $result->getRecordsCount() == self::COUNT;
if (!$isLoaded) {
$requestCounts++;
sleep(1);
}
} while (!$isLoaded && $requestCounts > 0);
if (!$isLoaded) {
throw new \LogicException('Search items are not loaded');
}
}
/**
* Apply ACL to search Query.
* Removes all entities of the request to which the user has no access
*
* @param Query $query
*/
protected function applyAclToQuery(Query $query)
{
$allowedEntities = $this->getAllowedEntitiesListAliases();
$queryFromEntities = $query->getFrom();
$entitiesList = array_values($allowedEntities);
// in query, from record !== '*'
if (!empty($queryFromEntities) && $queryFromEntities[0] !== '*') {
foreach ($queryFromEntities as $key => $fromEntityAlias) {
if (!in_array($fromEntityAlias, $entitiesList)) {
unset($queryFromEntities[$key]);
}
}
$query->from($queryFromEntities);
} else {
$query->from($allowedEntities);
}
}
/**
* Parse from statement
*
* @param Query $query
* @param string $inputString
*
* @return string
*/
private function from(Query $query, $inputString)
{
if (substr($inputString, 0, 1) == '(') {
$fromString = $this->getWord($inputString, ')');
$inputString = $this->trimString($inputString, $fromString . ')');
$fromString = str_replace(array('(', ')'), '', $fromString);
$query->from(explode(', ', $fromString));
} else {
$from = $this->getWord($inputString);
$inputString = $this->trimString($inputString, $from);
$query->from($from);
}
return $inputString;
}
