/**
  * @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);
 }

 /**
  * {@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);
     }
 }

 /**
  * {@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 createService(ServiceLocatorInterface $serviceLocator)
 {
     $entityManager = $serviceLocator->get('entity-manager');
     $languageEntity = $serviceLocator->get('lang-entity');
     $criteria = new Criteria();
     $criteria->where($criteria->expr()->gt('status', 0))->orderBy(['status' => Criteria::DESC]);
     $language = new \Application\Service\Invokable\Language();
     $languageClassName = get_class($languageEntity);
     $activeLanguages = $entityManager->getRepository($languageClassName)->matching($criteria);
     $language->setActiveLanguages($activeLanguages);
     $defaultLanguage = $entityManager->getRepository($languageClassName)->findOneByStatus(Lang::STATUS_DEFAULT);
     $defaultLanguage = $defaultLanguage ?: new Lang();
     $language->setDefaultLanguage($defaultLanguage);
     $request = $serviceLocator->get('Request');
     $router = $serviceLocator->get('Router');
     $match = $router->match($request);
     if ($match) {
         $matchedLangIso = $match->getParam('lang', $defaultLanguage->getIsoCode());
         if ($matchedLangIso) {
             $currentLanguage = $entityManager->getRepository($languageClassName)->findOneByIsoCode($matchedLangIso);
         }
     }
     $currentLanguage = isset($currentLanguage) ? $currentLanguage : new Lang();
     $language->setCurrentLanguage($currentLanguage);
     return $language;
 }

 public function findByTag($tagstring)
 {
     $criteria = new Criteria();
     $criteria->andWhere(Criteria::expr()->contains('t.name', "%" . $tagstring . "%"));
     $queryBuilder = $this->_em->createQueryBuilder()->select('p')->distinct(true)->from($this->getEntityName(), "p")->leftJoin('Product\\Entity\\ProductTags', 'pt', \Doctrine\ORM\Query\Expr\Join::WITH, 'p.id = pt.idProduct')->leftJoin('Product\\Entity\\Tags', 't', \Doctrine\ORM\Query\Expr\Join::WITH, 't.id = pt.idTag')->addCriteria($criteria)->orderBy("p.creationdate", "ASC")->getQuery();
     return $queryBuilder->getArrayResult();
 }

 public function testMatchingAcceptsCriteriaWithNullWhereExpression()
 {
     $repository = $this->dm->getRepository('Documents\\User');
     $criteria = new Criteria();
     $this->assertNull($criteria->getWhereExpression());
     $this->assertInstanceOf('Doctrine\\Common\\Collections\\Collection', $repository->matching($criteria));
 }

 protected function execute(InputInterface $input, OutputInterface $output)
 {
     $indexName = $input->getOption('index');
     $batchSize = $input->getOption('batch_size');
     $indexManager = $this->getIndexManager($indexName);
     $totalDocuments = $indexManager->getTotalEntities();
     $iterations = $this->getIterations($totalDocuments, $batchSize);
     $output->writeln(sprintf('<info>Reindexing</info> "%s"', $indexName));
     $output->writeln(sprintf('<comment>Total documents:</comment> %s', $totalDocuments));
     $output->writeln(sprintf('<comment>Batch size:</comment> %s', $batchSize));
     $output->writeln(sprintf('<comment>Iterations:</comment> %s', $iterations));
     $progress = new ProgressBar($output, $totalDocuments);
     $progress->setFormat('verbose');
     $progress->setRedrawFrequency($batchSize);
     $progress->start();
     $indexManager->purgeIndex();
     for ($i = 0; $i < $iterations; $i++) {
         $criteria = new Criteria();
         $criteria->setMaxResults($batchSize);
         $criteria->setFirstResult($i * $batchSize);
         $collection = $indexManager->getEntitiesCollection($criteria);
         $collection->map(function (EntityInterface $entity) use($indexManager, $progress) {
             $indexManager->addEntity($entity);
             $progress->advance();
         });
     }
     $progress->finish();
     $output->writeln('');
     $output->writeln(sprintf('<info>Optimizing "%s"</info>', $indexName));
     $indexManager->optimizeIndex();
 }

 /**
  * {@inheritdoc}
  */
 public function apply(Criteria $criteria, FilterValue $value = null)
 {
     $val = null !== $value ? $value->getValue() : $this->getDefaultValue();
     if (null !== $val) {
         $criteria->setMaxResults($val);
     }
 }

 /**
  * @param User $user
  * @param int $limit
  * @return Collection|Game[]
  */
 public function findAvailableForUser(User $user, $limit)
 {
     $criteria = new Criteria();
     $expr = Criteria::expr();
     $criteria->where($expr->neq('user1', $user))->andWhere($expr->isNull('user2'))->setMaxResults($limit)->orderBy(['id' => 'DESC']);
     return $this->matching($criteria);
 }

 public function testUsersWithFacebookLogin()
 {
     $criteria = new Criteria();
     $criteria->where($criteria->expr()->neq('facebook_id', null));
     $users = $this->getUserRepository()->matching($criteria);
     $this->assertCount(8, $users);
 }

 /**
  * Get items
  * @author Mohamed Labib <[email protected]>
  * 
  * @access public
  * 
  * @param int $offset
  * @param int $itemCountPerPage
  * @return array items queried
  */
 public function getItems($offset, $itemCountPerPage)
 {
     $this->setCriteria();
     $this->criteria->setFirstResult($offset);
     $this->criteria->setMaxResults($itemCountPerPage);
     return $this->query->filter($this->entityName, $this->criteria);
     //($pageNumber-1) for zero based count
 }

 /**
  * Finds operations
  *
  * @param Status $status status to filter upon
  * @param DateTime $date optional date to filter upon
  *
  * @return OperationInterface[]
  */
 public function findByStatusAndBeforeUpdatedAt(Status $status, DateTime $date)
 {
     $criteria = new Criteria();
     $exprBuilder = new ExpressionBuilder();
     $criteria->where($exprBuilder->eq('status', $status->getValue()));
     $criteria->andWhere($exprBuilder->lte('updatedAt', $date));
     return $this->matching($criteria)->toArray();
 }

 public function count(array $criteria)
 {
     $criteriaObj = new Criteria();
     foreach ($criteria as $field => $value) {
         $criteriaObj->where($criteriaObj->expr()->eq($field, $value));
     }
     return $this->repository->matching($criteriaObj)->count();
 }

 /**
  * @depends testUpdate
  */
 public function testFind()
 {
     $criteria = new Criteria();
     $expression = new ExpressionBuilder();
     $exp = $expression->eq('username', 'john');
     $criteria->where($exp);
     $this->assertEquals(1, count($this->getRepository(UserExtraEntity::class)->findBy($criteria)));
     $this->assertEquals(2, count($this->getRepository(UserExtraEntity::class)->findAll()));
 }

 /**
  * {@inheritdoc}
  */
 public function apply(Criteria $criteria, FilterValue $value = null)
 {
     $val = null !== $value ? $value->getValue() : $this->getDefaultValue();
     if (null !== $val) {
         $pageSize = $criteria->getMaxResults();
         if (null !== $pageSize) {
             $criteria->setFirstResult(QueryUtils::getPageOffset($val, $pageSize));
         }
     }
 }