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