PHP ManagerRegistry::getManagerForClass方法代码示例

 /**
  * @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];
 }

 /**
  * @return ObjectRepository
  */
 protected function getLoginPageRepository()
 {
     if (!$this->loginPageRepository) {
         $this->loginPageRepository = $this->doctrine->getManagerForClass('OroB2BCMSBundle:LoginPage')->getRepository('OroB2BCMSBundle:LoginPage');
     }
     return $this->loginPageRepository;
 }

 /**
  * 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;
 }