/** * @param User $user * @param array $actualRepositories */ protected function updateUserRepositories(User $user, array $actualRepositories) { // Reindex array by GH repository ids $actualRepositories = array_column($actualRepositories, null, 'id'); $userRepositoryIds = []; /** @var Repository $repository */ foreach ($user->getRepositories() as $repository) { // Repository was removed from github if (!array_key_exists($repository->getGithubId(), $actualRepositories)) { $user->getRepositories()->removeElement($repository); continue; } // Collect ids of user repositories $userRepositoryIds[] = $repository->getGithubId(); } $repositoryManager = $this->doctrine->getManagerForClass(Repository::class); // Create repository entities for new repositories from github array_map(function ($repository) use($userRepositoryIds, $user, $repositoryManager) { if (!in_array($repository['id'], $userRepositoryIds)) { $repository = (new Repository())->setGithubId($repository['id'])->setFullName($repository['full_name'])->setName($repository['name'])->setOwner($user); $repositoryManager->persist($repository); $user->addRepository($repository); } }, $actualRepositories); $repositoryManager->flush(); }
/** * Get marketing list types choices. * * @return array */ public function getListTypeChoices() { /** @var MarketingListType[] $types */ $types = $this->registry->getManagerForClass(self::MARKETING_LIST_TYPE)->getRepository(self::MARKETING_LIST_TYPE)->findBy(array(), array('name' => 'ASC')); $results = array(); foreach ($types as $type) { $results[$type->getName()] = $type->getLabel(); } return $results; }
/** * {@inheritdoc} */ public function addManager(ManagerInterface $manager) { $class = $manager->getClass(); $em = $this->doctrine->getManagerForClass($class); $manager->setObjectManager($em); $manager->setRepository($em->getRepository($class)); $manager->setEventDispatcher($this->eventDispatcher); $manager->setFactory($this); $this->managers[$class] = $manager; }
/** * {@inheritdoc} */ public function getEntityManager() { if ($this->entityManager instanceof ObjectManager) { return $this->entityManager; } $em = $this->registry->getManagerForClass(self::TRANSACTION_CLASS); if (!$em) { throw new \RuntimeException(sprintf('No entity manager defined for class %s', self::TRANSACTION_CLASS)); } return $em; }
/** * Returns query builder that allows to fetch list of lifetime values for each account * * @param null $ids the identifiers of accounts the lifetimeValues for which is need to be fetched * * @return QueryBuilder */ public function getAccountsLifetimeQueryBuilder($ids = null) { /** @var EntityManager $em */ $em = $this->registry->getManagerForClass('OroCRMChannelBundle:LifetimeValueHistory'); $qb = $em->createQueryBuilder(); $qb->select('IDENTITY(h.account) AS accountId, SUM(h.amount) AS lifetimeValue')->from('OroCRMChannelBundle:LifetimeValueHistory', 'h')->leftJoin('h.dataChannel', 'ch')->andWhere('ch.status = :channelStatus')->setParameter('channelStatus', $qb->expr()->literal((int) Channel::STATUS_ACTIVE))->andWhere('h.status = :status')->setParameter('status', $qb->expr()->literal(LifetimeValueHistory::STATUS_NEW))->groupBy('h.account'); if ($ids) { $qb->andWhere('IDENTITY(h.account) IN(:ids)')->setParameter('ids', array_values($ids)); } return $qb; }
/** * Process form * * @param EmailCampaign $entity * * @return bool */ public function process(EmailCampaign $entity) { $this->form->setData($entity); if (in_array($this->request->getMethod(), array('POST', 'PUT'))) { $this->form->submit($this->request); if (!$this->request->get(self::UPDATE_MARKER, false) && $this->form->isValid()) { $em = $this->registry->getManagerForClass('OroCRMCampaignBundle:EmailCampaign'); $em->persist($entity); $em->flush(); return true; } } return false; }
/** * @param Repository $repository */ public function toggleRepositoryWebhook(Repository $repository) { /** @var User $user */ $user = $this->tokenStorage->getToken()->getUser(); if ($repository->getEnabled()) { $this->githubManager->removeWebhook($user->getUsername(), $repository->getName(), $repository->getWebhookId()); $webhookId = null; } else { $webhookId = $this->githubManager->createWebhook($user->getUsername(), $repository->getName()); } // Update state of repository webhook $repository->setWebhookId($webhookId); $repositoryManager = $this->doctrine->getManagerForClass(ClassUtils::getClass($repository)); $repositoryManager->flush(); }
/** * Finds an entity * * @param string $class * @param array $data * * @return object|null */ protected function findEntity($class, array $data) { $repository = $this->doctrine->getManagerForClass($class)->getRepository($class); $identifierProperties = $this->getEntityIdentifierProperties($repository); $identifier = $this->getEntityIdentifier($identifierProperties, $data); return $this->findOneByIdentifier($repository, $identifier); }
/** * @param object $originEntity * @param array $criteria * @throws \RuntimeException * @return object|null */ protected function getEntity($originEntity, $criteria) { if (!$this->registry) { throw new \RuntimeException('Registry was not set'); } $className = ClassUtils::getRealClass($originEntity); return $this->registry->getManagerForClass($className)->getRepository($className)->findOneBy($criteria); }
/** * {@inheritdoc} */ public function buildForm(FormBuilderInterface $builder, array $options) { $serializerMetadata = $this->metadataFactory->getMetadataForClass($this->class); $manager = $this->registry->getManagerForClass($this->class); $doctrineMetadata = $manager->getClassMetadata($this->class); foreach ($serializerMetadata->propertyMetadata as $propertyMetadata) { $name = $propertyMetadata->name; if (in_array($name, $doctrineMetadata->getIdentifierFieldNames()) && !$this->identifierOverwrite) { continue; } if (!in_array($this->group, $propertyMetadata->groups)) { continue; } $type = null; $nullable = true; if (isset($doctrineMetadata->fieldMappings[$name])) { $fieldMetadata = $doctrineMetadata->fieldMappings[$name]; $type = isset($fieldMetadata['type']) ? $fieldMetadata['type'] : null; $nullable = isset($fieldMetadata['nullable']) ? $fieldMetadata['nullable'] : false; } else { if (isset($doctrineMetadata->associationMappings[$name])) { $associationMetadata = $doctrineMetadata->associationMappings[$name]; if (isset($associationMetadata['joinColumns']['nullable'])) { $nullable = $associationMetadata['joinColumns']['nullable']; } else { if (isset($associationMetadata['inverseJoinColumns']['nullable'])) { $nullable = $associationMetadata['inverseJoinColumns']['nullable']; } } } } switch ($type) { case 'datetime': $builder->add($name, $type, array('required' => !$nullable, 'widget' => 'single_text')); break; case 'boolean': $childBuilder = $builder->create($name, null, array('required' => !$nullable)); $childBuilder->addEventSubscriber(new FixCheckboxDataListener()); $builder->add($childBuilder); break; default: $builder->add($name, null, array('required' => !$nullable)); break; } } }
/** * @param \Class $class * * @return EntityManager */ public function getEntityManager($class = null) { if (!$class) { return $this->_registry->getEntityManager(); } if (is_object($class)) { $class = get_class($class); } if (!isset($this->_cache[$class])) { $em = $this->_registry->getManagerForClass($class); if (!$em) { throw new \RuntimeException(sprintf('No entity manager defined for class %s', $class)); } $this->_cache[$class] = $em; } return $this->_cache[$class]; }
/** * Finds an entity * * @param string $class * @param array $data * * @throws \LogicException * * @return object|null */ protected function findEntity($class, array $data) { $repository = $this->doctrine->getManagerForClass($class)->getRepository($class); if ($repository instanceof IdentifiableObjectRepositoryInterface) { $identifierProperties = $repository->getIdentifierProperties(); $identifier = $this->getEntityIdentifier($identifierProperties, $data); return $repository->findOneByIdentifier($identifier); } return null; }
/** * {@inheritdoc} */ public function getIdentifyingValue($object) { $className = get_class($object); $em = $this->registry->getManagerForClass($className); $metadata = $em->getClassMetadata($className); $identifier = $metadata->getIdentifier(); if (count($identifier) > 1) { throw new CompositePrimaryKeyException(sprintf('Composite Primary Keys cannot be resolved to a single scalar value on Entity: %s', get_class($object))); } try { $pkValue = $this->propertyAccessor->getValue($object, $identifier[0]); } catch (AccessException $e) { throw new IdentifyingFieldNotReachableException(sprintf('The property accessor was unable to access %s.', $identifier[0])); } if (is_object($pkValue)) { $pkValue = $this->getIdentifyingValue($pkValue); } return $pkValue; }
/** * Returns query builder that allows to fetch account lifetime value from history table * Following parameters are required to be passed: * - account Account entity or identifier * * Following parameters are optional: * - dataChannel - Channel entity or id to be used for fetch criteria, required if $addChannelParam is set to true * * @param bool $addChannelParam * * @return QueryBuilder */ public function getChannelAccountLifetimeQueryBuilder($addChannelParam = false) { /** @var EntityManager $em */ $em = $this->registry->getManagerForClass('OroCRMChannelBundle:LifetimeValueHistory'); $qb = $em->createQueryBuilder(); $qb->from('OroCRMChannelBundle:LifetimeValueHistory', 'h'); $qb->select('SUM(h.amount)'); $qb->andWhere('h.account = :account'); if ($addChannelParam) { // do not change order, need for idx $qb->andWhere('h.dataChannel = :dataChannel'); } $qb->leftJoin('h.dataChannel', 'ch'); $qb->andWhere('ch.status = :channelStatus'); $qb->setParameter('channelStatus', $qb->expr()->literal((int) Channel::STATUS_ACTIVE)); $qb->andWhere('h.status = :status'); $qb->setParameter('status', $qb->expr()->literal(LifetimeValueHistory::STATUS_NEW)); $qb->setMaxResults(1); return $qb; }
/** * Finds an entity * * @param string $class * @param array $data * * @return object|null */ protected function findEntity($class, array $data) { $repository = $this->doctrine->getManagerForClass($class)->getRepository($class); if ($repository instanceof ReferableEntityRepositoryInterface) { $reference = implode('.', array_map(function ($property) use($class, $data) { if (!isset($data[$property])) { throw new MissingIdentifierException(); } return $data[$property]; }, $repository->getReferenceProperties())); return $repository->findByReference($reference); } }
/** * Outputs serialized entities * * @param Request $request */ protected function export(Request $request) { $iterator = $this->queryGenerator->createQueryBuilder($request, $this->configuration->getName())->getQuery()->iterate(); $headersSent = false; $manager = $this->doctrine->getManagerForClass($this->configuration->getEntityClass()); foreach ($iterator as $index => $item) { if (!count($item[0])) { continue; } $norm = $this->serializer->normalize($item[0], $this->options['serializer_format'], $this->options['serializer_context']); if (!$headersSent) { echo $this->serializer->encode(array_keys($norm), $this->options['serializer_format'], $this->options['serializer_context']); $headersSent = true; } echo $this->serializer->encode($norm, $this->options['serializer_format'], $this->options['serializer_context']); flush(); if (0 === ($index + 100) % $this->options['batch_size']) { $manager->clear(); } } }
/** * @param FormEvent $event */ public function postSubmit(FormEvent $event) { $form = $event->getForm(); $parentForm = $form->getParent(); $parentData = $parentForm->getData(); $propertyAccessor = PropertyAccess::createPropertyAccessor(); if ($parentData) { $entityClass = get_class($parentData); $em = $this->doctrine->getManagerForClass($entityClass); $translatableFields = $this->getTranslatableFields($entityClass); $data = $event->getData(); $locales = $this->localeList; $reflectionClass = new \ReflectionClass($entityClass); $gedmoAnnotations = $this->isPersonnalTranslationRecursive($reflectionClass); if ($gedmoAnnotations && is_object($gedmoAnnotations) && $gedmoAnnotations->class != '') { $repository = $this->translationRepository; } else { $repository = $em->getRepository('Gedmo\\Translatable\\Entity\\Translation'); } foreach ($locales as $locale => $localeConf) { foreach ($translatableFields as $field => $type) { if ($parentForm->has($field)) { $fieldData = ''; $localeFieldName = sprintf('%s-%s', $field, $locale); if (isset($data[$localeFieldName])) { $fieldData = $data[$localeFieldName]; } elseif (isset($data[$field])) { $fieldData = $data[$field]; } if ($field != 'slug' || $fieldData) { if ($repository instanceof BigfootTranslationRepository && $this->currentLocale == $locale) { $fieldData = $propertyAccessor->getValue($parentData, $field); } $repository->translate($parentData, $field, $locale, $fieldData); } } } } } }
/** * @return RepositoryRepository */ protected function getRepositoryRepository() { return $this->doctrine->getManagerForClass('ApproveCodeUserBundle:Repository')->getRepository('ApproveCodeUserBundle:Repository'); }
public function __construct(RegistryInterface $registry, $class) { $this->class = $class; $this->entity_manager = $registry->getManagerForClass($class); $this->entity_repository = $this->entity_manager->getRepository($class); }
private function getEntityManager() { return $this->doctrine->getManagerForClass($this->options['class']); }
/** * @return \Doctrine\ORM\EntityManager */ private function getEntityManager() { return $this->registry->getManagerForClass($this->blockManager->getClass()); }