public function testSetPrimaryTableRelated()
{
$this->builder->addUniqueConstraint(array('username', 'name'), 'users_idx');
$this->builder->addIndex(array('username', 'name'), 'users_idx');
$this->builder->setTable('users');
$this->assertEquals(array('name' => 'users', 'indexes' => array('users_idx' => array('columns' => array('username', 'name'))), 'uniqueConstraints' => array('users_idx' => array('columns' => array('username', 'name')))), $this->cm->table);
}
/**
* @param LoadClassMetadataEventArgs $event
*/
public function loadClassMetadata(LoadClassMetadataEventArgs $event)
{
// HOT FIX for PIM-3683, when using MongoDB with PIM some queries are executed before that the schema is created
return;
/** @var OroEntityManager $em */
$em = $event->getEntityManager();
$configProvider = $em->getExtendManager()->getConfigProvider();
$className = $event->getClassMetadata()->getName();
if ($configProvider->hasConfig($className)) {
$config = $configProvider->getConfig($className);
if ($config->is('is_extend')) {
$cmBuilder = new ClassMetadataBuilder($event->getClassMetadata());
if ($config->is('index')) {
foreach ($config->get('index') as $columnName => $enabled) {
$fieldConfig = $configProvider->getConfig($className, $columnName);
if ($enabled && !$fieldConfig->is('state', ExtendManager::STATE_NEW)) {
$cmBuilder->addIndex(array(ExtendConfigDumper::FIELD_PREFIX . $columnName), 'oro_idx_' . $columnName);
}
}
}
$this->prepareRelations($config, $cmBuilder);
}
$em->getMetadataFactory()->setMetadataFor($className, $event->getClassMetadata());
}
}
/**
* {@inheritdoc}
*/
public function build(ClassMetadataBuilder $metadataBuilder, ConfigInterface $extendConfig)
{
$className = $extendConfig->getId()->getClassName();
$indices = $extendConfig->get('index');
// TODO: need to be changed to fieldName => columnName
// TODO: should be done in scope https://magecore.atlassian.net/browse/BAP-3940
foreach ($indices as $columnName => $enabled) {
$fieldConfig = $this->extendConfigProvider->getConfig($className, $columnName);
if ($enabled && !$fieldConfig->is('state', ExtendScope::STATE_NEW)) {
$indexName = $this->nameGenerator->generateIndexNameForExtendFieldVisibleInGrid($className, $columnName);
$metadataBuilder->addIndex([$columnName], $indexName);
}
}
}
/**
* Loads the metadata for the specified class into the provided container.
*
* @param string $className
* @param ClassMetadata|\Doctrine\ORM\Mapping\ClassMetadata $metadata
*
* @return void
*/
public function loadMetadataForClass($className, ClassMetadata $metadata)
{
$mapping = config(sprintf('doctrine.mappings.%s', $className));
$builder = new ClassMetadataBuilder($metadata);
if (!empty($mapping['abstract'])) {
$builder->setMappedSuperClass();
}
if (!empty($mapping['table'])) {
$builder->setTable($mapping['table']);
}
if (!empty($mapping['indexes'])) {
foreach ($mapping['indexes'] as $name => $columns) {
$builder->addIndex($columns, $name);
}
}
if (!empty($mapping['repository'])) {
$builder->setCustomRepositoryClass($mapping['repository']);
}
if (!empty($mapping['fields'])) {
foreach ($mapping['fields'] as $fieldName => $fieldConfig) {
$this->mapField($builder, $fieldName, $fieldConfig);
}
}
}
/**
* Execute the build process
*/
public function build()
{
$this->builder->addIndex($this->getColumns(), $this->getName());
}
/**
* Loads the metadata for the specified class into the provided container.
*
* @param string $className
* @param \Doctrine\ORM\Mapping\ClassMetadata $metadata
*/
public function loadMetadataForClass($className, ClassMetadata $metadata)
{
global $container;
$builder = new ClassMetadataBuilder($metadata);
$tableName = static::classToTableName($className);
$this->loadDataContainer($tableName);
try {
/** @var ClassLoader $entitiesClassLoader */
$entitiesClassLoader = $container['doctrine.orm.entitiesClassLoader'];
if (!class_exists($className, false)) {
$entitiesClassLoader->loadClass($className);
}
if (class_exists($className, false)) {
$class = new \ReflectionClass($className);
} else {
$class = false;
}
} catch (\Exception $e) {
$class = false;
}
if (!array_key_exists('TL_DCA', $GLOBALS)) {
$GLOBALS['TL_DCA'] = array();
}
if (!array_key_exists($tableName, $GLOBALS['TL_DCA']) || !is_array($GLOBALS['TL_DCA'][$tableName])) {
$GLOBALS['TL_DCA'][$tableName] = array('fields' => array());
}
$entityConfig = array();
if (array_key_exists('entity', $GLOBALS['TL_DCA'][$tableName])) {
$entityConfig = $GLOBALS['TL_DCA'][$tableName]['entity'];
}
if ($class && !$class->isInstantiable()) {
$metadata->isMappedSuperclass = true;
} elseif (array_key_exists('isMappedSuperclass', $entityConfig)) {
$metadata->isMappedSuperclass = $entityConfig['isMappedSuperclass'];
}
// custom repository class
if (array_key_exists('repositoryClass', $entityConfig)) {
$metadata->setCustomRepositoryClass($entityConfig['repositoryClass']);
} else {
$metadata->setCustomRepositoryClass('Contao\\Doctrine\\ORM\\Repository');
}
// id generator
if (array_key_exists('idGenerator', $entityConfig)) {
$metadata->setIdGeneratorType($entityConfig['idGenerator']);
} else {
$metadata->setIdGeneratorType(ClassMetadataInfo::GENERATOR_TYPE_AUTO);
}
// indexes
if (isset($entityConfig['indexes'])) {
if (is_array($entityConfig['indexes'])) {
foreach ($entityConfig['indexes'] as $name => $columns) {
if (is_array($columns)) {
$builder->addIndex($columns, $name);
} else {
throw new \RuntimeException(sprintf('$GLOBALS[TL_DCA][%s][entity][indexes][%s] must be an array', $tableName, $name));
}
}
} else {
throw new \RuntimeException(sprintf('$GLOBALS[TL_DCA][%s][entity][indexes] must be an array', $tableName));
}
}
// uniques
if (isset($entityConfig['uniques'])) {
if (is_array($entityConfig['uniques'])) {
foreach ($entityConfig['uniques'] as $name => $columns) {
if (is_array($columns)) {
$builder->addUniqueConstraint($columns, $name);
} else {
throw new \RuntimeException(sprintf('$GLOBALS[TL_DCA][%s][entity][uniques][%s] must be an array', $tableName, $name));
}
}
} else {
throw new \RuntimeException(sprintf('$GLOBALS[TL_DCA][%s][entity][uniques] must be an array', $tableName));
}
}
$metadata->setInheritanceType(ClassMetadataInfo::INHERITANCE_TYPE_NONE);
$metadata->setPrimaryTable(array('name' => $tableName));
$fields = (array) $GLOBALS['TL_DCA'][$tableName]['fields'];
foreach ($fields as $fieldName => $fieldConfig) {
$configured = array_key_exists('field', $fieldConfig) || array_key_exists('oneToOne', $fieldConfig) || array_key_exists('oneToMany', $fieldConfig) || array_key_exists('manyToOne', $fieldConfig) || array_key_exists('manyToMany', $fieldConfig);
if (!$configured && empty($fieldConfig['inputType']) || $configured && $fieldConfig['field'] === false) {
continue;
}
if (isset($fieldConfig['oneToOne'])) {
$fieldConfig['oneToOne']['fieldName'] = $fieldName;
$metadata->mapOneToOne($fieldConfig['oneToOne']);
} elseif (isset($fieldConfig['oneToMany'])) {
$fieldConfig['oneToMany']['fieldName'] = $fieldName;
$metadata->mapOneToMany($fieldConfig['oneToMany']);
} elseif (isset($fieldConfig['manyToOne'])) {
$fieldConfig['manyToOne']['fieldName'] = $fieldName;
$metadata->mapManyToOne($fieldConfig['manyToOne']);
} elseif (isset($fieldConfig['manyToMany'])) {
$fieldConfig['manyToMany']['fieldName'] = $fieldName;
$metadata->mapManyToMany($fieldConfig['manyToMany']);
} else {
$fieldMapping = array();
$inputTypes = array($fieldConfig['inputType']);
$inputTypeOptions = array();
if ($fieldConfig['foreignKey']) {
$inputTypeOptions[] = 'foreignKey';
}
if ($fieldConfig['eval']['multiple']) {
$inputTypeOptions[] = 'multiple';
}
for ($i = 0; $i < count($inputTypeOptions); $i++) {
$inputTypeOption = $fieldConfig['inputType'] . '_' . $inputTypeOptions[$i];
array_unshift($inputTypes, $inputTypeOption);
for ($j = $i + 1; $j < count($inputTypeOptions); $j++) {
$inputTypeOption .= '_' . $inputTypeOptions[$j];
array_unshift($inputTypes, $inputTypeOption);
}
}
foreach ($inputTypes as $inputType) {
if (array_key_exists($inputType, $GLOBALS['DOCTRINE_TYPE_MAP'])) {
$fieldMapping = $GLOBALS['DOCTRINE_TYPE_MAP'][$inputType];
break;
}
}
if (isset($fieldConfig['eval']['maxlength'])) {
$fieldMapping['length'] = (int) $fieldConfig['eval']['maxlength'];
}
if (isset($fieldConfig['eval']['unique'])) {
$fieldMapping['unique'] = (bool) $fieldConfig['eval']['unique'];
}
if (array_key_exists('field', $fieldConfig)) {
$fieldMapping = array_merge($fieldMapping, $fieldConfig['field']);
}
$fieldMapping['fieldName'] = $fieldName;
$metadata->mapField($fieldMapping);
}
}
/*
if (TL_MODE == 'BE' && !$metadata->isMappedSuperclass) {
EntityGeneration::generateEntity($metadata);
}
*/
}
