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); }