public function searchByContains(array $criteria, array $orderBy = null, $page = 0, $pageSize = PHP_INT_MAX)
{
if ($page < 0 || $pageSize < 1) {
throw new \Exception("Invalid page or pageSize: page must be >= 0 and pageSize must be > 0");
} else {
$criteriaObj = new Criteria();
$i = 0;
foreach ($criteria as $field => $value) {
if ($value == null) {
continue;
} else {
if ($i++ == 0) {
$criteriaObj->where($criteriaObj->expr()->contains($field, $value));
} else {
$criteriaObj->orWhere($criteriaObj->expr()->contains($field, $value));
}
}
}
if ($orderBy != null) {
$criteriaObj->orderBy($orderBy);
}
$total = $this->repository->matching($criteriaObj)->count();
$query = $this->repository->createQueryBuilder("q")->addCriteria($criteriaObj);
$items = $query->setFirstResult($page * $pageSize)->setMaxResults($pageSize)->getQuery()->getResult();
return ResponseUtils::createSearchResponse($total, $items, $page, $pageSize);
}
}
/**
* @param DataStructure\Sort $sorting
*
* @return void
*/
public function sort(DataStructure\Sort $sorting)
{
$sortings = [];
foreach ($sorting as $sortingEntity) {
if ($this->isExcludedProperty($sortingEntity->getProperty())) {
continue;
}
$sortings[$sortingEntity->getProperty()] = $sortingEntity instanceof DataStructure\Sort\Asc ? 'asc' : 'desc';
}
$this->criteria->orderBy($sortings);
}
/**
* @param Request $request
* @param FilterInterface $filter
* @param Criteria $criteria
* @param ClassMetadata $embedClassMeta
*
* @return null
*/
protected function applyFilter(Request $request, FilterInterface $filter, Criteria $criteria, ClassMetadata $embedClassMeta)
{
$properties = $filter->getRequestProperties($request);
if ($filter instanceof OrderFilter && !empty($properties)) {
$criteria->orderBy($properties);
return null;
}
if ($filter instanceof SearchFilter) {
foreach ($properties as $name => $propertie) {
if (in_array($name, $embedClassMeta->getIdentifier())) {
continue;
}
$expCriterial = Criteria::expr();
if ($embedClassMeta->hasAssociation($name)) {
$associationTargetClass = $embedClassMeta->getAssociationTargetClass($name);
$propertyResource = $this->resourceResolver->getResourceForEntity($associationTargetClass);
$propertyObj = $this->dataProviderChain->getItem($propertyResource, (int) $propertie['value'], true);
if ($propertyObj && $propertyResource instanceof ResourceInterface) {
$whereCriteria = $expCriterial->in($name, [$propertyObj]);
$criteria->where($whereCriteria);
}
} else {
if ($embedClassMeta->hasField($name)) {
$fieldMapping = $embedClassMeta->getFieldMapping($name);
$type = isset($fieldMapping['type']) ? $fieldMapping['type'] : null;
$value = isset($this->mappingFilterVar[$type]) ? filter_var($propertie['value'], $this->mappingFilterVar[$type]) : $propertie['value'];
$whereCriteria = isset($propertie['precision']) && $propertie['precision'] === 'exact' ? $expCriterial->eq($name, $value) : $expCriterial->contains($name, $propertie['value']);
$criteria->where($whereCriteria);
}
}
}
}
}
private function createCriteria()
{
$criteria = new Criteria();
$criteria->orderBy(array('username' => 'ASC'));
$criteria->setFirstResult(2);
$criteria->setMaxResults(3);
return $criteria;
}
protected function generateMenu()
{
$criteria = new Criteria();
$criteria->orderBy(['hierarchy' => 'asc']);
$collection = $this->adminMenuRepository->matching($criteria);
$elements = $this->filterElements($collection, null);
$tree = $this->generateTree($collection, $elements);
return $tree;
}
/**
* {@inheritdoc}
*/
public function apply(Criteria $criteria, FilterValue $value = null)
{
$val = null !== $value ? $value->getValue() : $this->getDefaultValue();
if (!empty($val)) {
$criteria->orderBy($val);
}
}
/**
* Gets emails by ids
*
* @param int[] $ids
*
* @return Email[]
*/
public function findEmailsByIds($ids)
{
$queryBuilder = $this->createQueryBuilder('e');
$criteria = new Criteria();
$criteria->where(Criteria::expr()->in('id', $ids));
$criteria->orderBy(['sentAt' => Criteria::DESC]);
$queryBuilder->addCriteria($criteria);
$result = $queryBuilder->getQuery()->getResult();
return $result;
}
public function getMenu()
{
$criteria = new Criteria();
$criteria->orderBy(['hierarchy' => 'asc']);
$criteria->andWhere($criteria->expr()->eq('parent', null));
return $this->adminMenuRepository->matching($criteria);
}
/**
* Sort data
* @param Sorting $sorting
* @return static
*/
public function sort(Sorting $sorting)
{
if (is_callable($sorting->getSortCallback())) {
call_user_func($sorting->getSortCallback(), $this->criteria, $sorting->getSort());
return $this;
}
if ($sort = $sorting->getSort()) {
$this->criteria->orderBy($sort);
return $this;
}
$this->criteria->orderBy([$this->primary_key => 'ASC']);
return $this;
}
/**
* {@inheritdoc}
*/
public function load(ObjectManager $manager)
{
$criteria = new Criteria();
$criteria->where($criteria->expr()->neq('xThreadId', null));
/** @var QueryBuilder $threadQueryBuilder */
$threadQueryBuilder = $manager->getRepository('OroEmailBundle:Email')->createQueryBuilder('entity');
$threadQueryBuilder->distinct()->select('entity.xThreadId');
$threadQueryBuilder->addCriteria($criteria);
$iterator = new BufferedQueryResultIterator($threadQueryBuilder);
$iterator->setBufferSize(self::BATCH_SIZE);
$itemsCount = 0;
$entities = [];
foreach ($iterator as $threadResult) {
$threadId = $threadResult['xThreadId'];
/** @var QueryBuilder $queryBuilder */
$queryBuilder = $manager->getRepository('OroEmailBundle:Email')->createQueryBuilder('entity');
$criteria = new Criteria();
$criteria->where($criteria->expr()->eq('xThreadId', $threadId));
$criteria->orderBy(['created' => 'ASC']);
$queryBuilder->addCriteria($criteria);
$queryBuilder->setFirstResult(0);
$emails = $queryBuilder->getQuery()->execute();
if (count($emails) > 1) {
$itemsCount++;
$newThread = new EmailThread();
$manager->persist($newThread);
foreach ($emails as $key => $email) {
/** @var Email $email */
if ($key == 0) {
$email->setHead(true);
} else {
$email->setHead(false);
}
$email->setThread($newThread);
$entities[] = $email;
}
} elseif (count($emails) == 1) {
$email = $emails[0];
$email->setHead(true);
$itemsCount++;
$entities[] = $email;
}
if (0 == $itemsCount % self::BATCH_SIZE) {
$this->saveEntities($manager, $entities);
$entities = [];
}
}
if ($itemsCount % self::BATCH_SIZE > 0) {
$this->saveEntities($manager, $entities);
}
}
public function __invoke(Criteria $criteria)
{
if (!$this->getController() instanceof AbstractController) {
throw new \LogicException('Cannot locate the controller');
}
$sort = $this->getController()->params()->fromQuery('sorting');
if ($sort) {
$fields = explode(',', $sort);
$orderBy = [];
foreach ($fields as $field) {
$parts = explode(':', $field);
// Ignore it
if (count($parts) != 2) {
continue;
}
$orderBy[$parts[0]] = $parts[1];
}
$criteria->orderBy($orderBy);
}
}
public function testOrderings()
{
$criteria = new Criteria();
$criteria->orderBy(array("foo" => "ASC"));
$this->assertEquals(array("foo" => "ASC"), $criteria->getOrderings());
}
/**
* Returns the collection of producers for given identifiers
*
* @param array $identifiers
*
* @return \Doctrine\Common\Collections\Collection
*/
protected function getProducerCollection(array $identifiers = [])
{
$criteria = new Criteria();
$criteria->orderBy(['id' => 'asc']);
$criteria->where($criteria->expr()->in('id', $identifiers));
return $this->producerRepository->matching($criteria);
}
/**
* Process order
*
* @param Criteria $criteria
* @param RequestInterface $request
*/
protected function processOrder(Criteria $criteria, RequestInterface $request)
{
$criteria->orderBy($request->getOrder());
}
/**
* {@inheritdoc}
*/
public function getShippingMethods() : Collection
{
$criteria = new Criteria();
$criteria->where($criteria->expr()->eq('enabled', true));
$criteria->orderBy(['hierarchy' => 'asc']);
$methods = $this->matching($criteria)->filter(function (ShippingMethodInterface $shippingMethod) {
$paymentMethodsCount = $shippingMethod->getPaymentMethods()->count();
$shippingMethodCostCount = $shippingMethod->getCosts()->count();
return $paymentMethodsCount > 0 && $shippingMethodCostCount > 0;
});
return $methods;
}
public function testAddCriteriaOrder()
{
$qb = $this->_em->createQueryBuilder();
$criteria = new Criteria();
$criteria->orderBy(array('field' => Criteria::DESC));
$qb->addCriteria($criteria);
$this->assertCount(1, $orderBy = $qb->getDQLPart('orderBy'));
$this->assertEquals('field DESC', (string) $orderBy[0]);
}
/**
* Get emails in thread of current one
*
* @param EntityManager $entityManager
* @param Email $entity
*
* @return Email[]
*/
public function getThreadEmails(EntityManager $entityManager, Email $entity)
{
$thread = $entity->getThread();
if ($thread) {
/** @var QueryBuilder $queryBuilder */
$queryBuilder = $entityManager->getRepository('OroEmailBundle:Email')->createQueryBuilder('e');
$criteria = new Criteria();
$criteria->where($criteria->expr()->eq('thread', $thread));
$criteria->orderBy(['sentAt' => Criteria::DESC]);
$queryBuilder->addCriteria($criteria);
$result = $queryBuilder->getQuery()->getResult();
} else {
$result = [$entity];
}
return $result;
}
/**
* Sort existing value collection utility.
*
* @param Collection $values
* @param string $sortKey
* @return Collection
*/
public static function sort(Collection $values, $sortKey)
{
$criteria = new Criteria();
switch ($sortKey) {
case self::BY_ALPHA_ASC:
$criteria->orderBy(array('value' => Criteria::ASC));
break;
case self::BY_ALPHA_DESC:
$criteria->orderBy(array('value' => Criteria::DESC));
break;
case self::BY_ID_ASC:
$criteria->orderBy(array('id' => Criteria::ASC));
break;
case self::BY_ID_DESC:
$criteria->orderBy(array('id' => Criteria::DESC));
break;
case self::BY_NUMBER:
default:
$criteria->orderBy(array('order' => Criteria::ASC));
break;
}
return $values->matching($criteria);
}
/**
* @Template("Event/sidebarEvents.html.twig")
* @return type
*/
public function sidebarEventsAction()
{
$em = $this->getDoctrine()->getManager();
$eventRepository = $em->getRepository("TruckeeMatchBundle:Event");
// $user = $this->getUser();
$criteria = new Criteria();
$criteria->where($criteria->expr()->gte('eventdate', new \DateTime()));
$criteria->orderBy(['eventdate' => 'ASC']);
$criteria->setMaxResults(5);
$templates[] = 'Event/hr.html.twig';
if (!empty($eventRepository)) {
return array('templates' => $templates, 'events' => $eventRepository->matching($criteria));
} else {
return array('templates' => $templates);
}
}
public function searchClients(array $criteria, array $orderBy = null, $page = 0, $pageSize = 10)
{
$params = new ClientSearch($criteria);
$criteriaObj = new Criteria();
if ($params->getApprovedforbusiness()) {
$criteriaObj->andWhere($criteriaObj->expr()->eq('approvedforbusiness', 1));
}
if ($params->getClientcode() != null) {
$criteriaObj->andWhere($criteriaObj->expr()->contains('clientcode', $params->getClientcode()));
}
if ($params->getSearchtext() != null) {
$criteriaObj->andWhere($criteriaObj->expr()->orX($criteriaObj->expr()->contains('name', $params->getSearchtext()), $criteriaObj->expr()->contains('address', $params->getSearchtext()), $criteriaObj->expr()->contains('postcode', $params->getSearchtext())));
}
if ($orderBy != null) {
$criteriaObj->orderBy($orderBy);
}
return $this->clientsRepo->searchByCriteria($criteriaObj, $page, $pageSize);
}
/**
* @param array $orderings
* @return $this
*/
public function orderBy(array $orderings)
{
$this->criteria->orderBy($orderings);
return $this;
}
/**
* Initialize mocks for Doctrine
*
* @param array $managersToMock List of managers to be mocked
*
* @return void
*/
protected function initDatabaseMock($managersToMock)
{
if (is_null($this->mockedManager)) {
$test = $this;
foreach ($managersToMock as $manager) {
$entityName = $manager['entityName'];
// EntityManager mock
$entityManagerMock = new \mock\Doctrine\ORM\EntityManager();
// ClassMetadata mock
$classMetadata = new \mock\Doctrine\ORM\Mapping\ClassMetadata($entityName);
$entityClassName = $manager['entityClassName'];
$this->calling($classMetadata)->getName = function () use($entityClassName) {
return $entityClassName;
};
// EntityRepository mock
$entityRepositoryMock = new \mock\Doctrine\ORM\EntityRepository($entityManagerMock, $classMetadata);
$this->calling($entityRepositoryMock)->find = function ($id) use($test, $entityName) {
if (!empty($test->database[$entityName]) && array_key_exists($id, $test->database[$entityName])) {
return clone $test->database[$entityName][$id];
}
return null;
};
$this->calling($entityRepositoryMock)->findBy = function ($criteria = [], $sort = null, $limit = null, $start = 0) use($test, $entityName) {
$entities = new ArrayCollection($test->database[$entityName]);
$crit = new Criteria();
foreach ($criteria as $field => $value) {
$crit->andWhere($crit->expr()->eq($field, $value));
}
if (!is_null($sort)) {
$crit->orderBy($sort);
}
$crit->setFirstResult($start);
$crit->setMaxResults($limit);
return $entities->matching($crit)->map(function ($item) {
return clone $item;
});
};
// Overload main EntityManager functions
$this->calling($entityManagerMock)->getRepository = function () use($entityRepositoryMock) {
return $entityRepositoryMock;
};
$this->calling($entityManagerMock)->getClassMetadata = function ($entity) use($classMetadata) {
return $classMetadata;
};
$this->calling($entityManagerMock)->persist = function ($entity) use($test, $entityName) {
if (!$entity->getId()) {
if (!empty($test->database[$entityName])) {
$entity->setId(count($test->database[$entityName]) + 1);
} else {
$entity->setId(1);
}
}
$test->database[$entityName][$entity->getId()] = $entity;
return true;
};
$this->calling($entityManagerMock)->remove = function ($entity) use($test, $entityName) {
if (!$entity->getId() || empty($test->database[$entityName][$entity->getId()])) {
return false;
}
unset($test->database[$entityName][$entity->getId()]);
return true;
};
$mockClass = '\\mock' . $manager['className'];
$managerMock = new $mockClass($entityManagerMock, $entityName);
$this->mockedManager[$manager['serviceName']] = $managerMock;
}
}
}
public function testAddCriteriaOrder()
{
$qb = $this->_em->createQueryBuilder();
$qb->select('u')->from('Doctrine\\Tests\\Models\\CMS\\CmsUser', 'u');
$criteria = new Criteria();
$criteria->orderBy(array('field' => Criteria::DESC));
$qb->addCriteria($criteria);
$this->assertCount(1, $orderBy = $qb->getDQLPart('orderBy'));
$this->assertEquals('u.field DESC', (string) $orderBy[0]);
}
public function findAllPublicWithQuery($query, $page, $itemPerPage)
{
$publicCriteria = new Criteria();
$publicCriteria->where($publicCriteria->expr()->eq('r.published', true));
$queryCriteria = new Criteria();
$queryCriteria->where($queryCriteria->expr()->contains('r.title', $query));
$queryCriteria->orWhere($queryCriteria->expr()->contains('r.content', $query));
$orderCriteria = new Criteria();
$orderCriteria->orderBy(['r.dateUpdated' => 'DESC']);
/** @var QueryBuilder $queryBuilder */
$queryBuilder = $this->objectRepository->createQueryBuilder('r');
$queryBuilder->addCriteria($publicCriteria);
$queryBuilder->addCriteria($queryCriteria);
$queryBuilder->addCriteria($orderCriteria);
$queryBuilder->setFirstResult(($page - 1) * $itemPerPage);
$queryBuilder->setMaxResults($itemPerPage);
return new Paginator($queryBuilder);
}
