/** * Constructor. * * @param EntityManagerInterface $em * @param string $class * @param string $metaClass */ public function __construct(EntityManagerInterface $em, $class, $metaClass) { $this->em = $em; $this->repository = $em->getRepository($class); $this->class = $em->getClassMetadata($class)->name; $this->metaClass = $em->getClassMetadata($metaClass)->name; }
/** * {@inheritdoc} */ public function build(MetadataInterface $metadata, FormBuilderInterface $formBuilder, array $options) { $classMetadata = $this->entityManager->getClassMetadata($metadata->getClass('model')); if (1 < count($classMetadata->identifier)) { throw new \RuntimeException('The default form factory does not support entity classes with multiple primary keys.'); } $fields = (array) $classMetadata->fieldNames; if (!$classMetadata->isIdentifierNatural()) { $fields = array_diff($fields, $classMetadata->identifier); } foreach ($fields as $fieldName) { $options = []; if (in_array($fieldName, ['createdAt', 'updatedAt', 'deletedAt'])) { continue; } if (Type::DATETIME === $classMetadata->getTypeOfField($fieldName)) { $options = ['widget' => 'single_text']; } $formBuilder->add($fieldName, null, $options); } foreach ($classMetadata->getAssociationMappings() as $fieldName => $associationMapping) { if (ClassMetadataInfo::ONE_TO_MANY !== $associationMapping['type']) { $formBuilder->add($fieldName, null, ['property' => 'id']); } } }
public function testCanBePutInLazyLoadingMode() { $class = $this->_emMock->getClassMetadata('Doctrine\\Tests\\Models\\ECommerce\\ECommerceProduct'); $collection = new PersistentCollection($this->_emMock, $class, new ArrayCollection()); $collection->setInitialized(false); $this->assertFalse($collection->isInitialized()); }
public function deserializeRelation(JsonDeserializationVisitor $visitor, $relation, array $type, Context $context) { $className = isset($type['params'][0]['name']) ? $type['params'][0]['name'] : null; if (!class_exists($className)) { throw new \InvalidArgumentException('Class name should be explicitly set for deserialization'); } /** @var ClassMetadata $metadata */ $metadata = $this->manager->getClassMetadata($className); if (!is_array($relation)) { return $this->manager->getReference($className, $relation); } $single = false; if ($metadata->isIdentifierComposite) { $single = true; foreach ($metadata->getIdentifierFieldNames() as $idName) { $single = $single && array_key_exists($idName, $relation); } } if ($single) { return $this->manager->getReference($className, $relation); } $objects = []; foreach ($relation as $idSet) { $objects[] = $this->manager->getReference($className, $idSet); } return $objects; }
/** * update tables from array of entity classes * @param array $classes * @param bool $saveMode */ public function update(array $classes, $saveMode = true) { $metaClasses = array(); foreach ($classes as $class) { $metaClasses[] = $this->entityManager->getClassMetadata($class); } $this->tool->updateSchema($metaClasses, $saveMode); }
/** * @param object $entity * * @return ClassMetadata */ protected function getMetadataForEntity($entity) { $class = ClassUtils::getClass($entity); if (!isset($this->metadataCache[$class])) { $this->metadataCache[$class] = $this->entityManager->getClassMetadata($class); } return $this->metadataCache[$class]; }
public function setSectionHasChildren(Section $section = null, $pageCountModifier = 0) { if ($section !== null) { $repo = $this->entityManager->getRepository('BackBee\\CoreDomain\\NestedNode\\Page'); $notDeletedDescendants = $repo->getNotDeletedDescendants($section->getPage(), 1, false, [], true, 0, 2); $section->setHasChildren($notDeletedDescendants->getIterator()->count() + $pageCountModifier > 0); $this->entityManager->getUnitOfWork()->recomputeSingleEntityChangeSet($this->entityManager->getClassMetadata('BackBee\\CoreDomain\\NestedNode\\Section'), $section); } }
/** * @see MetadataCache::getMapping */ public function getMapping($className) { if (!is_string($className) && !is_object($className)) { throw new \Exception(self::ERROR_MAPPING_EXPECTED_VALUE); } $this->stringify($className); $metadata = $this->getMetadata($className); if (empty($metadata->mapping)) { $metadata->mapping = $this->entityManager->getClassMetadata($className); } return $metadata->mapping; }
/** * @param Request $request * @param ResourceInterface $resourceEmbed * @param $data * * @return \Doctrine\Common\Collections\Collection|PersistentCollection */ public function ApplyCriteria(Request $request, ResourceInterface $resourceEmbed, $data) { if ($data instanceof PersistentCollection && $data->count() > 0) { $embedClassMeta = $this->em->getClassMetadata($resourceEmbed->getEntityClass()); $criteria = Criteria::create(); foreach ($resourceEmbed->getFilters() as $filter) { if ($filter instanceof FilterInterface) { $this->applyFilter($request, $filter, $criteria, $embedClassMeta); $data = $data->matching($criteria); } } } return $data; }
/** * Determines the type of which filter class to instantiate, based on * the structured array received and the given entity class. * * @param FilterOptions $filterOptions * @param string $entity * * @return null|FilterInterface */ public function guessFilterTypeFromArray($filterOptions, $entity) { $filterType = null; /* in case the attribute to filter by is situated in another entity, parse the connected entities until you reach its entity */ if ($path = $filterOptions->getPathArray()) { while ($path) { $entity = $this->em->getClassMetadata($entity)->getAssociationMapping(array_shift($path))['targetEntity']; } } if ($filter = $this->filterFieldReader->getFilter($entity, $attribute = $filterOptions->getName())) { /* get the type of the attribute that corresponds to the filter */ $attributeType = isset($filter[$attribute]['options']['type']) ? $filter[$attribute]['options']['type'] : $this->em->getClassMetadata($entity)->getTypeOfField($filter[$attribute]['property']); $filterOptions->setAttribute($filter[$attribute]['property']); if (sizeof($filterOptions->getValues()) == 1) { switch ($attributeType) { case 'integer': $filterType = FilterInterface::NUMERIC_FILTER; break; case 'text': case 'string': $filterType = FilterInterface::STRING_FILTER; break; case 'date': $filterType = FilterInterface::DATE_FILTER; break; case 'checker': $filterType = FilterInterface::CHECK_FILTER; break; } } else { switch ($attributeType) { case 'integer': $filterType = FilterInterface::NUMERIC_INTERVAL_FILTER; break; case 'date': $filterType = FilterInterface::DATE_INTERVAL_FILTER; break; case 'string': $filterType = FilterInterface::OR_STRING_FILTER; break; case 'date_check': $filterType = FilterInterface::DATE_CHECK_FILTER; break; } } } return $filterType; }
/** * Retrieve ClassMetadata associated to entity class name. * * @param string $className * * @return \Doctrine\ORM\Mapping\ClassMetadata */ protected function getClassMetadata($className) { if (!isset($this->_metadataCache[$className])) { $this->_metadataCache[$className] = $this->_em->getClassMetadata($className); } return $this->_metadataCache[$className]; }
public function transform($value) { // already transformed (or null) if (is_array($value) || is_null($value)) { return $value; } if (!is_object($value)) { throw new TransformationFailedException(sprintf('Expected an object to transform, got "%s"', json_encode($value))); } // load object if it's a Proxy if ($value instanceof Proxy) { $value->__load(); } $meta = $this->entityManager->getClassMetadata(get_class($value)); return $meta->getIdentifierValues($value); }
/** * Return the field names of fields that had their value/relation changed * * @param EntityManagerInterface $em * @param mixed $entity * @param mixed $original * @return bool */ public function getMutatedFields(EntityManagerInterface $em, $entity, $original) { $mutation_data = []; /* @var $metadata \Doctrine\ORM\Mapping\ClassMetadata */ $metadata = $em->getClassMetadata(get_class($entity)); $fields = $metadata->getFieldNames(); $associations = $metadata->getAssociationNames(); if ($entity !== null && $original === null) { return array_merge($fields, $associations); } for ($i = 0, $n = count($fields); $i < $n; $i++) { $field = $fields[$i]; $left = $metadata->getFieldValue($entity, $field); $right = $metadata->getFieldValue($original, $field); if ($left !== $right) { $mutation_data[] = $field; } } for ($i = 0, $n = count($associations); $i < $n; $i++) { $association = $associations[$i]; $association_meta = $metadata->getAssociationMapping($association); if ($association_meta['type'] === ClassMetadataInfo::ONE_TO_ONE && !$association_meta['isOwningSide']) { continue; } $association_target_meta = $em->getClassMetadata($metadata->getAssociationTargetClass($association)); $association_value_left = $metadata->getFieldValue($entity, $association); $association_value_right = $metadata->getFieldValue($original, $association); if ($this->hasAssociationChanged($association_target_meta, $association_value_left, $association_value_right)) { $mutation_data[] = $association; } } return $mutation_data; }
/** * Generates the Select clause from this ResultSetMappingBuilder. * * Works only for all the entity results. The select parts for scalar * expressions have to be written manually. * * @param array $tableAliases * * @return string */ public function generateSelectClause($tableAliases = array()) { $sql = ""; foreach ($this->columnOwnerMap as $columnName => $dqlAlias) { $tableAlias = isset($tableAliases[$dqlAlias]) ? $tableAliases[$dqlAlias] : $dqlAlias; if ($sql) { $sql .= ", "; } $sql .= $tableAlias . "."; if (isset($this->fieldMappings[$columnName])) { $class = $this->em->getClassMetadata($this->declaringClasses[$columnName]); $sql .= $class->fieldMappings[$this->fieldMappings[$columnName]]['columnName']; } else { if (isset($this->metaMappings[$columnName])) { $sql .= $this->metaMappings[$columnName]; } else { if (isset($this->discriminatorColumn[$columnName])) { $sql .= $this->discriminatorColumn[$columnName]; } } } $sql .= " AS " . $columnName; } return $sql; }
private function prepare($data) { $metaDataClass = $this->entityManager->getClassMetadata(get_class($data)); $assocFields = $metaDataClass->getAssociationMappings(); foreach ($assocFields as $assoc) { $relatedEntities = $metaDataClass->reflFields[$assoc['fieldName']]->getValue($data); if ($relatedEntities instanceof Collection) { if ($relatedEntities === $metaDataClass->reflFields[$assoc['fieldName']]->getValue($data)) { continue; } if ($relatedEntities instanceof PersistentCollection) { // Unwrap so that foreach() does not initialize $relatedEntities = $relatedEntities->unwrap(); } foreach ($relatedEntities as $relatedEntity) { $relatedEntitiesState = $this->entityManager->getUnitOfWork()->getEntityState($relatedEntities); if ($relatedEntitiesState === UnitOfWork::STATE_DETACHED) { $metaDataClass->setFieldValue($data, $assoc['fieldName'], $this->entityManager->merge($relatedEntity)); } } } else { if ($relatedEntities !== null) { $relatedEntitiesState = $this->entityManager->getUnitOfWork()->getEntityState($relatedEntities); if ($relatedEntitiesState === UnitOfWork::STATE_DETACHED) { $metaDataClass->setFieldValue($data, $assoc['fieldName'], $this->entityManager->merge($relatedEntities)); } } } } }
/** * 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 $entityManager * @param $className * @return mixed */ protected function generateRepository(EntityManagerInterface $entityManager, $className) { $classMetadata = $entityManager->getClassMetadata($className); $baseRepository = new EntityRepository($entityManager, $classMetadata); $repositoryClass = static::REPOSITORY_CLASS; $repository = new $repositoryClass($entityManager, $baseRepository, $classMetadata, $this->queryCollection); return $repository; }
/** * Allows to translate entity namespaces to full qualified names. * * @param Query\ResultSetMapping $rsm * * @return void */ private function translateNamespaces(Query\ResultSetMapping $rsm) { $translate = function ($alias) { return $this->_em->getClassMetadata($alias)->getName(); }; $rsm->aliasMap = array_map($translate, $rsm->aliasMap); $rsm->declaringClasses = array_map($translate, $rsm->declaringClasses); }
/** * @param EntityManagerInterface $entityManager * @param string $entityName * * @return ObjectRepository */ protected function createRepository(EntityManagerInterface $entityManager, $entityName) { $metadata = $entityManager->getClassMetadata($entityName); $repository = $metadata->customRepositoryClassName; if ($repository === null) { $repository = $entityManager->getConfiguration()->getDefaultRepositoryClassName(); } return $this->createResourceRepository($repository, $entityManager, $metadata, $this->resolveResource($metadata->getName())); }
/** * @return \Doctrine\ORM\Cache\TimestampCacheKey|null */ private function getTimestampKey() { $entityName = reset($this->_resultSetMapping->aliasMap); if (empty($entityName)) { return null; } $metadata = $this->_em->getClassMetadata($entityName); return new Cache\TimestampCacheKey($metadata->getTableName()); }
/** * @param object $object * * @return object */ private function reFetchObject($object) { $metadata = $this->entityManager->getClassMetadata(get_class($object)); $freshValue = $this->entityManager->find($metadata->getName(), $metadata->getIdentifierValues($object)); if (!$freshValue) { throw MissingBatchItemException::fromInvalidReference($metadata, $object); } return $freshValue; }
/** * {@inheritdoc} */ public function evictCollectionRegion($className, $association) { $metadata = $this->em->getClassMetadata($className); $persister = $this->uow->getCollectionPersister($metadata->getAssociationMapping($association)); if (!$persister instanceof CachedPersister) { return; } $persister->getCacheRegion()->evictAll(); }
/** * Marks this collection as changed/dirty. * * @return void */ private function changed() { if ($this->isDirty) { return; } $this->isDirty = true; if ($this->association !== null && $this->association['isOwningSide'] && $this->association['type'] === ClassMetadata::MANY_TO_MANY && $this->owner && $this->em->getClassMetadata(get_class($this->owner))->isChangeTrackingNotify()) { $this->em->getUnitOfWork()->scheduleForDirtyCheck($this->owner); } }
/** * 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 */ protected function createRepository(EntityManagerInterface $entityManager, $entityName) { $metadata = $entityManager->getClassMetadata($entityName); $repositoryClassName = $metadata->customRepositoryClassName; if ($repositoryClassName === null) { $configuration = $entityManager->getConfiguration(); $repositoryClassName = $configuration->getDefaultRepositoryClassName(); } return new $repositoryClassName($entityManager, $metadata); }
public function setUp() { $config = new \Doctrine\ORM\Configuration(); $config->setMetadataCacheImpl(new \Doctrine\Common\Cache\ArrayCache()); $config->setQueryCacheImpl(new \Doctrine\Common\Cache\ArrayCache()); $config->setProxyDir(__DIR__ . '/Proxies'); $config->setProxyNamespace('DoctrineExtensions\\Tests\\Proxies'); $config->setAutoGenerateProxyClasses(true); $config->setMetadataDriverImpl($config->newDefaultAnnotationDriver(__DIR__ . '/../Entities')); $config->setCustomDatetimeFunctions(array('YEAR' => 'DoctrineExtensions\\Query\\Sqlite\\Year', 'WEEKDAY' => 'DoctrineExtensions\\Query\\Sqlite\\WeekDay', 'WEEK' => 'DoctrineExtensions\\Query\\Sqlite\\Week', 'Month' => 'DoctrineExtensions\\Query\\Sqlite\\Month', 'MINUTE' => 'DoctrineExtensions\\Query\\Sqlite\\Minute', 'HOUR' => 'DoctrineExtensions\\Query\\Sqlite\\Hour', 'DAY' => 'DoctrineExtensions\\Query\\Sqlite\\Day', 'DATE' => 'DoctrineExtensions\\Query\\Sqlite\\Date', 'STRFTIME' => 'DoctrineExtensions\\Query\\Sqlite\\StrfTime', 'DATE_FORMAT' => 'DoctrineExtensions\\Query\\Sqlite\\DateFormat')); $this->entityManager = \Doctrine\ORM\EntityManager::create(array('driver' => 'pdo_sqlite', 'memory' => true), $config); $configuration = $this->entityManager->getConfiguration(); if (method_exists($configuration, 'getQuoteStrategy') === false) { // doctrine < 2.3 $this->columnAlias = 'sclr0'; } else { $this->columnAlias = $configuration->getQuoteStrategy()->getColumnAlias('sclr', 0, $this->entityManager->getConnection()->getDatabasePlatform(), $this->entityManager->getClassMetadata('DoctrineExtensions\\Tests\\Entities\\Date')); } }
/** * 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 ObjectRepository */ private function createRepository(EntityManagerInterface $entityManager, $entityName) { /* @var $metadata ClassMetadata */ $metadata = $entityManager->getClassMetadata($entityName); $repositoryClassName = $metadata->customRepositoryClassName ?: $entityManager->getConfiguration()->getDefaultRepositoryClassName(); $result = new $repositoryClassName($entityManager, $metadata); if ($result instanceof ContainerAwareInterface) { $result->setContainer($this->container); } return $result; }
/** * {@inheritdoc} */ public function getRepository(EntityManagerInterface $entityManager, $entityName) { if (isset($this->ids[$entityName])) { return $this->container->get($this->ids[$entityName]); } $metadata = $entityManager->getClassMetadata($entityName); $entityNamespace = $metadata->getName(); if (is_subclass_of($entityNamespace, '\\Util\\Doctrine\\Entity\\EntityInterface', true)) { return new EnhancedRepository($entityManager, $metadata); } return $this->default->getRepository($entityManager, $entityName); }
/** * Gets the repository 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 */ public function getRepository(EntityManagerInterface $entityManager, $entityName) { if ($this->entityRepositoryManager->has($entityName)) { $repository = $this->entityRepositoryManager->get($entityName); } else { $entityMetadata = $entityManager->getClassMetadata($entityName); $className = $entityManager->getConfiguration()->getDefaultRepositoryClassName(); /** @var EntityRepository $defaultRepository */ $repository = new $className($entityManager, $entityMetadata); } return $repository; }
public function testToIdentifierArrayShouldLookupForEntityIdentifier() { $identifier = 123; $entity = new Country('Foo'); $metadata = $this->em->getClassMetadata(Country::CLASSNAME); $method = new \ReflectionMethod($this->cache, 'toIdentifierArray'); $property = new \ReflectionProperty($entity, 'id'); $property->setAccessible(true); $method->setAccessible(true); $property->setValue($entity, $identifier); $this->assertEquals(array('id' => $identifier), $method->invoke($this->cache, $metadata, $identifier)); }
public function getEntityHistory($className, $id) { if (!$this->metadataFactory->isAudited($className)) { throw new NotAuditedException($className); } /** @var ClassMetadataInfo|ClassMetadata $class */ $class = $this->em->getClassMetadata($className); $tableName = $this->config->getTableName($class); if (!is_array($id)) { $id = array($class->identifier[0] => $id); } $whereId = array(); foreach ($class->identifier as $idField) { if (isset($class->fieldMappings[$idField])) { $columnName = $class->fieldMappings[$idField]['columnName']; } else { if (isset($class->associationMappings[$idField])) { $columnName = $class->associationMappings[$idField]['joinColumns'][0]; } else { continue; } } $whereId[] = "{$columnName} = ?"; } $whereSQL = implode(' AND ', $whereId); $columnList = array($this->config->getRevisionFieldName()); $columnMap = array(); foreach ($class->fieldNames as $columnName => $field) { $type = Type::getType($class->fieldMappings[$field]['type']); $columnList[] = $type->convertToPHPValueSQL($class->getQuotedColumnName($field, $this->platform), $this->platform) . ' AS ' . $this->platform->quoteSingleIdentifier($field); $columnMap[$field] = $this->platform->getSQLResultCasing($columnName); } foreach ($class->associationMappings as $assoc) { if (($assoc['type'] & ClassMetadata::TO_ONE) == 0 || !$assoc['isOwningSide']) { continue; } foreach ($assoc['targetToSourceKeyColumns'] as $sourceCol) { $columnList[] = $sourceCol; $columnMap[$sourceCol] = $this->platform->getSQLResultCasing($sourceCol); } } $values = array_values($id); $query = "SELECT " . implode(', ', $columnList) . " FROM " . $tableName . " e WHERE " . $whereSQL . " ORDER BY e.rev DESC"; $stmt = $this->em->getConnection()->executeQuery($query, $values); $result = array(); while ($row = $stmt->fetch(Query::HYDRATE_ARRAY)) { $rev = $row[$this->config->getRevisionFieldName()]; unset($row[$this->config->getRevisionFieldName()]); $result[] = $this->createEntity($class->name, $row, $rev); } return $result; }