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