/**
* @dataProvider dataLiteral
*
* @param mixed $input
* @param string|null $type
*/
public function testLiteral($input, $type)
{
/** @var \OC\DB\QueryBuilder\Literal $actual */
$actual = $this->expressionBuilder->literal($input, $type);
$this->assertInstanceOf('\\OC\\DB\\QueryBuilder\\Literal', $actual);
$this->assertEquals($this->doctrineExpressionBuilder->literal($input, $type), $actual->__toString());
}
/**
* {@inheritdoc}
*/
protected function doWalkComparison($fieldName, $operator, $placeholder)
{
switch ($operator) {
case Comparison::IN:
return $this->expr->in($fieldName, $placeholder);
case Comparison::NIN:
return $this->expr->notIn($fieldName, $placeholder);
case Comparison::EQ:
case Comparison::IS:
if ($placeholder === null) {
return $this->expr->isNull($fieldName);
}
return $this->expr->eq($fieldName, $placeholder);
case Comparison::NEQ:
if ($placeholder === null) {
return $this->expr->isNotNull($fieldName);
}
return $this->expr->neq($fieldName, $placeholder);
case Comparison::CONTAINS:
return $this->expr->like($fieldName, $placeholder);
default:
$operator = self::convertComparisonOperator($operator);
if ($operator) {
return $this->expr->comparison($fieldName, $operator, $placeholder);
}
throw new \RuntimeException("Unknown comparison operator: " . $operator);
}
}
/**
* Filter field with `LIKE`.
*
* @param string $filterName
* @param string $field
*/
protected function likeFilter($filterName, $field)
{
$info = $this->extract($filterName);
$info['values'] = explode(',', str_replace('*', '%', $info['values']));
foreach ($info['values'] as $value) {
if ($info['cond']) {
$expr = $this->expr->like($field, "'%{$value}%'");
} else {
$expr = $this->expr->notLike($field, "'%{$value}%'");
}
}
$this->builder->andWhere($expr);
$this->filters[$filterName] = $info;
}
/**
* Quotes a given input parameter.
*
* @param mixed $input The parameter to be quoted.
* @param string|null $type The type of the parameter.
*
* @return Literal
*/
public function literal($input, $type = null)
{
return new Literal($this->expressionBuilder->literal($input, $type));
}
/**
* Initializes a new <tt>ExpressionBuilder</tt>.
*
* @param \Doctrine\DBAL\Connection $connection DBAL Connection
*/
public function __construct(Connection $connection)
{
parent::__construct($connection);
$this->conn = $connection;
}
/**
* The default handler is the last to be run and handler simple value parsing.
*
* @param string $key
* @param string $value
* @param ExpressionBuilder $expr
*
* @return Filter
*/
public function defaultFilterHandler($key, $value, $expr)
{
$val = $this->parseValue($value);
$placeholder = $key . '_1';
$exprMethod = $val['operator'];
$filter = new Filter();
$filter->setKey($key);
$filter->setExpression($expr->andX($expr->{$exprMethod}($this->alias . $key, ":{$placeholder}")));
$filter->setParameters([$placeholder => $val['value']]);
return $filter;
}
/**
* Get list of entities for autopopulate fields.
*
* @param $type
* @param $filter
* @param $limit
* @param $start
*
* @return array
*/
public function getLookupResults($type, $filter = '', $limit = 10, $start = 0)
{
$results = [];
switch ($type) {
case 'companyfield':
case 'lead.company':
$expr = null;
if ('lead.company' === $type) {
$column = 'companyname';
$filterVal = $filter;
} else {
if (is_array($filter)) {
$column = $filter[0];
$filterVal = $filter[1];
} else {
$column = $filter;
}
}
$expr = new ExpressionBuilder($this->em->getConnection());
$composite = $expr->andX();
$composite->add($expr->like("comp.{$column}", ':filterVar'));
// Validate owner permissions
if (!$this->security->isGranted('lead:leads:viewother')) {
$composite->add($expr->orX($expr->andX($expr->isNull('comp.owner_id'), $expr->eq('comp.created_by', (int) $this->userHelper->getUser()->getId())), $expr->eq('comp.owner_id', (int) $this->userHelper->getUser()->getId())));
}
$results = $this->em->getRepository('MauticLeadBundle:Company')->getSimpleList($composite, ['filterVar' => $filterVal . '%'], $column);
break;
}
return $results;
}
/**
* @param $queryBuilder
* @param $expressionBuilder
*/
protected function addFilteredProperties(QueryBuilder &$queryBuilder, ExpressionBuilder $expressionBuilder)
{
if (!count($this->filteredProperties)) {
return;
}
foreach ($this->filteredProperties as $index => $filteredProperty) {
$property = 'm.' . $filteredProperty['membersPropertyFilter_property'];
$comparator = $filteredProperty['membersPropertyFilter_comparator'];
$value = $filteredProperty['membersPropertyFilter_value'];
switch ($comparator) {
case 'empty':
$queryBuilder->andWhere($expressionBuilder->orX($expressionBuilder->eq($property, ':property' . $index), $expressionBuilder->isNull($property)));
$value = '';
break;
case 'not empty':
$queryBuilder->andWhere($expressionBuilder->gt($property, ':property' . $index));
$value = '';
break;
default:
if (!method_exists($expressionBuilder, $comparator)) {
continue;
}
$queryBuilder->andWhere($expressionBuilder->{$comparator}($property, ':property' . $index));
break;
}
$queryBuilder->setParameter(':property' . $index, $value);
}
}
