private function createActivityType(EntityManagerInterface $em) { $activityType = new ResourceType(); $activityType->setName('activity'); $em->persist($activityType); $em->flush(); }
/** * @param EntityManager $em * @param Cache $cache * @param CacheHitsContainer $hitsContainer */ public function __construct(EntityManagerInterface $em, Cache $cache, CacheHitsContainer $hitsContainer) { $this->em = $em; $this->connection = $em->getConnection(); $this->cache = $cache; $this->hitsContainer = $hitsContainer; }
/** * @param string $token * * @return Boolean */ protected function isUsedCode($token) { $this->manager->getFilters()->disable('softdeleteable'); $isUsed = null !== $this->repository->findOneBy(array('confirmationToken' => $token)); $this->manager->getFilters()->enable('softdeleteable'); return $isUsed; }
/** * @param $fileName * @return bool */ protected function uniqueNameExists($fileName, EntityManagerInterface $em) { $dql = "SELECT COUNT(image) FROM EDVFileBundle:EdImage AS image WHERE image.hashString = :name"; $query = $em->createQuery($dql)->setParameters(array('name' => $fileName)); $result = $query->getSingleScalarResult(); return $result > 0; }
public function it_performs_a_fulltext_query(EntityManagerInterface $entityManager, AbstractQuery $query, $result = []) { $entityManager->createQuery(Argument::any())->shouldBeCalled()->willReturn($query); $query->setParameter(Argument::any(), Argument::any())->shouldBeCalled()->willReturn($query); $query->getResult()->shouldBeCalled()->willReturn($result); $this->query('black', $entityManager)->shouldBeArray(); }
/** * {@inheritdoc} */ public function convert($value) { if ($value) { return $this->em->getReference($this->entityClass, $value); } return null; }
/** * Creates schema for doctrine entities * * @throws \Doctrine\ORM\Tools\ToolsException */ protected function createDoctrineSchema() { $metadata = $this->entityManager->getMetadataFactory()->getAllMetadata(); $tool = new SchemaTool($this->entityManager); $tool->dropSchema($metadata); $tool->createSchema($metadata); }
/** * @inheritdoc */ public function delete(UserModel $user) : UserModel { $user->delete(); $this->em->persist($user); $this->em->flush(); return $user; }
/** * Returns the global entity manager. * * @return \Doctrine\ORM\EntityManagerInterface */ public function getEntityManager() { if ($this->entityManager === null || !$this->entityManager->isOpen()) { $this->entityManager = $this->createEntityManager(); } return $this->entityManager; }
/** * @param Category $category * @throws \Exception */ public function tryDelete(Category $category) { $this->tryValidate($category); $this->em->transactional(function () use($category) { $this->em->remove($category); }); }
public function onRender(RendererEvent $event) { $renderer = $event->getRenderer(); $content = $renderer->getObject(); $links = $content->getParamValue('link'); $link = ['url' => '', 'title' => 'Visit', 'target' => '_self']; if (!empty($links)) { $links = reset($links); if (isset($links['pageUid']) && !empty($links['pageUid'])) { $page = $this->entityManager->getRepository('BackBee\\CoreDomain\\NestedNode\\Page')->find($links['pageUid']); if ($page !== null) { $link['url'] = $page->getUrl(); } } if (empty($link['url']) && isset($links['url'])) { $link['url'] = $links['url']; } if (isset($links['title'])) { $link['title'] = $links['title']; } if (isset($links['target'])) { $link['target'] = $links['target']; } } $renderer->assign('link', $link); }
/** * Renueva el alquiler. * * @param Rental $rental * * @return Rental */ public function renewRental(Rental $rental) { if ($rental->getReturnAt()) { throw new FinishedRentalException(); } if ($rental->getUser()->getIsPenalized()) { throw new PenalizedUserException(); } if ($rental->getUser()->getFaculty()->getIsEnabled() === false) { throw new PenalizedFacultyException(); } if (!$rental->getIsRenewable()) { throw new NotRenewableRentalException(); } if ($rental->getIsExpired()) { throw new ExpiredRentalException(); } if ($rental->getDaysLeft() > $this->days_before_renovation) { throw new TooEarlyRenovationException(); } $left = $rental->getDaysLeft() + $this->days_length_rental; $rental->setEndAt(new \DateTime($left . ' days midnight')); $this->manager->persist($rental); $this->manager->flush(); $event = new RentalEvent($rental); $this->dispatcher->dispatch(RentalEvents::LOCKER_RENEWED, $event); return $rental; }
/** * Activates new user by activation code * * @param string $code * * @throws IOException */ public function activate($code) { $user = $this->userRepository->findOneBy(['code' => $code, 'frozen' => true]); $user->activate(); $this->entityManager->persist($user); $this->entityManager->flush(); }
public function getFreeWorkTimes(User $user, \DateTime $date = null) { $allTimes = []; //if($date) //{ $startTime = new \DateTime($date->format('Y-m-d H:i')); $endTime = new \DateTime($date->format('Y-m-d H:i')); $startTime->setTime($user->getStartTime()->format('H'), $user->getStartTime()->format('i')); $endTime->setTime($user->getEndTime()->format('H'), $user->getEndTime()->format('i')); //}else //{ // $startTime = new \DateTime($user->getStartTime()->format('H:i')); // $endTime = new \DateTime($user->getEndTime()->format('H:i')); //} $busyTimes = $this->em->getRepository('WorkerBundle:WorkTime')->getUserBusyTimes($user->getId()); while ($startTime < $endTime) { if ($startTime > new \DateTime()) { // if ($date) { $allTimes[] = $startTime->format('Y-m-d H:i'); // } else { // $allTimes[] = date('Y-m-d') . ' ' . $startTime->format('H:i'); // } } $startTime->modify('+1hour'); } return $this->removeBlockedTimes($allTimes, $busyTimes); }
function it_handles_a_delete_command(Entity $entity, Delete $command, EntityManagerInterface $em) { $command->getEntity()->willReturn($entity); $em->remove($entity)->shouldBeCalled(); $em->flush()->shouldBeCalled(); $this->handle($command); }
public function createMessage($text, $username, $email = null) { $message = new GuestBookMessage(); $message->setText($text)->setUsername($username)->setEmail($email); $this->manager->persist($message); $this->manager->flush(); }
private function purgeUsingCachedQueries() { $this->entityManager->getConnection()->getConfiguration()->setSQLLogger(null); foreach ($this->cachedQueries as $cachedQuery) { $this->entityManager->getConnection()->executeUpdate($cachedQuery['sql'], $cachedQuery['params'], $cachedQuery['types']); } }
/** * Enables tenantable filter on kernel.request. */ public function onKernelRequest() { $tenant = $this->tenantContext->getTenant(); if ($tenant && $tenant->getId()) { $this->entityManager->getFilters()->enable('tenantable')->setParameter('tenantCode', $tenant->getCode()); } }
/** * @param Parser $params * @param array &$resourceObject * @throws ParseException */ public function hydrate(Params $params, array &$resourceObject) { if (empty($resourceObject[self::LINKS])) { return; } elseif (!is_array($resourceObject[self::LINKS])) { throw new ParseException(self::ERROR_LINKS_TYPE); } $metadata = $this->mm->mine($params->primaryClass); foreach ($resourceObject[self::LINKS] as $relationship => &$ids) { if (is_array($ids)) { if (!$metadata->isToManyRelationship($relationship)) { $message = sprintf(self::ERROR_LINKS_CONTENT, $relationship); throw new ParseException($message); } $class = $metadata->relationships->toMany[$relationship]->class; $ids = $this->em->getRepository($class)->findById($ids); } elseif (is_string($ids)) { if (!$metadata->isToOneRelationship($relationship)) { $message = sprintf(self::ERROR_LINKS_CONTENT, $relationship); throw new ParseException($message); } $class = $metadata->relationships->toOne[$relationship]->class; $ids = $this->em->getRepository($class)->findOneById($ids); } elseif (!is_null($ids)) { $message = sprintf(self::ERROR_LINKS_CONTENT_TYPE, $relationship); throw new ParseException($message); } } }
/** * Load country data * * @param string $countryIso Country iso * * @return $this Self object */ public function loadCountry($countryIso) { $content = $this->locationLoaderAdapter->getSqlForCountry($countryIso); $statement = $this->locationEntityManager->getConnection()->prepare($content); $statement->execute(); return $this; }
function it_handles_a_find_all_query(FindAll $query, EntityRepository $repository, EntityManagerInterface $em) { $query->getEntityClass()->willReturn('Indigo\\Crud\\Stub\\Entity'); $repository->findAll()->shouldBeCalled(); $em->getRepository('Indigo\\Crud\\Stub\\Entity')->willReturn($repository); $this->handle($query); }
/** * Create a new repository instance for an entity class. * * @param \Doctrine\ORM\EntityManagerInterface $entityManager The EntityManager instance. * @param string $entityName The name of the entity. * * @return \Doctrine\Common\Persistence\ObjectRepository */ private function createRepository(EntityManagerInterface $entityManager, $entityName) { /* @var $metadata \Doctrine\ORM\Mapping\ClassMetadata */ $metadata = $entityManager->getClassMetadata($entityName); $repositoryClassName = $metadata->customRepositoryClassName ?: $entityManager->getConfiguration()->getDefaultRepositoryClassName(); return new $repositoryClassName($entityManager, $metadata); }
/** * @param EntityManagerInterface $em */ public function __construct(EntityManagerInterface $em) { $params = $em->getConnection()->getParams(); $dsn = "mysql:host={$params['host']};dbname={$params['dbname']}"; $this->pdo = new PDO($dsn, $params['user'], $params['password']); $this->pdo->setAttribute(PDO::ATTR_ORACLE_NULLS, PDO::NULL_NATURAL); }
/** * @param EntityManagerInterface $entityManager * @param UserManagerInterface $userManager * @param ValidatorInterface $validator */ public function __construct(EntityManagerInterface $entityManager, UserManagerInterface $userManager, ValidatorInterface $validator) { $this->entityManager = $entityManager; $this->userRepository = $entityManager->getRepository('AppBundle:User'); $this->userManager = $userManager; $this->validator = $validator; }
public function getFilters() { $filterFactory = function ($className) { return function ($nodes) use($className) { $nodes = is_array($nodes) ? $nodes : ($nodes ? iterator_to_array($nodes) : []); return array_filter($nodes, function ($item) use($className) { if ($item instanceof HasRefInterface) { return $item->getRefName() === $className; } return $item instanceof $className; }); }; }; $pageFetcher = function ($className) { return function ($id) use($className) { return $this->em->getRepository($className)->find($id); }; }; $pageFetchers = $this->pageFetchersConfiguration(); $filterFactories = $this->filterFactoriesConfiguration(); return array_combine(array_keys($pageFetchers), array_map(function ($name, $class) use($pageFetcher) { return new \Twig_SimpleFilter($name, $pageFetcher($class)); }, array_keys($pageFetchers), $pageFetchers)) + array_combine(array_keys($filterFactories), array_map(function ($name, $class) use($filterFactory) { return new \Twig_SimpleFilter($name, $filterFactory($class)); }, array_keys($filterFactories), $filterFactories)); }
public function processDelete(ProcessHook $hook) { $repository = $this->entityManager->getRepository('CmfcmfMediaModule:HookedObject\\HookedObjectEntity'); $hookedObject = $repository->getByHookOrCreate($hook); $this->entityManager->remove($hookedObject); $this->entityManager->flush(); }
/** * @inheritdoc */ public function delete(MessageModel $message) : MessageModel { $message->delete(); $this->em->persist($message); $this->em->flush(); return $message; }
/** * {@inheritdcoc} */ public function getTresholds() { if (is_array($this->cachedTresholds)) { return $this->cachedTresholds; } return $this->cachedTresholds = $this->entitManager->getRepository($this->entityClass)->findAll(); }
/** * That nested case will be corrected and fully supported * {% softdeleteable %} * <span> * {% softdeleteable 'Acme\Bundle\CoreBundle\Entity\Foo' %} * {% softdeleteable %} * {% softdeleteable 'Acme\Bundle\CoreBundle\Entity\Bar' %} * {{ object.owner.fullName }} * {% endsoftdeleteable %} * {% endsoftdeleteable %} * {% endsoftdeleteable %} * </span> * {% endsoftdeleteable %} * @param null $class * @return bool */ public function enable($class = null) { if (!$this->entityManager->getFilters()->isEnabled('softdeleteable')) { if ($class !== null) { // Nested tags case. // {% softdeleteable 'FQCN' %} inside {% softdeleteable %} // So, just pop classes stack $this->classStack->pop(); } else { // When we enable globally we need to restore disabled entities $this->entityManager->getFilters()->enable('softdeleteable'); // Populate from stack of disabled entities /** @var SoftDeleteableFilter $filter */ $filter = $this->entityManager->getFilters()->getFilter('softdeleteable'); foreach ($this->classStack as $class) { $filter->disableForEntity($class); } } } else { if ($class !== null) { /** @var SoftDeleteableFilter $filter */ $filter = $this->entityManager->getFilters()->getFilter('softdeleteable'); $filter->enableForEntity($class); $this->classStack->pop(); } } }
/** * @param Schema $schema */ public function down(Schema $schema) { $rep = $this->em->getRepository('AnimeDbCatalogBundle:Genre'); /* @var $genre Genre */ foreach ($this->restore as $from => $to) { $genre = $rep->findOneBy(['name' => $from]); if (is_array($to)) { $genre->setName($to[1])->setTranslatableLocale('ru'); $this->em->persist($genre); $this->em->flush($genre); $to = $to[0]; } $genre->setName($to)->setTranslatableLocale('en'); $this->em->persist($genre); } // new genre $genre = new Genre(); $genre->setName('Mystery play')->setTranslatableLocale('en'); $this->em->persist($genre); $this->em->flush(); $genre->setName('Мистерия')->setTranslatableLocale('ru'); $this->em->persist($genre); // rename russian $genre = $rep->findOneBy(['name' => 'History']); $genre->setName('История')->setTranslatableLocale('ru'); $this->em->persist($genre); $genre = $rep->findOneBy(['name' => 'War']); $genre->setName('Война')->setTranslatableLocale('ru'); $this->em->persist($genre); $this->em->flush(); }