/**
* @param OrmConfiguration $configuration
*/
public function addEntityNamespaces(OrmConfiguration $configuration)
{
$this->knownNamespaceAlias = array_merge($this->knownNamespaceAlias, $configuration->getEntityNamespaces());
if ($configuration->getMetadataDriverImpl()) {
$this->entityClassnames = array_merge($this->entityClassnames, $configuration->getMetadataDriverImpl()->getAllClassNames());
}
}
public function testSetGetMetadataDriverImpl()
{
$this->assertSame(null, $this->configuration->getMetadataDriverImpl());
// defaults
$metadataDriver = $this->getMock('Doctrine\\Common\\Persistence\\Mapping\\Driver\\MappingDriver');
$this->configuration->setMetadataDriverImpl($metadataDriver);
$this->assertSame($metadataDriver, $this->configuration->getMetadataDriverImpl());
}
/**
* Set the association mappings of a metadata.
*
* @param ClassMetadataInfo $metadata
* @param Configuration $configuration
*/
protected function setAssociationMappings(ClassMetadataInfo $metadata, Configuration $configuration)
{
$supportedClasses = $configuration->getMetadataDriverImpl()->getAllClassNames();
foreach (class_parents($metadata->getName()) as $parent) {
if (in_array($parent, $supportedClasses)) {
$parentMetadata = new OrmClassMetadata($parent, $configuration->getNamingStrategy());
$configuration->getMetadataDriverImpl()->loadMetadataForClass($parent, $parentMetadata);
foreach ($parentMetadata->getAssociationMappings() as $key => $value) {
if ($this->hasRelation($value['type'])) {
$metadata->associationMappings[$key] = $value;
}
}
}
}
}
/**
* {@inheritdoc}
*/
public static function create($conn, Configuration $config, EventManager $eventManager = null)
{
if (!$config->getMetadataDriverImpl()) {
throw ORMException::missingMappingDriverImpl();
}
switch (true) {
case is_array($conn):
if (!$eventManager) {
$eventManager = new EventManager();
}
if (isset($conn['prefix']) && $conn['prefix']) {
$eventManager->addEventListener(Events::loadClassMetadata, new TablePrefix($conn['prefix']));
}
$conn = \Doctrine\DBAL\DriverManager::getConnection($conn, $config, $eventManager);
break;
case $conn instanceof Connection:
if ($eventManager !== null && $conn->getEventManager() !== $eventManager) {
throw ORMException::mismatchedEventManager();
}
break;
default:
throw new \InvalidArgumentException("Invalid argument: " . $conn);
}
return new self($conn, $config, $conn->getEventManager());
}
/**
* @param ClassMetadataInfo $metadata
* @param \Doctrine\ORM\Configuration $configuration
*/
private function setAssociationMappings(ClassMetadataInfo $metadata, $configuration)
{
foreach (class_parents($metadata->getName()) as $parent) {
$parentMetadata = new ClassMetadata($parent, $configuration->getNamingStrategy());
if (in_array($parent, $configuration->getMetadataDriverImpl()->getAllClassNames())) {
$configuration->getMetadataDriverImpl()->loadMetadataForClass($parent, $parentMetadata);
if ($parentMetadata->isMappedSuperclass) {
foreach ($parentMetadata->getAssociationMappings() as $key => $value) {
if ($this->hasRelation($value['type'])) {
$metadata->associationMappings[$key] = $value;
}
}
}
}
}
}
/**
* @param $connection
* @param Extension $extension
* @param EntityManagerInterface $em
* @param EventManager $evm
* @param Configuration $configuration
*/
protected function bootExtension($connection, Extension $extension, EntityManagerInterface $em, EventManager $evm, Configuration $configuration)
{
$extension->addSubscribers($evm, $em, $configuration->getMetadataDriverImpl()->getReader());
if (is_array($extension->getFilters())) {
foreach ($extension->getFilters() as $name => $filter) {
$configuration->addFilter($name, $filter);
$em->getFilters()->enable($name);
}
}
$this->markAsBooted($connection, $extension);
}
/**
* Enable Gedmo Doctrine Extensions
*
* @param array $namespaces
* @param bool $all
*/
public function bootGedmoExtensions($namespaces = ['App'], $all = true)
{
if ($all) {
DoctrineExtensions::registerMappingIntoDriverChainORM($this->chain, $this->reader);
} else {
DoctrineExtensions::registerAbstractMappingIntoDriverChainORM($this->chain, $this->reader);
}
$driver = $this->metadata->getMetadataDriverImpl();
foreach ($namespaces as $namespace) {
$this->chain->addDriver($driver, $namespace);
}
$this->metadata->setMetadataDriverImpl($this->chain);
$this->dispatcher->fire('doctrine.driver-chain::booted', [$driver, $this->chain]);
}
public function testLoadClassMetadataWithoutParent()
{
$this->loadClassMetadataEvent->getClassMetadata()->willReturn($this->classMetadata->reveal());
$this->classMetadata->getName()->willReturn(get_class($this->object->reveal()));
$this->classMetadata->setCustomRepositoryClass('Sulu\\Bundle\\ContactBundle\\Entity\\ContactRepository')->shouldNotBeCalled();
$this->loadClassMetadataEvent->getEntityManager()->willReturn($this->entityManager->reveal());
$this->entityManager->getConfiguration()->willReturn($this->configuration->reveal());
$this->configuration->getNamingStrategy()->willReturn(null);
/** @var \Doctrine\Common\Persistence\Mapping\Driver\MappingDriver $mappingDriver */
$mappingDriver = $this->prophesize('Doctrine\\Common\\Persistence\\Mapping\\Driver\\MappingDriver');
$this->configuration->getMetadataDriverImpl()->willReturn($mappingDriver->reveal());
$mappingDriver->getAllClassNames()->willReturn([get_class($this->parentObject->reveal())]);
$mappingDriver->loadMetadataForClass(get_class($this->parentObject->reveal()), Argument::type('Doctrine\\ORM\\Mapping\\ClassMetadata'))->shouldBeCalled();
$this->subscriber->loadClassMetadata($this->loadClassMetadataEvent->reveal());
}
public static function create($conn, Configuration $config, EventManager $eventManager = null)
{
if (!$config->getMetadataDriverImpl()) {
throw ORMException::missingMappingDriverImpl();
}
if (is_array($conn)) {
$conn = \Doctrine\DBAL\DriverManager::getConnection($conn, $config, $eventManager ?: new EventManager());
} elseif ($conn instanceof Connection) {
if ($eventManager !== null && $conn->getEventManager() !== $eventManager) {
throw ORMException::mismatchedEventManager();
}
} else {
throw new \InvalidArgumentException("Invalid argument: " . $conn);
}
return new OroEntityManager($conn, $config, $conn->getEventManager());
}
/**
* Factory method to create EntityManager instances.
*
* @param \Doctrine\DBAL\Connection|array $conn
* @param \Doctrine\ORM\Configuration $config
* @param \Doctrine\Common\EventManager $eventManager
* @throws \Doctrine\ORM\ORMException
* @throws InvalidArgumentException
* @throws \Doctrine\ORM\ORMException
* @return EntityManager
*/
public static function create($conn, Doctrine\ORM\Configuration $config, Doctrine\Common\EventManager $eventManager = NULL)
{
if (!$config->getMetadataDriverImpl()) {
throw ORMException::missingMappingDriverImpl();
}
switch (TRUE) {
case is_array($conn):
$conn = DriverManager::getConnection($conn, $config, $eventManager ?: new Doctrine\Common\EventManager());
break;
case $conn instanceof Doctrine\DBAL\Connection:
if ($eventManager !== NULL && $conn->getEventManager() !== $eventManager) {
throw ORMException::mismatchedEventManager();
}
break;
default:
throw new InvalidArgumentException("Invalid connection");
}
return new EntityManager($conn, $config, $conn->getEventManager());
}
/**
* Copied from Doctrine\ORM\EntityManager, cause return use new EntityManager() instead of new static()
*
* @param mixed $conn
* @param Configuration $config
* @param EventManager|null $eventManager
* @return EntityManager
* @throws ORMException
* @throws \Doctrine\DBAL\DBALException
*/
public static function create($conn, Configuration $config, EventManager $eventManager = null)
{
if (!$config->getMetadataDriverImpl()) {
throw ORMException::missingMappingDriverImpl();
}
switch (true) {
case is_array($conn):
$conn = \Doctrine\DBAL\DriverManager::getConnection($conn, $config, $eventManager ?: new EventManager());
break;
case $conn instanceof Connection:
if ($eventManager !== null && $conn->getEventManager() !== $eventManager) {
throw ORMException::mismatchedEventManager();
}
break;
default:
throw new \InvalidArgumentException("Invalid argument: " . $conn);
}
return new static($conn, $config, $conn->getEventManager());
}
/**
* @param array $settings
* @param Configuration $configuration
*/
protected function setCustomMappingDriverChain(array $settings = [], Configuration $configuration)
{
$chain = new MappingDriverChain($configuration->getMetadataDriverImpl(), 'LaravelDoctrine');
foreach (array_get($settings, 'namespaces', []) as $alias => $namespace) {
if (is_string($alias)) {
$configuration->addEntityNamespace($alias, $namespace);
}
$chain->addNamespace($namespace);
}
$configuration->setMetadataDriverImpl($chain);
}
/**
* @param Configuration $configuration
*
* @return array
*/
private function getAllClassNames(Configuration $configuration)
{
if (!$this->classNames) {
$this->classNames = $configuration->getMetadataDriverImpl()->getAllClassNames();
}
return $this->classNames;
}
public function __construct(\Doctrine\ORM\Configuration $Configuration)
{
$this->driver = $Configuration->getMetadataDriverImpl();
$this->cachedMap = array();
}
/**
* Factory method to create EntityManager instances.
*
* @param array|Connection $connection An array with the connection parameters or an existing Connection instance.
* @param Configuration $config The Configuration instance to use.
* @param EventManager $eventManager The EventManager instance to use.
*
* @return EntityManager The created EntityManager.
*
* @throws \InvalidArgumentException
* @throws ORMException
*/
public static function create($connection, Configuration $config, EventManager $eventManager = null)
{
if (!$config->getMetadataDriverImpl()) {
throw ORMException::missingMappingDriverImpl();
}
$connection = static::createConnection($connection, $config, $eventManager);
return new EntityManager($connection, $config, $connection->getEventManager());
}
/**
* Returns the class names of additional entities that are directly associated with
* one of the entities that is explicitly mentioned in the given configuration.
*
* @param Configuration $config
* @param string[] $entityClasses Classes whose associations are checked.
* @return string[] Associated entity classes.
*/
protected function getDirectlyAssociatedEntities(Configuration $config, $entityClasses)
{
if (count($entityClasses) === 0) {
return array();
}
$associatedEntities = array();
foreach ($entityClasses as $entityClass) {
/* @var $entityClass string */
$metadata = new ClassMetadata($entityClass);
$metadata->initializeReflection($this->reflectionService);
$config->getMetadataDriverImpl()->loadMetadataForClass($entityClass, $metadata);
foreach ($metadata->getAssociationNames() as $name) {
/* @var $name string */
$associatedEntity = $metadata->getAssociationTargetClass($name);
$associatedEntities[] = $metadata->fullyQualifiedClassName($associatedEntity);
}
if (count($metadata->discriminatorMap) > 0) {
$childClasses = array_values($metadata->discriminatorMap);
$associatedEntities = array_merge($associatedEntities, $childClasses);
}
// Add parent classes that are involved in some kind of entity inheritance.
foreach ($this->reflectionService->getParentClasses($entityClass) as $parentClass) {
if (!$config->getMetadataDriverImpl()->isTransient($parentClass)) {
$associatedEntities[] = $parentClass;
}
}
}
return array_unique($associatedEntities);
}
/**
* @param Configuration $configuration
* @param Connection $connection
* @param EventManager $eventManager
*/
public function extend(Configuration $configuration, Connection $connection, EventManager $eventManager)
{
foreach ($this->subscribers as $subscriber) {
$eventManager->addEventSubscriber($this->container->make($subscriber, [$configuration->getMetadataDriverImpl()->getReader()]));
}
}