public function findAll() { if (false === $this->authorizationService->isGranted('user.admin')) { throw new UnauthorizedException('Insufficient Permissions'); } return $this->objectRepository->findBy([], ['email' => 'ASC']); }
/** * {@inheritdoc} */ public function getSupportedMethods(ShippingSubjectInterface $subject) { $methods = []; foreach ($this->shippingMethodRepository->findBy(['enabled' => true]) as $shippingMethod) { if ($this->eligibilityChecker->isEligible($subject, $shippingMethod)) { $methods[] = $shippingMethod; } } return $methods; }
/** * @return array * @throws UnauthorizedException */ public function findAll() { if ($this->authorizationService->isGranted('recipe.admin')) { return $this->objectRepository->findBy([], ['dateUpdated' => 'DESC']); } if ($this->authorizationService->isGranted('recipe.manage')) { return $this->objectRepository->findBy(['author' => $this->authorizationService->getIdentity()], ['dateUpdated' => 'DESC']); } throw new UnauthorizedException('Insufficient Permission'); }
/** * @param GenericEvent $event */ public function onArchetypeUpdate(GenericEvent $event) { $archetype = $event->getSubject(); if (!$archetype instanceof ArchetypeInterface) { throw new UnexpectedTypeException($archetype, ArchetypeInterface::class); } $products = $this->productRepository->findBy(array('archetype' => $archetype)); foreach ($products as $product) { $this->builder->build($product); $this->productManager->persist($product); } }
/** * {@inheritdoc} */ public function fillBackorders(StockableInterface $stockable) { $onHand = $stockable->getOnHand(); if ($onHand <= 0) { return; } $units = $this->repository->findBy(array('stockable' => $stockable, 'inventoryState' => InventoryUnitInterface::STATE_BACKORDERED), array('createdAt' => 'ASC')); foreach ($units as $unit) { $unit->setInventoryState(InventoryUnitInterface::STATE_SOLD); if (--$onHand === 0) { break; } } $stockable->setOnHand($onHand); }
/** * Gets all zones * * @param string|null $scope * * @return array $zones */ protected function getZones($scope = null) { if (null === $scope) { return $this->repository->findAll(); } return $this->repository->findBy(array('scope' => $scope)); }
function it_should_index_entity(ManagerRegistry $registry, EntityManager $em, ObjectRepository $repo) { $repo->findBy([], ['id' => 'DESC'], 1, 2)->willReturn([1, 2, 3]); $em->getRepository('foo')->willReturn($repo); $registry->getManager(null)->willReturn($em); $this->setRegistry($registry); $this->index(1, 2, 'id', 'DESC')->shouldBe([1, 2, 3]); }
/** * Get current cart automatic coupons. * * @param CartInterface $cart Cart * * @returns CouponInterface[] Array of non applied coupons */ private function getNonAppliedAutomaticCoupons(CartInterface $cart) { $automaticCoupons = $this->couponRepository->findBy(['enforcement' => ElcodiCouponTypes::ENFORCEMENT_AUTOMATIC]); $loadedAutomaticCoupons = $this->cartCouponManager->getCoupons($cart); return array_udiff($automaticCoupons, $loadedAutomaticCoupons, function (CouponInterface $a, CouponInterface $b) { return $a->getId() != $b->getId(); }); }
function it_does_reverse_transform_identifiers_to_array_of_entities(ObjectRepository $repository, FakeEntity $entityOne, FakeEntity $entityTwo) { $value = array(1, 2); $entityOne->getId()->willReturn(1); $entityTwo->getId()->willReturn(2); $repository->findBy(array('id' => $value))->shouldBeCalled()->willReturn(array($entityOne, $entityTwo)); $this->reverseTransform($value)->shouldReturn(array($entityOne, $entityTwo)); }
/** * Method subscribed to PreCartLoad event * * Iterate over all automatic Coupons and check if they apply. * If any applies, it will be added to the Cart * * @param CartOnLoadEvent $event Event * * @return null */ public function tryAutomaticCoupons(CartOnLoadEvent $event) { $cart = $event->getCart(); if ($cart->getCartLines()->isEmpty()) { return null; } /** * @var CouponInterface[] $automaticCoupons */ $automaticCoupons = $this->couponRepository->findBy(['enforcement' => ElcodiCouponTypes::ENFORCEMENT_AUTOMATIC]); foreach ($automaticCoupons as $coupon) { try { $this->cartCouponManager->addCoupon($cart, $coupon); } catch (AbstractCouponException $e) { // Silently tries next coupon on controlled exception } } }
function it_returns_all_methods_eligible_for_given_subject(ObjectRepository $methodRepository, ShippingMethodEligibilityCheckerInterface $eligibilityChecker, ShippingSubjectInterface $subject, ShippingMethodInterface $method1, ShippingMethodInterface $method2, ShippingMethodInterface $method3) { $methods = [$method1, $method2, $method3]; $methodRepository->findBy(['enabled' => true])->shouldBeCalled()->willReturn($methods); $eligibilityChecker->isEligible($subject, $method1)->shouldBeCalled()->willReturn(true); $eligibilityChecker->isEligible($subject, $method2)->shouldBeCalled()->willReturn(true); $eligibilityChecker->isEligible($subject, $method3)->shouldBeCalled()->willReturn(false); $this->getSupportedMethods($subject)->shouldReturn([$method1, $method2]); }
function it_partially_fills_backordered_units_and_updates_stock_accordingly(StockableInterface $stockable, InventoryUnitInterface $inventoryUnit1, InventoryUnitInterface $inventoryUnit2, ObjectRepository $repository) { $stockable->getOnHand()->shouldBeCalled()->willReturn(5); $stockable->setOnHand(3)->shouldBeCalled(); $inventoryUnit1->setInventoryState(InventoryUnitInterface::STATE_SOLD)->shouldBeCalled(); $inventoryUnit2->setInventoryState(InventoryUnitInterface::STATE_SOLD)->shouldBeCalled(); $repository->findBy(['stockable' => $stockable, 'inventoryState' => InventoryUnitInterface::STATE_BACKORDERED], ['createdAt' => 'ASC'])->willReturn([$inventoryUnit1, $inventoryUnit2]); $this->fillBackorders($stockable); }
function it_schedules_owning_document_for_update_when_setting_element_by_key_in_the_collection(MongoDBODMUnitOfWork $uow, DocumentStub $document, ObjectRepository $repository, ClassMetadata $classMetadata, EntityStub $entity4, EntityStub $entity8, EntityStub $entity15, EntityStub $newEntity) { $classMetadata->getIdentifier()->willReturn(['id']); $repository->findBy(['id' => [4, 8, 15]])->willReturn([$entity4, $entity8, $entity15]); $uow->getDocumentState($document)->willReturn(MongoDBODMUnitOfWork::STATE_MANAGED); $uow->isScheduledForUpdate($document)->willReturn(false); $uow->scheduleForUpdate($document)->shouldBeCalled(); $this->setOwner($document); $this->set(2, $newEntity); }
/** * {@inheritDoc} */ public function getRoles(array $roleNames) { $key = implode($roleNames); if (isset($this->roleCache[$key])) { return $this->roleCache[$key]; } $roles = $this->objectRepository->findBy([$this->roleNameProperty => $roleNames]); // We allow more roles to be loaded than asked (although this should not happen because // role name should have a UNIQUE constraint in database... but just in case ;)) if (count($roles) >= count($roleNames)) { $this->roleCache[$key] = $roles; return $roles; } // We have roles that were asked but couldn't be found in database... problem! foreach ($roles as &$role) { $role = $role->getName(); } throw new RoleNotFoundException(sprintf('Some roles were asked but could not be loaded from database: %s', implode(', ', array_diff($roleNames, $roles)))); }
function it_updates_products_with_newer_attributes_added_to_their_archetypes(GenericEvent $event, ArchetypeInterface $archetype, ArchetypeBuilderInterface $builder, ObjectRepository $productRepository, ObjectManager $productManager, ProductInterface $productA, ProductInterface $productB) { $event->getSubject()->willReturn($archetype); $productRepository->findBy(array('archetype' => $archetype))->willReturn(array($productA, $productB)); $builder->build($productA)->shouldBeCalled(); $builder->build($productB)->shouldBeCalled(); $productManager->persist($productA)->shouldBeCalled(); $productManager->persist($productB)->shouldBeCalled(); $this->onArchetypeUpdate($event); }
/** * Here we read rules from DB and put them into an a form that BjyAuthorize's Controller.php understands * * @param string $type * * @return array */ public function getRules($type = self::TYPE_RESOURCE) { //read from object store a set of (role, controller, action) $result = $this->objectRepository->findBy(['type' => $type]); //transform to object BjyAuthorize will understand $rules = array(); foreach ($result as $key => $rule) { $role = $rule->getRole()->getRoleId(); $controller = $rule->getResource(); $action = $rule->getPrivileges(); if (!$action) { $rules[$controller]['roles'][] = $role; $rules[$controller]['controller'] = array($controller); } else { $rules[$controller . ':' . $action]['roles'][] = $role; $rules[$controller . ':' . $action]['controller'] = array($controller); $rules[$controller . ':' . $action]['action'] = explode(',', $action); } } return array_values($rules); }
/** * {@inheritDoc} */ public function getRouteCollectionForRequest(Request $request) { $url = $request->getPathInfo(); $collection = new RouteCollection(); /** @var $connection \Doctrine\DBAL\Connection */ $connection = $this->objectManager->getConnection(); try { $connection->connect(); } catch (\Exception $e) { return $collection; } if (!$connection->isConnected()) { return $collection; } $searchUrl = substr($url, -1) != '/' ? $url . '/' : $url; $params = array('path' => $searchUrl); try { $contentRoutes = $this->repository->findBy($params); } catch (\Doctrine\DBAL\DBALException $e) { return $collection; } if (empty($contentRoutes)) { return $collection; } $filterByLocale = function (ContentRouteInterface $var) use($request) { if ($request) { return $var->getLocale() == $request->getLocale(); } else { return true; } }; $tempContentRoutes = array_filter($contentRoutes, $filterByLocale); if (empty($tempContentRoutes)) { $tempContentRoutes = $contentRoutes; } foreach ($tempContentRoutes as $key => $contentRoute) { $viewStatus = $request ? $request->getSession()->get('_viewStatus', VersionableInterface::STATUS_PUBLISHED) : VersionableInterface::STATUS_PUBLISHED; $test = new \ReflectionClass($contentRoute->getClassType()); if ($viewStatus == VersionableInterface::STATUS_DRAFT && $test->implementsInterface(ResourceVersionInterface::class)) { continue; } elseif ($viewStatus == VersionableInterface::STATUS_PUBLISHED && $test->implementsInterface(VersionableInterface::class)) { continue; } /** @var \Networking\InitCmsBundle\Model\ContentRouteInterface $contentRoute */ $content = $this->getRouteContent($contentRoute); $collection->add(sprintf('%s/%s', $contentRoute->getLocale(), $searchUrl), static::generateRoute($contentRoute, $url, $content)); } return $collection; }
/** * {@inheritdoc} */ public function reverseTransform($value) { if (null === $value) { return null; } if ($this->multiple) { if (is_string($value) && null !== $this->delimiter) { $value = explode($this->delimiter, $value); } if (!is_array($value)) { throw new UnexpectedTypeException($value, 'array'); } return $this->repository->findBy([$this->identifierProperty => $value]); } return $this->repository->findOneBy([$this->identifierProperty => $value]); }
/** * {@inheritDoc} */ public function findContentRoutesBy($url) { $collection = new RouteCollection(); /** @var $connection \Doctrine\DBAL\Connection */ $connection = $this->objectManager->getConnection(); try { $connection->connect(); } catch (\Exception $e) { return $collection; } if (!$connection->isConnected()) { return $collection; } $searchUrl = substr($url, -1) != '/' ? $url . '/' : $url; $params = array('path' => $searchUrl); try { $contentRoutes = $this->repository->findBy($params); } catch (\Doctrine\DBAL\DBALException $e) { return $collection; } if (empty($contentRoutes)) { return $collection; } $tempContentRoutes = array_filter($contentRoutes, array($this, 'filterByLocale')); if (empty($tempContentRoutes)) { $tempContentRoutes = $contentRoutes; } foreach ($tempContentRoutes as $key => $contentRoute) { $viewStatus = $this->request ? $this->request->getSession()->get('_viewStatus', VersionableInterface::STATUS_PUBLISHED) : VersionableInterface::STATUS_PUBLISHED; $test = new \ReflectionClass($contentRoute->getClassType()); if ($viewStatus == VersionableInterface::STATUS_DRAFT && $test->implementsInterface('Networking\\InitCmsBundle\\Doctrine\\Extensions\\Versionable\\ResourceVersionInterface')) { continue; } elseif ($viewStatus == VersionableInterface::STATUS_PUBLISHED && $test->implementsInterface('Networking\\InitCmsBundle\\Doctrine\\Extensions\\Versionable\\VersionableInterface')) { continue; } /** @var \Networking\InitCmsBundle\Model\ContentRouteInterface $contentRoute */ $content = $this->getRouteContent($contentRoute); $contentRoute->setContent($content); $contentRoute->setPath($url); $collection->add(self::ROUTE_GENERATE_DUMMY_NAME . preg_replace('/[^a-z0-9A-Z_.]/', '_', $key), $contentRoute); } return $collection; }
/** * {@inheritdoc} */ public function reverseTransform($value) { if (null === $value) { return; } if ($this->multiple) { if (is_string($value) && null !== $this->delimiter) { $value = explode($this->delimiter, $value); } if (!is_array($value)) { throw new UnexpectedTypeException($value, 'array'); } if (method_exists($this->repository, 'findByIds')) { return $this->repository->findByIds($value); } else { return $this->repository->findBy(['id' => $value]); } } return $this->repository->find($value); }
/** * @inheritDoc * * This will look for already persisted entries only. */ public function searchAces(array $grantees = null, array $targets = null, array $permissions = null) { $criteria = array(); if (null !== $grantees) { $grantees = array_map(array($this, 'extractSecurityIdentity'), $grantees); // Filter out non persisted non-anonymous grantee $grantees = array_filter($grantees, function (SecurityIdentity $grantee) { return null !== $grantee->getId() || SecurityIdentity::KIND_ANONYMOUS === $grantee->getKind(); }); $grantees = array_unique(array_map(function (SecurityIdentity $grantee) { return $grantee->getId(); }, $grantees), true); if (0 === count($grantees)) { return array(); } $criteria['grantee'] = $this->generateCriteriaValue($grantees); } if (null !== $targets) { $targets = array_map(array($this, 'extractTargetIdentity'), $targets); $targets = array_map(function (TargetIdentity $target) { return $target->getId(); }); // Filter out non persisted targets $targets = array_unique(array_filter($targets)); if (0 === count($targets)) { return array(); } $criteria['target'] = $this->generateCriteriaValue($targets); } if (null !== $permissions) { if (0 === count($permissions)) { return array(); } $criteria['permission'] = $this->generateCriteriaValue($permissions); } return $this->repository->findBy($criteria); }
/** * get all active products */ public function getAllActiveProducts() { return $this->repository->findBy(['isActive' => 1]); }
/** * {@inheritDoc} */ public function findByUser(UserInterface $user) { return $this->repository->findBy(['user' => $user]); }
/** * {@inheritDoc} */ public function findSchedules($limit = null, $offset = null) { return $this->repository->findBy(array(), array(), $limit, $offset); }
/** * @param array $criteria * * @return ShippingMethodInterface[] */ protected function getMethods(array $criteria = []) { return $this->repository->findBy($criteria); }
/** * {@inheritDoc} */ public function findByChannel($channel) { return $this->repository->findBy(array('channel' => $channel)); }
/** * Finds objects by a set of criteria. * * Optionally sorting and limiting details can be passed. An implementation may throw * an UnexpectedValueException if certain values of the sorting or limiting details are * not supported. * * @param array $criteria * @param array|null $orderBy * @param int|null $limit * @param int|null $offset * * @return array Set of fetched objects * * @throws UnexpectedValueException */ public function findBy(array $criteria, array $orderBy = null, $limit = null, $offset = null) { return $this->repository->findBy($criteria, $orderBy, $limit, $offset); }
/** * Find by the associated user id * @param $user_id * @return object */ public function findByUserId($user_id) { return $this->clientRepository->findBy(array('user' => $user_id)); }
/** * @param string $path * @return Product[] */ public function getByPath($path) { return $this->repository->findBy(['path' => $path]); }
/** * Insert new users * * @param Collection $users */ private function insertUsers(Collection $users) { set_time_limit(60); $this->manager->getConnection()->getConfiguration()->setSQLLogger(null); // Get existan user from DB $existantUsers = $this->repository->findBy(['email' => $this->extractEmails($users)->toArray()]); // Create an array of emails $existantEmails = array_map(function ($user) { return $user->getEmail(); }, $existantUsers); unset($existantUsers); // Get not existant users ready to import $nonExistantUsers = $users->filter(function ($user) use($existantEmails) { return !in_array($user->getEmail(), $existantEmails); }); unset($existantEmails); foreach ($nonExistantUsers as $user) { $user->addRole('ROLE_USER'); $this->manager->persist($user); $this->manager->flush(); $this->manager->clear(); $this->manager->detach($user); gc_enable(); gc_collect_cycles(); } }