/** * @return ObjectRepository */ protected function getLoginPageRepository() { if (!$this->loginPageRepository) { $this->loginPageRepository = $this->doctrine->getManagerForClass('OroB2BCMSBundle:LoginPage')->getRepository('OroB2BCMSBundle:LoginPage'); } return $this->loginPageRepository; }
/** * @param OrmFilterDatasourceAdapter $ds * @param string $fieldName * * @return array [entity, alias, field] * * @throws \RuntimeException */ protected function getFilterParts(OrmFilterDatasourceAdapter $ds, $fieldName) { $fieldParts = explode('.', $fieldName); if (count($fieldParts) !== 2) { throw new \RuntimeException(sprintf('It is expected that $fieldName is in "alias.name" format, but "%s" given.', $fieldName)); } $qb = $ds->getQueryBuilder(); $entity = $this->getRootEntity($qb, $fieldParts[0]); if (empty($entity)) { $associations = []; $entity = $this->findEntityByAlias($qb, $fieldParts[0]); while (!empty($entity) && strpos($entity, ':') === false && strpos($entity, '\\') === false) { $parts = explode('.', $entity); array_unshift($associations, $parts[1]); $entity = $this->findEntityByAlias($qb, $parts[0]); } if (empty($entity)) { throw new \RuntimeException(sprintf('Cannot find root entity for "$s". It seems that a query is not valid.', $fieldName)); } foreach ($associations as $assoc) { $entity = $this->doctrine->getManagerForClass($entity)->getClassMetadata($entity)->getAssociationTargetClass($assoc); } } if (empty($entity)) { throw new \RuntimeException(sprintf('Cannot find entity for "$s". It seems that a query is not valid.', $fieldName)); } return [$entity, $fieldParts[0], $fieldParts[1]]; }
/** * @param int $segmentId * * @return MarketingList */ public function getMarketingListBySegment($segmentId) { if (empty($this->marketingListsBySegment[$segmentId])) { $this->marketingListsBySegment[$segmentId] = $this->managerRegistry->getManagerForClass(self::MARKETING_LIST)->getRepository(self::MARKETING_LIST)->findOneBy(['segment' => $segmentId]); } return $this->marketingListsBySegment[$segmentId]; }
/** * Returns class metadata for a defined entity parameter * * @param string $entityParameter * * @return \Doctrine\Common\Persistence\Mapping\ClassMetadata */ protected function getClassMetadata($entityParameter) { $entityClassName = $this->container->getParameter($entityParameter); $manager = $this->managerRegistry->getManagerForClass($entityClassName); $classMetadata = $manager->getClassMetadata($entityClassName); return $classMetadata; }
public function runCrons() { $entityManager = $this->managerRegistry->getManagerForClass('DspSoftsCronManagerBundle:CronTask'); $cronTaskRepo = $entityManager->getRepository('DspSoftsCronManagerBundle:CronTask'); $cronTasks = $cronTaskRepo->findCronsToLaunch(); foreach ($cronTasks as $cronTask) { $run = true; if (!$cronTask->getRelaunch()) { $run = $this->planificationChecker->isExecutionDue($cronTask->getPlanification()); } if ($run) { if ($this->logger !== null) { $this->logger->info(sprintf('Running Cron Task <info>%s</info>', $cronTask->getName())); } $cli = 'exec ' . $this->kernelRootDir . DIRECTORY_SEPARATOR . 'console dsp:cron:runjob -c ' . $cronTask->getId() . ' &'; if ($this->logger !== null) { $this->logger->info(sprintf('Command line : <info>%s</info>', $cli)); } $process = new Process($cli); $process->setTimeout(0); $process->start(); } else { if ($this->logger !== null) { $this->logger->info(sprintf('Skipping Cron Task <info>%s</info>', $cronTask->getName())); } } } }
/** * @param ConsoleTerminateEvent $event */ public function onConsoleTerminate(ConsoleTerminateEvent $event) { if (!$this->isExceptionOccurred) { if ($event->getCommand() instanceof UpdateSchemaDoctrineCommand) { $output = $event->getOutput(); $input = $event->getInput(); if ($input->getOption('force')) { $result = $this->fulltextIndexManager->createIndexes(); $output->writeln('Schema update and create index completed.'); if ($result) { $output->writeln('Indexes were created.'); } } } if ($event->getCommand() instanceof UpdateSchemaCommand) { /** @var EntityManager $searchEntityManager */ $searchEntityManager = $this->registry->getManagerForClass('OroSearchBundle:UpdateEntity'); $entities = $searchEntityManager->getRepository('OroSearchBundle:UpdateEntity')->findAll(); if (count($entities)) { /** @var EntityManager $em */ $em = $this->registry->getManagerForClass('JMS\\JobQueueBundle\\Entity\\Job'); foreach ($entities as $entity) { $job = new Job(ReindexCommand::COMMAND_NAME, ['class' => $entity->getEntity()]); $em->persist($job); $searchEntityManager->remove($entity); } $em->flush(); $searchEntityManager->flush(); } } } $this->isExceptionOccurred = null; }
/** * {@inheritdoc} */ public function getSerializationConfig($className) { /** @var EntityManager $em */ $em = $this->doctrine->getManagerForClass($className); $metadata = $em->getClassMetadata($className); $extendConfigProvider = $this->configManager->getProvider('extend'); $fields = []; foreach ($metadata->getFieldNames() as $fieldName) { $extendFieldConfig = $extendConfigProvider->getConfig($className, $fieldName); if ($extendFieldConfig->is('is_extend')) { // skip extended fields continue; } $fields[$fieldName] = null; } foreach ($metadata->getAssociationNames() as $fieldName) { $extendFieldConfig = $extendConfigProvider->getConfig($className, $fieldName); if ($extendFieldConfig->is('is_extend')) { // skip extended fields continue; } $mapping = $metadata->getAssociationMapping($fieldName); if ($mapping['type'] & ClassMetadata::TO_ONE && $mapping['isOwningSide']) { $targetMetadata = $em->getClassMetadata($mapping['targetEntity']); $idFieldNames = $targetMetadata->getIdentifierFieldNames(); if (count($idFieldNames) === 1) { $fields[$fieldName] = ['fields' => $idFieldNames[0]]; } } } return ['exclusion_policy' => 'all', 'hints' => ['HINT_TRANSLATABLE'], 'fields' => $fields]; }
/** * @param GetResponseEvent $event */ public function onKernelRequest(GetResponseEvent $event) { if (!$this->installed) { return; } $request = $event->getRequest(); if ($request->attributes->has('_controller') || $event->getRequestType() !== HttpKernelInterface::MASTER_REQUEST) { return; } $slugUrl = $request->getPathInfo(); if ($slugUrl !== '/') { $slugUrl = rtrim($slugUrl, '/'); } /** @var EntityManager $em */ $em = $this->registry->getManagerForClass('OroB2BRedirectBundle:Slug'); $slug = $em->getRepository('OroB2BRedirectBundle:Slug')->findOneBy(['url' => $slugUrl]); if ($slug) { $routeName = $slug->getRouteName(); $controller = $this->router->getRouteCollection()->get($routeName)->getDefault('_controller'); $parameters = []; $parameters['_route'] = $routeName; $parameters['_controller'] = $controller; $redirectRouteParameters = $slug->getRouteParameters(); $parameters = array_merge($parameters, $redirectRouteParameters); $parameters['_route_params'] = $redirectRouteParameters; $request->attributes->add($parameters); } }
/** * {@inheritdoc} */ public function loadClassMetadata(ClassMetadataInterface $classMetadata, array $normalizationGroups = null, array $denormalizationGroups = null, array $validationGroups = null) { $className = $classMetadata->getReflectionClass()->name; $manager = $this->managerRegistry->getManagerForClass($className); if (!$manager) { return $classMetadata; } $doctrineClassMetadata = $manager->getClassMetadata($className); if (!$doctrineClassMetadata) { return $classMetadata; } $identifiers = $doctrineClassMetadata->getIdentifier(); if (1 !== count($identifiers)) { return $classMetadata; } $identifierName = $identifiers[0]; if (!$classMetadata->hasAttributeMetadata($identifierName)) { $attributeMetadata = $this->attributeMetadataFactory->getAttributeMetadataFor($classMetadata, $identifierName, $normalizationGroups, $denormalizationGroups); if ($doctrineClassMetadata->isIdentifierNatural()) { $attributeMetadata = $attributeMetadata->withWritable(false); } $classMetadata = $classMetadata->withAttributeMetadata($identifierName, $attributeMetadata); } $classMetadata = $classMetadata->withIdentifierName($identifierName); return $classMetadata; }
/** * @param string $entityName Entity name to prepare search handler for * @param string $targetField Entity field to search by and include to search results */ public function initForEntity($entityName, $targetField) { $this->entityName = str_replace('_', '\\', $entityName); $this->initDoctrinePropertiesByEntityManager($this->registry->getManagerForClass($this->entityName)); $this->properties = array_unique(array_merge($this->defaultPropertySet, [$targetField])); $this->currentField = $targetField; }
/** * @param string $type * * @return FilterIn|null */ private function create($type) { $manager = $this->managerRegistry->getManagerForClass($type); if ($manager) { return new FilterIn($manager->getRepository($type)); } }
/** * {@inheritdoc} * @throws RuntimeException */ public function construct(VisitorInterface $visitor, ClassMetadata $metadata, $data, array $type, DeserializationContext $context) { // Locate possible ObjectManager $objectManager = $this->managerRegistry->getManagerForClass($metadata->name); if (!$objectManager) { // No ObjectManager found, proceed with normal deserialization return $this->fallbackConstructor->construct($visitor, $metadata, $data, $type, $context); } // Locate possible ClassMetadata $classMetadataFactory = $objectManager->getMetadataFactory(); if ($classMetadataFactory->isTransient($metadata->name)) { // No ClassMetadata found, proceed with normal deserialization return $this->fallbackConstructor->construct($visitor, $metadata, $data, $type, $context); } try { $id = $this->resolveIdentifier($metadata, $data, $objectManager); } catch (\Exception $e) { $id = null; } if ($id && ($entity = $objectManager->find($metadata->name, $id))) { /* @var $objectManager EntityManager */ if ($this->isNewIdRegistered($metadata->name, $id)) { throw new RuntimeException("Not a unique entity '{$metadata->name}' with identifier '{$id}''"); } $this->registerNewId($metadata->name, $id); return $entity; } // No ClassMetadata found, proceed with normal deserialization return $this->fallbackConstructor->construct($visitor, $metadata, $data, $type, $context); }
/** * {@inheritdoc} */ public function buildForm(FormBuilderInterface $builder, array $options) { if ($options['em'] === null) { $em = $this->registry->getManagerForClass($options['class']); } else { $em = $this->registry->getManager($options['em']); } $repository = $em->getRepository($options['class']); $entities = $repository->findAll(); /** @var ClassMetadataInfo $classMetadata */ $classMetadata = $em->getClassMetadata($options['class']); $identifierField = $classMetadata->getSingleIdentifierFieldName(); $choiceLabels = []; /** @var AddressType $entity */ foreach ($entities as $entity) { $pkValue = $classMetadata->getReflectionProperty($identifierField)->getValue($entity); if ($options['property']) { $value = $classMetadata->getReflectionProperty($options['property'])->getValue($entity); } else { $value = (string) $entity; } $choiceLabels[$pkValue] = $this->translator->trans('orob2b.customer.customer_typed_address_with_default_type.choice.default_text', ['%type_name%' => $value]); } $builder->add('default', 'choice', ['choices' => $choiceLabels, 'multiple' => true, 'expanded' => true, 'label' => false])->addViewTransformer(new AddressTypeDefaultTransformer($em)); }
/** * @param FormEvent $event */ public function postSetData(FormEvent $event) { $form = $event->getForm(); if ($form->getParent()) { return; } if (!$form->has($this->fieldName)) { return; } $isEntityExists = false; $entity = $event->getData(); if ($entity) { if (!is_object($entity)) { return; } $entityClass = ClassUtils::getClass($entity); $entityManager = $this->managerRegistry->getManagerForClass($entityClass); if (!$entityManager) { return; } $entityIdentifier = $entityManager->getClassMetadata($entityClass)->getIdentifierValues($entity); $isEntityExists = !empty($entityIdentifier); } // if entity exists and assign is not granted - replace field with disabled text field, // otherwise - set default owner value if ($isEntityExists) { $this->replaceOwnerField($form); } else { $this->setPredefinedOwner($form); } }
/** * @param string $entityClass * @return EntityManager * @throws LogicException */ protected function getEntityManager($entityClass) { $entityManager = $this->managerRegistry->getManagerForClass($entityClass); if (!$entityManager) { throw new LogicException(sprintf('Can\'t find entity manager for %s', $entityClass)); } return $entityManager; }
/** * @return \Doctrine\Common\Persistence\ObjectManager * @throws \FSi\Bundle\AdminBundle\Exception\RuntimeException */ public function getObjectManager() { $om = $this->registry->getManagerForClass($this->getClassName()); if (is_null($om)) { throw new RuntimeException(sprintf('Registry manager does\'t have manager for class "%s".', $this->getClassName())); } return $om; }
/** * @param string $entityClass * * @return EntityManager * * @throws \RuntimeException */ public function getEntityManager($entityClass) { $em = $this->doctrine->getManagerForClass($entityClass); if (!$em) { throw new \RuntimeException(sprintf('Entity class "%s" is not manageable.', $entityClass)); } return $em; }
/** * @return ObjectManager */ public function getObjectManager() { $manager = $this->registry->getManagerForClass($this->class); if (!$manager) { throw new \RuntimeException(sprintf("Unable to find the mapping information for the class %s." . " Please check the 'auto_mapping' option (http://symfony.com/doc/current/reference/configuration/doctrine.html#configuration-overview)" . " or add the bundle to the 'mappings' section in the doctrine configuration.", $this->class)); } return $manager; }
/** * Gets the manager if applicable. * * @param ResourceInterface $resourceType * @param mixed $data * * @return ObjectManager|null */ private function getManager(ResourceInterface $resourceType, $data) { $objectManager = $this->managerRegistry->getManagerForClass($resourceType->getEntityClass()); if (null === $objectManager || !is_object($data)) { return; } return $objectManager; }
/** * Get object manager for class * * @param string|object $source An class name or entity * * @return ObjectManager */ public function getManager($source) { $source = $this->getClass($source); if (null === ($om = $this->registry->getManagerForClass($source))) { throw new \LogicException(sprintf('Could not get object manager for class %s', $source)); } return $om; }
/** * @param string $class * @return ClassMetadata|null */ protected function getMetadataForClass($class) { $entityManager = $this->managerRegistry->getManagerForClass($class); if (!$entityManager) { return null; } return $entityManager->getClassMetadata($class); }
/** * @param object $entity * @param Constraint $constraint */ public function validate($entity, Constraint $constraint) { if (!is_array($constraint->fields) && !is_string($constraint->fields)) { throw new UnexpectedTypeException($constraint->fields, 'array'); } $fields = (array) $constraint->fields; if (0 === count($fields)) { throw new ConstraintDefinitionException('At least one field has to be specified.'); } if ($constraint->em) { $em = $this->registry->getManager($constraint->em); } else { $em = $this->registry->getManagerForClass(get_class($entity)); } $className = $this->context->getCurrentClass(); $class = $em->getClassMetadata($className); /* @var $class \Doctrine\Common\Persistence\Mapping\ClassMetadata */ $criteria = array(); foreach ($fields as $fieldName) { if (!$class->hasField($fieldName) && !$class->hasAssociation($fieldName)) { throw new ConstraintDefinitionException("Only field names mapped by Doctrine can be validated for uniqueness."); } $criteria[$fieldName] = $class->reflFields[$fieldName]->getValue($entity); if (null === $criteria[$fieldName]) { return; } if ($class->hasAssociation($fieldName)) { /* Ensure the Proxy is initialized before using reflection to * read its identifiers. This is necessary because the wrapped * getter methods in the Proxy are being bypassed. */ $em->initializeObject($criteria[$fieldName]); $relatedClass = $em->getClassMetadata($class->getAssociationTargetClass($fieldName)); $relatedId = $relatedClass->getIdentifierValues($criteria[$fieldName]); if (count($relatedId) > 1) { throw new ConstraintDefinitionException("Associated entities are not allowed to have more than one identifier field to be " . "part of a unique constraint in: " . $class->getName() . "#" . $fieldName); } $criteria[$fieldName] = array_pop($relatedId); } } $repository = $em->getRepository($className); $result = $repository->findBy($criteria); /* If the result is a MongoCursor, it must be advanced to the first * element. Rewinding should have no ill effect if $result is another * iterator implementation. */ if ($result instanceof \Iterator) { $result->rewind(); } /* If no entity matched the query criteria or a single entity matched, * which is the same as the entity being validated, the criteria is * unique. */ if (0 === count($result) || 1 === count($result) && $entity === ($result instanceof \Iterator ? $result->current() : current($result))) { return; } $this->context->addViolationAtSubPath($fields[0], $constraint->message, array(), $criteria[$fields[0]]); }
/** * Returns EntityManager for entity. * * @param Workflow $workflow * @param Attribute $attribute * @return EntityManager * @throws SerializerException */ protected function getEntityManager(Workflow $workflow, Attribute $attribute) { $entityClass = $attribute->getOption('class'); $result = $this->registry->getManagerForClass($entityClass); if (!$result) { throw new SerializerException(sprintf('Attribute "%s" of workflow "%s" contains object of "%s", but it\'s not managed entity class', $attribute->getName(), $workflow->getName(), $entityClass)); } return $result; }
/** * @param ConfigSettingsUpdateEvent $event */ public function onFormPreSetData(ConfigSettingsUpdateEvent $event) { $settingsKey = $this->getSettingsKey(); $settings = $event->getSettings(); if (is_array($settings) && array_key_exists($settingsKey, $settings)) { $settings[$settingsKey]['value'] = $this->registry->getManagerForClass($this->ownerClass)->find($this->ownerClass, $settings[$settingsKey]['value']); $event->setSettings($settings); } }
/** * Get choices list for unit field. * * @return array */ protected function getUnitChoices() { $choices = []; $units = $this->registry->getManagerForClass('OroB2BProductBundle:ProductUnit')->getRepository('OroB2BProductBundle:ProductUnit')->findAll(); foreach ($units as $unit) { $choices[$unit->getCode()] = $this->formatter->format($unit->getCode()); } return $choices; }
/** * @param string $entityClassName * @return EntityManager * @throws NotManageableEntityException */ protected function getEntityManager($entityClassName) { /** @var EntityManager $entityManager */ $entityManager = $this->registry->getManagerForClass($entityClassName); if (!$entityManager) { throw new NotManageableEntityException($entityClassName); } return $entityManager; }
/** * {@inheritdoc} */ public function filter($rawValue, $operator) { /** @var EntityManager $em */ $em = $this->registry->getManagerForClass($this->entityFQCN); if (null === $this->field) { return $em->getReference($this->entityFQCN, $rawValue); } else { return $em->getRepository($this->entityFQCN)->findOneBy([$this->field => $rawValue]); } }
private function tryLoadingDoctrineMetadata($className) { if (!($manager = $this->registry->getManagerForClass($className))) { return null; } if ($manager->getMetadataFactory()->isTransient($className)) { return null; } return $manager->getClassMetadata($className); }
/** * Process onResponse event, updates user history information * * @param FilterResponseEvent $event * * @return bool|null */ public function onResponse(FilterResponseEvent $event) { if (HttpKernel::MASTER_REQUEST != $event->getRequestType()) { // Do not do anything return null; } /** @var EntityManager $em */ $em = $this->registry->getManagerForClass($this->historyItemFQCN); $request = $event->getRequest(); $response = $event->getResponse(); $token = $this->securityContext->getToken(); $user = $organization = null; if ($token instanceof TokenInterface) { $user = $token->getUser(); } // check if a current request can be added to a history if (!$this->canAddToHistory($response, $request, $user)) { return false; } if ($token instanceof OrganizationContextTokenInterface) { $organization = $token->getOrganizationContext(); } $postArray = ['url' => $request->getRequestUri(), 'user' => $user, 'organization' => $organization]; /** @var $historyItem NavigationHistoryItem */ $historyItem = $em->getRepository($this->historyItemFQCN)->findOneBy($postArray); if (!$historyItem) { $routeParameters = $request->get('_route_params'); unset($routeParameters['id']); $entityId = filter_var($request->get('id'), FILTER_VALIDATE_INT); if (false !== $entityId) { $entityId = (int) $entityId; } else { $entityId = null; } $postArray['route'] = $request->get('_route'); $postArray['routeParameters'] = $routeParameters; $postArray['entityId'] = $entityId; /** @var $historyItem \Oro\Bundle\NavigationBundle\Entity\NavigationItemInterface */ $historyItem = $this->navItemFactory->createItem($this->navigationHistoryItemType, $postArray); } $historyItem->setTitle($this->titleService->getSerialized()); // force update $historyItem->doUpdate(); // disable Doctrine events for history item processing $eventManager = $em->getEventManager(); if ($eventManager instanceof OroEventManager) { $eventManager->disableListeners('^Oro'); } $em->persist($historyItem); $em->flush($historyItem); if ($eventManager instanceof OroEventManager) { $eventManager->clearDisabledListeners(); } return true; }
/** * Transforms a string (id) to an object (object). * * @param string $id * * @throws TransformationFailedException if object (object) is not found. * * @return object|null */ public function reverseTransform($id) { if (empty($id)) { return; } $object = $this->registry->getManagerForClass($this->class)->getRepository($this->class)->find($id); if (null === $object) { throw new TransformationFailedException(sprintf('Object from class %s with id "%s" not found', $this->class, $id)); } return $object; }