/** * {@inheritdoc} */ public function supports(PuliResource $resource) { if (false === $resource instanceof CmfResource) { return false; } return $this->metadataFactory->hasMetadataFor(ClassUtils::getRealClass($resource->getPayloadType())); }
/** * {@inheritDoc} */ public function boot() { // Register an autoloader for proxies to avoid issues when unserializing them // when the ORM is used. if ($this->container->hasParameter('doctrine.orm.proxy_namespace')) { $namespace = $this->container->getParameter('doctrine.orm.proxy_namespace'); $dir = $this->container->getParameter('doctrine.orm.proxy_dir'); $proxyGenerator = null; if ($this->container->getParameter('doctrine.orm.auto_generate_proxy_classes')) { // See https://github.com/symfony/symfony/pull/3419 for usage of references $container =& $this->container; $proxyGenerator = function ($proxyDir, $proxyNamespace, $class) use(&$container) { $originalClassName = ClassUtils::getRealClass($class); /** @var $registry Registry */ $registry = $container->get('doctrine'); // Tries to auto-generate the proxy file /** @var $em \Doctrine\ORM\EntityManager */ foreach ($registry->getManagers() as $em) { if (!$em->getConfiguration()->getAutoGenerateProxyClasses()) { continue; } $metadataFactory = $em->getMetadataFactory(); if ($metadataFactory->isTransient($originalClassName)) { continue; } $classMetadata = $metadataFactory->getMetadataFor($originalClassName); $em->getProxyFactory()->generateProxyClasses(array($classMetadata)); clearstatcache(true, Autoloader::resolveFile($proxyDir, $proxyNamespace, $class)); break; } }; } $this->autoloader = Autoloader::register($dir, $namespace, $proxyGenerator); } }
public static function getRealClass($class) { if (class_exists('Doctrine\\Common\\Util\\ClassUtils')) { $class = DoctrineClassUtils::getRealClass($class); } return $class; }
public function resultatsLinkTerritoire($territoire) { switch (ClassUtils::getRealClass(get_class($territoire))) { case 'AppBundle\\Domain\\Territoire\\Entity\\Territoire\\CirconscriptionEuropeenne': $route = 'resultat_circo_europeenne'; $parameters = array('code' => $territoire->getCode(), 'nom' => $this->slugify->slugify($territoire->getNom())); break; case 'AppBundle\\Domain\\Territoire\\Entity\\Territoire\\Commune': $route = 'resultat_commune'; $parameters = array('departement' => $territoire->getDepartement()->getCode(), 'code' => $territoire->getCode(), 'nom' => $this->slugify->slugify($territoire->getNom())); break; case 'AppBundle\\Domain\\Territoire\\Entity\\Territoire\\Departement': $route = 'resultat_departement'; $parameters = array('code' => $territoire->getCode(), 'nom' => $this->slugify->slugify($territoire->getNom())); break; case 'AppBundle\\Domain\\Territoire\\Entity\\Territoire\\Pays': $route = 'resultat_france'; $parameters = array(); break; case 'AppBundle\\Domain\\Territoire\\Entity\\Territoire\\Region': $route = 'resultat_region'; $parameters = array('code' => $territoire->getCode(), 'nom' => $this->slugify->slugify($territoire->getNom())); break; } if (isset($route, $parameters)) { return $this->router->generate($route, $parameters); } return ''; }
/** * {@inheritDoc} * * use getRealClass if className names a doctrine proxy class. */ public function canonicalName($className) { $refl = new \ReflectionClass($className); if (in_array('Doctrine\\Common\\Persistence\\Proxy', $refl->getInterfaceNames())) { $className = \Doctrine\Common\Util\ClassUtils::getRealClass($className); } return $className; }
/** * @param $entity * @return string */ public function getOwnerType($entity) { $ownerClassName = ClassUtils::getRealClass(get_class($entity)); if (!$this->configProvider->hasConfig($ownerClassName)) { return; } $config = $this->configProvider->getConfig($ownerClassName)->all(); return $config['owner_type']; }
/** * Get real class name of a reference that could be a proxy * * @param string $className Class name of reference object * * @return string */ protected function getRealClass($className) { if (Version::compare('2.2.0') <= 0) { return ClassUtils::getRealClass($className); } if (substr($className, -5) === 'Proxy') { return substr($className, 0, -5); } return $className; }
/** * * @param type $translatableClass * @return type */ private function getGedmoConfig($translatableClass) { if (isset($this->gedmoConfig[$translatableClass])) { return $this->gedmoConfig[$translatableClass]; } $translatableClass = \Doctrine\Common\Util\ClassUtils::getRealClass($translatableClass); $manager = $this->getManagerRegistry()->getManagerForClass($translatableClass); $this->gedmoConfig[$translatableClass] = $this->gedmoTranslatableListener->getConfiguration($manager, $translatableClass); return $this->gedmoConfig[$translatableClass]; }
/** * Gets a real class name for an entity. * * @param object|string $entityOrClass An entity object, entity class name or entity proxy class name * * @return string */ public function getEntityClass($entityOrClass) { if (is_object($entityOrClass)) { return ClassUtils::getClass($entityOrClass); } if (strpos($entityOrClass, ':') !== false) { list($namespaceAlias, $simpleClassName) = explode(':', $entityOrClass, 2); return $this->registry->getAliasNamespace($namespaceAlias) . '\\' . $simpleClassName; } return ClassUtils::getRealClass($entityOrClass); }
protected function markDirty(Identified $entity, array $data = []) { if (empty($entity->getId())) { throw new InvalidArgumentException('Entity has no identifier'); } $class = ClassUtils::getRealClass(get_class($entity)); $this->dirtyEntities[$class][$entity->getId()] = $data; if ($this->autoFlush) { $this->flushSync(); } }
public function createClassIdentity($className) { $className = ClassUtils::getRealClass($className); if (isset($this->classCache[$className])) { return $this->classCache[$className]; } if (null !== ($this->classCache[$className] = $this->classRepository->findOneByName($className))) { return $this->classCache[$className]; } $classClass = $this->classRepository->getClassName(); return $this->classCache[$className] = new $classClass($className); }
/** * Gets the real class name of a class name that could be a proxy. * * @param string|object $object * * @return string */ public static function getRealClass($object) { $class = is_object($object) ? get_class($object) : $object; if (class_exists('Doctrine\\Common\\Util\\ClassUtils')) { return DoctrineClassUtils::getRealClass($class); } // fallback in case doctrine common is not installed if (false === ($pos = strrpos($class, '\\' . self::MARKER . '\\'))) { return $class; } return substr($class, $pos + self::MARKER_LENGTH + 2); }
/** * Create new * * @return Response */ public function handleCreateRequest() { $entity = $this->getManager()->createEntity(); $isProcessed = $this->processForm($entity); if ($isProcessed) { $entityClass = ClassUtils::getRealClass(get_class($entity)); $classMetadata = $this->getManager()->getObjectManager()->getClassMetadata($entityClass); $view = $this->view($classMetadata->getIdentifierValues($entity), Codes::HTTP_CREATED); } else { $view = $this->view($this->getForm(), Codes::HTTP_BAD_REQUEST); } return $this->handleView($view); }
/** * * @param type $translationClass * @return type */ protected function getTranslatableFields($translationClass) { $translationClass = \Doctrine\Common\Util\ClassUtils::getRealClass($translationClass); $manager = $this->getManagerRegistry()->getManagerForClass($translationClass); $metadataClass = $manager->getMetadataFactory()->getMetadataFor($translationClass); $fields = array(); foreach ($metadataClass->fieldMappings as $fieldMapping) { if (!in_array($fieldMapping['fieldName'], array('id', 'locale'))) { $fields[] = $fieldMapping['fieldName']; } } return $fields; }
/** * @param EntityManagerInterface|EntityManager $entityManager * @param string $entityName * @return EntityRepository */ public function getRepository(EntityManagerInterface $entityManager, $entityName) { if (is_object($entityName)) { $entityName = Doctrine\Common\Util\ClassUtils::getRealClass(get_class($entityName)); } $entityName = ltrim($entityName, '\\'); if (isset($this->repositoryList[$emId = spl_object_hash($entityManager)][$entityName])) { return $this->repositoryList[$emId][$entityName]; } /** @var Doctrine\ORM\Mapping\ClassMetadata $metadata */ $metadata = $entityManager->getClassMetadata($entityName); $repository = $this->createRepository($entityManager, $metadata); return $this->repositoryList[$emId][$entityName] = $repository; }
/** * * @param string $translationClass * @param array $exclude * @return array */ protected function getTranslationFields($translationClass, array $exclude = array()) { $fields = array(); $translationClass = ClassUtils::getRealClass($translationClass); if ($manager = $this->managerRegistry->getManagerForClass($translationClass)) { $metadataClass = $manager->getMetadataFactory()->getMetadataFor($translationClass); foreach ($metadataClass->fieldMappings as $fieldMapping) { if (!in_array($fieldMapping['fieldName'], array('id', 'locale')) && !in_array($fieldMapping['fieldName'], $exclude)) { $fields[] = $fieldMapping['fieldName']; } } } return $fields; }
/** * {@inheritdoc} */ public function guessValues(UrlInformation $urlInformation, $object, $sitemap) { if (null !== $urlInformation->getDepth()) { return; } $manager = $this->managerRegistry->getManagerForClass(ClassUtils::getRealClass(get_class($object))); if (!$manager instanceof DocumentManager) { return; } $node = $manager->getNodeForDocument($object); if (null === $node) { return; } $urlInformation->setDepth($node->getDepth() - $this->offset); }
/** * @param FormInterface $form * * @return string */ private function getDataClass(FormInterface $form) { // Simple case, data_class from current form if ($dataClass = $form->getConfig()->getDataClass()) { return ClassUtils::getRealClass($dataClass); } // Advanced case, loop parent form to get closest fill data_class while ($formParent = $form->getParent()) { if (!($dataClass = $formParent->getConfig()->getDataClass())) { $form = $formParent; continue; } return $this->objectInfo->getAssociationTargetClass($dataClass, $form->getName()); } }
/** * @return TranslationInterface */ public function getTranslation() { $locale = null === $this->locale ? \Locale::getDefault() : $this->locale; $translations = $this->translatable->getTranslations(); if (isset($translations[$locale])) { return $translations[$locale]; } elseif (isset($translations[substr($locale, 0, strpos($locale, '_'))])) { return $translations[substr($locale, 0, strpos($locale, '_'))]; } $class = get_class($this->translatable); if ($this->translatable instanceof \Doctrine\Common\Persistence\Proxy) { $class = \Doctrine\Common\Util\ClassUtils::getRealClass($class); } $translationClass = $this->getTranslationClassName($class); return $this->createTranslation($translationClass, $locale); }
/** * Return a HAL entity with just a self link */ public function extract($value) { if (is_null($value)) { return $value; } $entityValues = $this->getHydratorForEntity($value)->extract($value); $entityMetadata = $this->getMetadataMap()[ClassUtils::getRealClass(get_class($value))]; $link = new Link('self'); $link->setRoute($entityMetadata['route_name']); $link->setRouteParams(array($entityMetadata['route_identifier_name'] => $entityValues[$entityMetadata['entity_identifier_name']])); $linkCollection = new LinkCollection(); $linkCollection->add($link); $halEntity = new HalEntity(new stdClass()); $halEntity->setLinks($linkCollection); return $halEntity; }
/** * {@inheritdoc} */ public function resolveComponentData(ResolveComponentModelIdentifier $resolve) { $model = $resolve->getModel(); $identifier = $resolve->getIdentifier(); $data = null; if (is_object($model)) { $data = $model; $modelClass = get_class($model); if (!method_exists($model, 'getId')) { throw new ResolveComponentDataException('Model must have a getId method'); } $identifier = $model->getId(); $model = $modelClass; } $model = ClassUtils::getRealClass($model); return new ResolvedComponentData($model, $identifier, $data); }
public function boot() { // force Doctrine annotations to be loaded // should be removed when a better solution is found in Doctrine class_exists('Doctrine\\ORM\\Mapping\\Driver\\AnnotationDriver'); // Register an autoloader for proxies to avoid issues when unserializing them // when the ORM is used. if ($this->container->hasParameter('doctrine.orm.proxy_namespace')) { $namespace = $this->container->getParameter('doctrine.orm.proxy_namespace'); $dir = $this->container->getParameter('doctrine.orm.proxy_dir'); $container =& $this->container; $this->autoloader = function ($class) use($namespace, $dir, &$container) { if (0 === strpos($class, $namespace)) { $className = substr($class, strlen($namespace) + 1); $file = $dir . DIRECTORY_SEPARATOR . str_replace('\\', '', $className) . '.php'; if (!file_exists($file) && $container->getParameter('kernel.debug')) { $registry = $container->get('doctrine'); if (1 === Version::compare('2.2.0')) { $originalClassName = substr($className, 0, -5); } else { $originalClassName = ClassUtils::getRealClass($className); $originalClassName = str_replace('\\', '', $originalClassName); } // Tries to auto-generate the proxy file foreach ($registry->getEntityManagers() as $em) { if ($em->getConfiguration()->getAutoGenerateProxyClasses()) { $classes = $em->getMetadataFactory()->getAllMetadata(); foreach ($classes as $class) { $name = str_replace('\\', '', $class->name); if ($name == $originalClassName) { $em->getProxyFactory()->generateProxyClasses(array($class)); } } } } clearstatcache($file); if (!file_exists($file)) { throw new \RuntimeException(sprintf('The proxy file "%s" does not exist. If you still have objects serialized in the session, you need to clear the session manually.', $file)); } } require $file; } }; spl_autoload_register($this->autoloader); } }
private function doUpdate(ClassMetadataFactory $metadataFactory, PhpcrMetadata $odmMetadata, CtMetadata $ctMetadata, $document) { $documentId = $odmMetadata->getIdentifierValue($document); foreach ($odmMetadata->childrenMappings as $childrenField) { // if the children field is not managed by the CT component, // continue if (!isset($ctMetadata->propertyMetadata[$childrenField])) { continue; } $children = $odmMetadata->getFieldValue($document, $childrenField); // note that we do not preserve array keys. PHPCR ODM will return a // children collection using the PHPCR property names as keys, so // we currently have no control over how these keys populated. $index = 0; foreach ($children as $child) { $childMetadata = $metadataFactory->getMetadataFor(ClassUtils::getRealClass(get_class($child))); $newId = sprintf('%s/%s', $documentId, $this->encoder->encode($childrenField, $index++)); $childMetadata->setIdentifierValue($child, $newId); } } }
/** * {@inheritDoc} */ public function boot() { // Register an autoloader for proxies to avoid issues when unserializing them // when the ORM is used. if ($this->container->hasParameter('doctrine.orm.proxy_namespace')) { $namespace = $this->container->getParameter('doctrine.orm.proxy_namespace'); $dir = $this->container->getParameter('doctrine.orm.proxy_dir'); // See https://github.com/symfony/symfony/pull/3419 for usage of // references $container =& $this->container; $this->autoloader = function ($class) use($namespace, $dir, &$container) { if (0 === strpos($class, $namespace)) { $fileName = str_replace('\\', '', substr($class, strlen($namespace) + 1)); $file = $dir . DIRECTORY_SEPARATOR . $fileName . '.php'; if (!is_file($file) && $container->getParameter('kernel.debug')) { $originalClassName = ClassUtils::getRealClass($class); /** @var $registry Registry */ $registry = $container->get('doctrine'); // Tries to auto-generate the proxy file /** @var $em \Doctrine\ORM\EntityManager */ foreach ($registry->getManagers() as $em) { if ($em->getConfiguration()->getAutoGenerateProxyClasses()) { $classes = $em->getMetadataFactory()->getAllMetadata(); foreach ($classes as $classMetadata) { if ($classMetadata->name == $originalClassName) { $em->getProxyFactory()->generateProxyClasses(array($classMetadata)); } } } } clearstatcache($file); } if (file_exists($file)) { require $file; } } }; spl_autoload_register($this->autoloader); } }
public function prePersist(LifecycleEventArgs $args) { $document = $args->getObject(); $metadataFactory = $args->getObjectManager()->getMetadataFactory(); $odmMetadata = $metadataFactory->getMetadataFor(ClassUtils::getRealClass(get_class($document))); if (null === ($ctMetadata = $this->metadataFactory->getMetadataForClass($odmMetadata->getName()))) { return; } foreach ($odmMetadata->childrenMappings as $childrenField) { // if the children field is not managed by the CT component, // continue if (!isset($ctMetadata->propertyMetadata[$childrenField])) { continue; } $childCtMetadata = $ctMetadata->propertyMetadata[$childrenField]; $children = $odmMetadata->getFieldValue($document, $childrenField); if (!$children) { continue; } $this->stack[] = ['children' => $children, 'ct_metadata' => $childCtMetadata, 'field' => $childrenField]; } }
/** * Updates UrlInformation with new values if they are not already set. * * @param UrlInformation $urlInformation The value object to update. * @param object $object The sitemap element to get values from. * @param string $sitemap Name of the sitemap being built. */ public function guessValues(UrlInformation $urlInformation, $object, $sitemap) { if (null !== $urlInformation->getLastModification()) { return; } $className = ClassUtils::getRealClass(get_class($object)); $manager = $this->managerRegistry->getManagerForClass($className); if (!$manager instanceof DocumentManager) { return; } /** @var ClassMetadata $metadata */ $metadata = $manager->getClassMetadata($className); $mixins = $metadata->getMixins(); if (!in_array('mix:lastModified', $mixins)) { return; } $fieldName = $this->getFieldName($metadata); if (null === $fieldName) { return; } $urlInformation->setLastModification($metadata->getFieldValue($object, $fieldName)); }
/** * @param mixed $data * @param bool $includeCollectionTag * @param bool $processNestedData * * @return array */ protected function getTags($data, $includeCollectionTag, $processNestedData) { $tags = []; if (is_object($data)) { $class = ClassUtils::getClass($data); /** @var EntityManager $em */ $em = $this->doctrine->getManagerForClass($class); $uow = $em->getUnitOfWork(); // tag only in case if it's not a new object if ($this->isNewEntity($data, $uow)) { $tags[] = implode('_', array_merge([$this->convertToTag($class)], $uow->getEntityIdentifier($data))); if ($processNestedData) { $tags = array_merge($tags, $this->collectNestedDataTags($data, $em->getClassMetadata($class))); } } } else { $class = ClassUtils::getRealClass($data); } if ($includeCollectionTag) { $tags[] = $this->convertToTag($class) . self::COLLECTION_SUFFIX; } return $tags; }
/** * @param string $entityClass * * @return array */ protected function getEntityVariableGetters($entityClass) { $entityClass = ClassUtils::getRealClass($entityClass); if (!$this->emailConfigProvider->hasConfig($entityClass)) { return []; } $result = []; $reflClass = new \ReflectionClass($entityClass); $fieldConfigs = $this->emailConfigProvider->getConfigs($entityClass); foreach ($fieldConfigs as $fieldConfig) { if (!$fieldConfig->is('available_in_template')) { continue; } /** @var FieldConfigId $fieldId */ $fieldId = $fieldConfig->getId(); list($varName, $getter) = $this->getFieldAccessInfo($reflClass, $fieldId->getFieldName()); if (!$varName) { continue; } $resultGetter = $getter; $formatters = $this->formatterManager->guessFormatters($fieldId); if ($formatters && count($formatters)) { $resultGetter = array_merge(['property_path' => $getter], $formatters); } $result[$varName] = $resultGetter; } return $result; }
/** * {@inheritdoc} */ public function hasClassMetadataForEntity($object) { $className = ClassUtils::getRealClass(get_class($object)); return $this->getMetadataFactory()->hasMetadataFor($className); }
/** * Gets the class metadata descriptor for a class. * * @param string $className The name of the class. * * @return ClassMetadata * * @throws ReflectionException * @throws MappingException */ public function getMetadataFor($className) { if (isset($this->loadedMetadata[$className])) { return $this->loadedMetadata[$className]; } // Check for namespace alias if (strpos($className, ':') !== false) { list($namespaceAlias, $simpleClassName) = explode(':', $className, 2); $realClassName = $this->getFqcnFromAlias($namespaceAlias, $simpleClassName); } else { $realClassName = ClassUtils::getRealClass($className); } if (isset($this->loadedMetadata[$realClassName])) { // We do not have the alias name in the map, include it return $this->loadedMetadata[$className] = $this->loadedMetadata[$realClassName]; } $loadingException = null; try { if ($this->cacheDriver) { if (($cached = $this->cacheDriver->fetch($realClassName . $this->cacheSalt)) !== false) { $this->loadedMetadata[$realClassName] = $cached; $this->wakeupReflection($cached, $this->getReflectionService()); } else { foreach ($this->loadMetadata($realClassName) as $loadedClassName) { $this->cacheDriver->save($loadedClassName . $this->cacheSalt, $this->loadedMetadata[$loadedClassName], null); } } } else { $this->loadMetadata($realClassName); } } catch (MappingException $loadingException) { if (!($fallbackMetadataResponse = $this->onNotFoundMetadata($realClassName))) { throw $loadingException; } $this->loadedMetadata[$realClassName] = $fallbackMetadataResponse; } if ($className !== $realClassName) { // We do not have the alias name in the map, include it $this->loadedMetadata[$className] = $this->loadedMetadata[$realClassName]; } return $this->loadedMetadata[$className]; }