/**
* @param BundleInterface $bundle The bundle
* @param string $entity The entity name
* @param string $format The format
* @param array $fields The fields
* @param boolean $withRepository With repository
* @param string $prefix A prefix
*
* @throws \RuntimeException
*/
public function generate(BundleInterface $bundle, $entity, $format, array $fields, $withRepository, $prefix)
{
// configure the bundle (needed if the bundle does not contain any Entities yet)
$config = $this->registry->getManager(null)->getConfiguration();
$config->setEntityNamespaces(array_merge(array($bundle->getName() => $bundle->getNamespace() . '\\Entity'), $config->getEntityNamespaces()));
$entityClass = $this->registry->getAliasNamespace($bundle->getName()) . '\\' . $entity;
$entityPath = $bundle->getPath() . '/Entity/' . str_replace('\\', '/', $entity) . '.php';
if (file_exists($entityPath)) {
throw new \RuntimeException(sprintf('Entity "%s" already exists.', $entityClass));
}
$class = new ClassMetadataInfo($entityClass);
if ($withRepository) {
$entityClass = preg_replace('/\\\\Entity\\\\/', '\\Repository\\', $entityClass, 1);
$class->customRepositoryClassName = $entityClass . 'Repository';
}
foreach ($fields as $field) {
$class->mapField($field);
}
$class->setPrimaryTable(array('name' => $prefix . $this->getTableNameFromEntityName($entity)));
$entityGenerator = $this->getEntityGenerator();
$entityCode = $entityGenerator->generateEntityClass($class);
$mappingPath = $mappingCode = false;
$this->filesystem->mkdir(dirname($entityPath));
file_put_contents($entityPath, $entityCode);
if ($mappingPath) {
$this->filesystem->mkdir(dirname($mappingPath));
file_put_contents($mappingPath, $mappingCode);
}
if ($withRepository) {
$path = $bundle->getPath() . str_repeat('/..', substr_count(get_class($bundle), '\\'));
$this->getRepositoryGenerator()->writeEntityRepositoryClass($class->customRepositoryClassName, $path);
}
$this->addGeneratedEntityClassLoader($entityClass, $entityPath);
}
public function testAddedOptions()
{
$this->metadata->expects($this->once())->method('getTableName')->will($this->returnValue(IndexText::TABLE_NAME));
$this->event->expects($this->once())->method('getClassMetadata')->will($this->returnValue($this->metadata));
$this->listener->loadClassMetadata($this->event);
$this->assertEquals(['options' => ['engine' => PdoMysql::ENGINE_MYISAM], 'indexes' => ['value' => ['columns' => ['value']]]], $this->metadata->table);
}
public static function validateField(ClassMetadataInfo $meta, $field)
{
$fieldMapping = $meta->getFieldMapping($field);
if (!in_array($fieldMapping['type'], self::$validTypes)) {
throw new InvalidMappingException(sprintf('Field "%s" must be of one of the following types: "%s"', $fieldMapping['type'], implode(', ', self::$validTypes)));
}
}
/**
* @throws \InvalidArgumentException When the bundle doesn't end with Bundle (Example: "Bundle\MySampleBundle")
*/
protected function execute(InputInterface $input, OutputInterface $output)
{
$bundle = $this->getApplication()->getKernel()->getBundle($input->getArgument('bundle'));
$entity = str_replace('/', '\\', $input->getArgument('entity'));
$fullEntityClassName = $bundle->getNamespace() . '\\Entity\\' . $entity;
$mappingType = $input->getOption('mapping-type');
$class = new ClassMetadataInfo($fullEntityClassName);
$class->mapField(array('fieldName' => 'id', 'type' => 'integer', 'id' => true));
$class->setIdGeneratorType(ClassMetadataInfo::GENERATOR_TYPE_AUTO);
// Map the specified fields
$fields = $input->getOption('fields');
if ($fields) {
$e = explode(' ', $fields);
foreach ($e as $value) {
$e = explode(':', $value);
$name = $e[0];
if (strlen($name)) {
$type = isset($e[1]) ? $e[1] : 'string';
preg_match_all('/(.*)\\((.*)\\)/', $type, $matches);
$type = isset($matches[1][0]) ? $matches[1][0] : $type;
$length = isset($matches[2][0]) ? $matches[2][0] : null;
$class->mapField(array('fieldName' => $name, 'type' => $type, 'length' => $length));
}
}
}
// Setup a new exporter for the mapping type specified
$cme = new ClassMetadataExporter();
$exporter = $cme->getExporter($mappingType);
$entityPath = $bundle->getPath() . '/Entity/' . str_replace('\\', '/', $entity) . '.php';
if (file_exists($entityPath)) {
throw new \RuntimeException(sprintf("Entity %s already exists.", $class->name));
}
if ('annotation' === $mappingType) {
$exporter->setEntityGenerator($this->getEntityGenerator());
$entityCode = $exporter->exportClassMetadata($class);
$mappingPath = $mappingCode = false;
} else {
$mappingType = 'yaml' == $mappingType ? 'yml' : $mappingType;
$mappingPath = $bundle->getPath() . '/Resources/config/doctrine/' . str_replace('\\', '.', $fullEntityClassName) . '.orm.' . $mappingType;
$mappingCode = $exporter->exportClassMetadata($class);
$entityGenerator = $this->getEntityGenerator();
$entityCode = $entityGenerator->generateEntityClass($class);
if (file_exists($mappingPath)) {
throw new \RuntimeException(sprintf("Cannot generate entity when mapping <info>%s</info> already exists", $mappingPath));
}
}
$output->writeln(sprintf('Generating entity for "<info>%s</info>"', $bundle->getName()));
$output->writeln(sprintf(' > entity <comment>%s</comment> into <info>%s</info>', $fullEntityClassName, $entityPath));
if (!is_dir($dir = dirname($entityPath))) {
mkdir($dir, 0777, true);
}
file_put_contents($entityPath, $entityCode);
if ($mappingPath) {
$output->writeln(sprintf(' > mapping into <info>%s</info>', $mappingPath));
if (!is_dir($dir = dirname($mappingPath))) {
mkdir($dir, 0777, true);
}
file_put_contents($mappingPath, $mappingCode);
}
}
function let(PropertyTransformerInterface $transformer, ColumnInfoInterface $columnInfo, ClassMetadataInfo $metadata)
{
$this->beConstructedWith($transformer, 'array');
$columnInfo->getPropertyPath()->willReturn('property_path');
$metadata->hasField('property_path')->willReturn(true);
$metadata->getTypeOfField('property_path')->willReturn('array');
}
/**
* Unset the association mappings of a metadata.
*
* @param ClassMetadataInfo $metadata
*/
protected function unsetAssociationMappings(ClassMetadataInfo $metadata)
{
foreach ($metadata->getAssociationMappings() as $key => $value) {
if ($this->hasRelation($value['type'])) {
unset($metadata->associationMappings[$key]);
}
}
}
public static function loadMetadata(\Doctrine\ORM\Mapping\ClassMetadataInfo $metadata)
{
$metadata->mapField(array('id' => true, 'fieldName' => 'id', 'type' => 'integer', 'columnName' => 'id'));
$metadata->mapField(array('fieldName' => 'value', 'type' => 'float'));
$metadata->isMappedSuperclass = true;
$metadata->setCustomRepositoryClass("Doctrine\\Tests\\Models\\DDC869\\DDC869PaymentRepository");
$metadata->setIdGeneratorType(\Doctrine\ORM\Mapping\ClassMetadataInfo::GENERATOR_TYPE_AUTO);
}
public function testManyToManyHasPrefix()
{
$this->metadata->mapManyToMany(['fieldName' => 'fooBar', 'targetEntity' => 'bar']);
$tablePrefix = new TablePrefixListener('someprefix_');
$tablePrefix->loadClassMetadata($this->args);
$this->assertEquals('someprefix_foo', $this->metadata->getTableName());
$this->assertEquals('someprefix_foo_bar', $this->metadata->associationMappings['fooBar']['joinTable']['name']);
}
/**
* Extends the mapping
*
* @param ClassMetadataInfo $metadata
* @param MappingDefinitionCollection $collection
*/
private function extendClassMetadata(ClassMetadataInfo $metadata, MappingDefinitionCollection $collection)
{
$collection->forAll(function (MappingDefinitionInterface $definition) use($metadata) {
$reflectionClass = $metadata->getReflectionClass();
if (true === $reflectionClass->hasProperty($definition->getPropertyName())) {
$metadata->{$definition->getClassMetadataMethod()}($definition->getOptions());
}
});
}
/**
* {@inheritdoc}
*/
public function traverse(ClassMetadataInfo $metadata)
{
$class = $metadata->getName();
if (true === $this->collection->has($class)) {
foreach ($this->collection->get($class) as $enhancer) {
$enhancer->visitClassMetadata($metadata);
}
}
}
/**
* @param ClassMetadataInfo $metadata
*
* @return string
*/
public function getTableName(ClassMetadataInfo $metadata)
{
$tableName = $metadata->getTableName();
//## Fix for doctrine/orm >= 2.5
if (method_exists($metadata, 'getSchemaName') && $metadata->getSchemaName()) {
$tableName = $metadata->getSchemaName() . '.' . $tableName;
}
return $this->getTablePrefix() . $tableName . $this->getTableSuffix();
}
/**
* @param ClassMetadataInfo $metadata
* @param string $outputDir
* @param Closure $collectionNameBuilder
*/
public function generate(ClassMetadataInfo $metadata, $outputDir, Closure $collectionNameBuilder)
{
$tpl = file_get_contents(CodeGeneratorHelper::absPath(EntityCollectionTemplate::class, RootPath::path()));
$tplNs = CodeGeneratorHelper::ns(EntityCollectionTemplate::class);
$tplSimpleName = CodeGeneratorHelper::simpleName(EntityCollectionTemplate::class);
$entityFqcn = CodeGeneratorHelper::simpleName(EntityFqcn::class);
$collectionClassName = $collectionNameBuilder($metadata->getName());
$code = CodeGeneratorHelper::render($tpl, array($tplNs => CodeGeneratorHelper::ns($collectionClassName), $tplSimpleName => CodeGeneratorHelper::simpleName($collectionClassName), $entityFqcn => CodeGeneratorHelper::fqn($metadata->getName())));
CodeGeneratorHelper::save($collectionClassName, $code, $outputDir);
}
/**
* Returns class annotations.
*
* @param ClassMetadataInfo $metadata
*
* @return array
*/
protected function getClassAnnotations($metadata)
{
$class = $metadata->getReflectionClass();
if (!$class) {
// this happens when running annotation driver in combination with
// static reflection services. This is not the nicest fix
$class = new \ReflectionClass($metadata->name);
}
return $this->readAnnotations($class);
}
/**
* {@inheritdoc}
*/
public function loadMetadataForClass($className, \Doctrine\ORM\Mapping\ClassMetadataInfo $metadata)
{
$element = $this->getElement($className, true);
// Customizing for Cloudrexx: YamlEntity extension
if ($element['type'] == 'YamlEntity') {
$metadata->setCustomRepositoryClass(isset($element['repositoryClass']) ? $element['repositoryClass'] : null);
$metadata->isMappedSuperclass = true;
}
parent::loadMetadataForClass($className, $metadata);
}
/**
* @throws \InvalidArgumentException When the bundle doesn't end with Bundle (Example: "Bundle\MySampleBundle")
*/
protected function execute(InputInterface $input, OutputInterface $output)
{
if (!preg_match('/Bundle$/', $bundle = $input->getArgument('bundle'))) {
throw new \InvalidArgumentException('The bundle name must end with Bundle. Example: "Bundle\\MySampleBundle".');
}
$dirs = $this->container->get('kernel')->getBundleDirs();
$tmp = str_replace('\\', '/', $bundle);
$namespace = str_replace('/', '\\', dirname($tmp));
$bundle = basename($tmp);
if (!isset($dirs[$namespace])) {
throw new \InvalidArgumentException(sprintf('Unable to initialize the bundle entity (%s not defined).', $namespace));
}
$entity = $input->getArgument('entity');
$entityNamespace = $namespace . '\\' . $bundle . '\\Entity';
$fullEntityClassName = $entityNamespace . '\\' . $entity;
$tmp = str_replace('\\', '/', $fullEntityClassName);
$tmp = str_replace('/', '\\', dirname($tmp));
$className = basename($tmp);
$mappingType = $input->getOption('mapping-type');
$mappingType = $mappingType ? $mappingType : 'xml';
$class = new ClassMetadataInfo($fullEntityClassName);
$class->mapField(array('fieldName' => 'id', 'type' => 'integer', 'id' => true));
$class->setIdGeneratorType(ClassMetadataInfo::GENERATOR_TYPE_AUTO);
// Map the specified fields
$fields = $input->getOption('fields');
if ($fields) {
$e = explode(' ', $fields);
foreach ($e as $value) {
$e = explode(':', $value);
$name = $e[0];
$type = isset($e[1]) ? $e[1] : 'string';
preg_match_all('/(.*)\\((.*)\\)/', $type, $matches);
$type = isset($matches[1][0]) ? $matches[1][0] : $type;
$length = isset($matches[2][0]) ? $matches[2][0] : null;
$class->mapField(array('fieldName' => $name, 'type' => $type, 'length' => $length));
}
}
// Setup a new exporter for the mapping type specified
$cme = new ClassMetadataExporter();
$exporter = $cme->getExporter($mappingType);
if ('annotation' === $mappingType) {
$path = $dirs[$namespace] . '/' . $bundle . '/Entity/' . str_replace($entityNamespace . '\\', null, $fullEntityClassName) . '.php';
$exporter->setEntityGenerator($this->getEntityGenerator());
} else {
$mappingType = 'yaml' == $mappingType ? 'yml' : $mappingType;
$path = $dirs[$namespace] . '/' . $bundle . '/Resources/config/doctrine/metadata/orm/' . str_replace('\\', '.', $fullEntityClassName) . '.dcm.' . $mappingType;
}
$code = $exporter->exportClassMetadata($class);
if (!is_dir($dir = dirname($path))) {
mkdir($dir, 0777, true);
}
$output->writeln(sprintf('Generating entity for "<info>%s</info>"', $bundle));
$output->writeln(sprintf(' > generating <comment>%s</comment>', $fullEntityClassName));
file_put_contents($path, $code);
}
/**
* @param ColumnInfoInterface $columnInfo
* @param ORMClassMetadataInfo $metadata
*
* @return array
*/
private function getORMTransformerInfo(ColumnInfoInterface $columnInfo, ORMClassMetadataInfo $metadata)
{
if (!$metadata->hasAssociation($columnInfo->getPropertyPath())) {
return;
}
$mapping = $metadata->getAssociationMapping($columnInfo->getPropertyPath());
if (!$this->doctrine->getRepository($mapping['targetEntity']) instanceof ReferableEntityRepositoryInterface) {
return;
}
return array($this->transformer, array('class' => $mapping['targetEntity'], 'multiple' => ORMClassMetadataInfo::MANY_TO_MANY === $mapping['type']));
}
/**
* @param \Doctrine\ORM\Mapping\ClassMetadataInfo $metadata
*/
public static function loadMetadata(ORM\ClassMetadataInfo $metadata)
{
$metadata->setTableName('album');
$metadata->setIdGeneratorType(ORM\ClassMetadataInfo::GENERATOR_TYPE_NONE);
$metadata->setCustomRepositoryClass('Orm\\Repository\\AlbumRepository');
$metadata->addLifecycleCallback('setLastupdateToNow', 'prePersist');
$metadata->addLifecycleCallback('setLastupdateToNow', 'preUpdate');
$metadata->mapField(array('id' => true, 'fieldName' => 'id', 'type' => 'string', 'length' => 100));
$metadata->mapField(array('id' => true, 'fieldName' => 'websiteid', 'type' => 'string', 'length' => 100));
$metadata->mapField(array('fieldName' => 'name', 'type' => 'string', 'length' => 255));
$metadata->mapField(array('fieldName' => 'lastupdate', 'type' => 'bigint', 'default' => 0));
}
public function testLoadMetadataForClass()
{
$metadata = new ClassMetadataInfo('Giftcards\\Encryption\\Tests\\Doctrine\\MockEntityWithEncryptedProperties');
$metadata->reflClass = new \ReflectionClass($metadata->getName());
$this->driver->loadMetadataForClass($metadata->getName(), $metadata);
$this->assertTrue($metadata->hasEncryptedProperties);
$this->assertEquals(array('encryptedProperty' => array('profile' => null)), $metadata->encryptedProperties);
$metadata = new ClassMetadataInfo('Giftcards\\Encryption\\Tests\\Doctrine\\MockEntityWithEncryptedPropertiesAndProfileSet');
$metadata->reflClass = new \ReflectionClass($metadata->getName());
$this->driver->loadMetadataForClass($metadata->getName(), $metadata);
$this->assertTrue($metadata->hasEncryptedProperties);
$this->assertEquals(array('encryptedProperty' => array('profile' => 'foo')), $metadata->encryptedProperties);
}
protected function setUp()
{
$this->classMetadata = $this->getMockBuilder('Doctrine\\ORM\\Mapping\\ClassMetadataInfo')->disableOriginalConstructor()->setMethods(array('getSingleIdentifierFieldName'))->getMock();
$this->classMetadata->expects($this->any())->method('getSingleIdentifierFieldName')->will($this->returnValue(self::TEST_IDENTIFIER));
$this->ormConfiguration = $this->getMockBuilder('Doctrine\\ORM\\Configuration')->disableOriginalConstructor()->setMethods(array('addCustomHydrationMode'))->getMock();
$this->entityManager = $this->getMockBuilder('Doctrine\\ORM\\EntityManager')->disableOriginalConstructor()->setMethods(array('getClassMetadata', 'getConfiguration'))->getMock();
$this->entityManager->expects($this->any())->method('getClassMetadata')->with(self::TEST_CLASS)->will($this->returnValue($this->classMetadata));
$this->entityManager->expects($this->any())->method('getConfiguration')->will($this->returnValue($this->ormConfiguration));
$this->registry = $this->getMockBuilder('Doctrine\\Common\\Persistence\\ManagerRegistry')->disableOriginalConstructor()->setMethods('getManager', 'getRepository')->getMockForAbstractClass();
$this->registry->expects($this->any())->method('getManager')->will($this->returnValue($this->entityManager));
$this->registry->expects($this->any())->method('getRepository')->with(self::TEST_CLASS)->will($this->returnValue($this->getEntityRepository()));
$this->type = new TranslatableEntityType($this->registry);
}
/**
* Returns an array of fields. Fields can be both column fields and
* association fields.
*
* @param ClassMetadataInfo $metadata
* @return array $fields
*/
private function getFieldsFromMetadata(ClassMetadataInfo $metadata)
{
$fields = (array) $metadata->fieldMappings;
// Remove the primary key field if it's not managed manually
if (!$metadata->isIdentifierNatural()) {
foreach ($metadata->identifier as $id) {
if (array_key_exists($id, $fields)) {
unset($fields[$id]);
}
}
}
return $fields;
}
/**
* Returns an array of fields. Fields can be both column fields and
* association fields.
*
* @param ClassMetadataInfo $metadata
* @return array $fields
*/
private function getFieldsFromMetadata(ClassMetadataInfo $metadata)
{
$fields = (array) $metadata->fieldNames;
// Remove the primary key field if it's not managed manually
if (!$metadata->isIdentifierNatural()) {
$fields = array_diff($fields, $metadata->identifier);
}
foreach ($metadata->associationMappings as $fieldName => $relation) {
if ($relation['type'] !== ClassMetadataInfo::ONE_TO_MANY) {
$fields[] = $fieldName;
}
}
return $fields;
}
function it_configures_the_mappings_of_a_model_that_overrides_an_original_model($configuration, ClassMetadataInfo $metadataInfo, MappingDriver $mappingDriver)
{
$originalQux1 = __NAMESPACE__ . '\\OriginalQux1';
$originalQux2 = __NAMESPACE__ . '\\OriginalQux2';
$overrideQux1 = __NAMESPACE__ . '\\OverrideQux1';
$overrideQux2 = __NAMESPACE__ . '\\OverrideQux2';
$mappingDriver->getAllClassNames()->willReturn([$originalQux1]);
$configuration->getMetadataDriverImpl()->willReturn($mappingDriver);
$configuration->getNamingStrategy()->willReturn(null);
$metadataInfo->getName()->willReturn($overrideQux1);
$mappingDriver->loadMetadataForClass($originalQux1, Argument::any())->shouldBeCalled();
$overrides = [['original' => $originalQux1, 'override' => $overrideQux1], ['original' => $originalQux2, 'override' => $overrideQux2]];
$this->configure($metadataInfo, $overrides, $configuration);
}
/**
* Creates an entity.
*
* @static
*/
public static function create($name, $path, array $fields, $annotationPrefix = 'ORM\\')
{
self::$annotationPrefix = $annotationPrefix;
self::$name = $name;
self::$path = $path;
self::$fields = $fields;
$class = new ClassMetadataInfo(self::$name);
$class->mapField(array('fieldName' => 'id', 'type' => 'integer', 'id' => true));
$class->setIdGeneratorType(ClassMetadataInfo::GENERATOR_TYPE_AUTO);
foreach (self::$fields as $field) {
$class->mapField($field);
}
file_put_contents(self::$path, self::getEntityGenerator()->generateEntityClass($class));
}
protected function generateCodeBody(ClassMetadataInfo $metadata)
{
$methods = array();
$methods[] = $this->generateFindBy($metadata->getName());
foreach ($metadata->fieldMappings as $fieldMapping) {
$methods[] = $this->generateFieldFindBy($metadata->getName(), $fieldMapping['type'], $fieldMapping['fieldName']);
}
foreach ($metadata->embeddedClasses as $fieldName => $embeddedClass) {
$methods[] = $this->generateFieldFindBy($metadata->getName(), $embeddedClass['class'], $fieldName);
}
foreach ($metadata->associationMappings as $associationMapping) {
$methods[] = $this->generateFieldFindBy($metadata->getName(), $associationMapping['targetEntity'], $associationMapping['fieldName']);
}
return implode("\n", $methods);
}
public function generate(BundleInterface $bundle, $entity, $format, array $fields, $withRepository)
{
// configure the bundle (needed if the bundle does not contain any Entities yet)
$config = $this->registry->getManager(null)->getConfiguration();
$config->setEntityNamespaces(array_merge(array($bundle->getName() => $bundle->getNamespace() . '\\Entity'), $config->getEntityNamespaces()));
$entityClass = $this->registry->getAliasNamespace($bundle->getName()) . '\\' . $entity;
$entityPath = $bundle->getPath() . '/Entity/' . str_replace('\\', '/', $entity) . '.php';
if (file_exists($entityPath)) {
throw new \RuntimeException(sprintf('Entity "%s" already exists.', $entityClass));
}
$class = new ClassMetadataInfo($entityClass);
$namingArray = Helper\NamingHelper::getNamingArray($bundle);
$class->table['name'] = $namingArray['vendor'] . '__' . $namingArray['bundle'] . '__' . strtolower($entity);
if ($withRepository) {
$class->customRepositoryClassName = $entityClass . 'Repository';
}
$class->mapField(array('fieldName' => 'id', 'type' => 'integer', 'id' => true));
$class->setIdGeneratorType(ClassMetadataInfo::GENERATOR_TYPE_AUTO);
foreach ($fields as $field) {
$class->mapField($field);
}
$entityGenerator = $this->getEntityGenerator();
if ('annotation' === $format) {
$entityGenerator->setGenerateAnnotations(true);
$entityCode = $entityGenerator->generateEntityClass($class);
$mappingPath = $mappingCode = false;
} else {
$cme = new ClassMetadataExporter();
$exporter = $cme->getExporter('yml' == $format ? 'yaml' : $format);
$mappingPath = $bundle->getPath() . '/Resources/config/doctrine/' . str_replace('\\', '.', $entity) . '.orm.' . $format;
if (file_exists($mappingPath)) {
throw new \RuntimeException(sprintf('Cannot generate entity when mapping "%s" already exists.', $mappingPath));
}
$mappingCode = $exporter->exportClassMetadata($class);
$entityGenerator->setGenerateAnnotations(false);
$entityCode = $entityGenerator->generateEntityClass($class);
}
$this->filesystem->mkdir(dirname($entityPath));
file_put_contents($entityPath, $entityCode);
if ($mappingPath) {
$this->filesystem->mkdir(dirname($mappingPath));
file_put_contents($mappingPath, $mappingCode);
}
if ($withRepository) {
$path = $bundle->getPath() . str_repeat('/..', substr_count(get_class($bundle), '\\'));
$this->getRepositoryGenerator()->writeEntityRepositoryClass($class->customRepositoryClassName, $path);
}
}
/**
* Adds Field.
*
* @param string $name
* @param string $type
* @param array $mapping
*
* @return ClassMetadataBuilder
*/
public function addField($name, $type, array $mapping = array())
{
$mapping['fieldName'] = $name;
$mapping['type'] = $type;
$this->cm->mapField($mapping);
return $this;
}
/**
* Returns an array of fields. Fields can be both column fields and
* association fields.
*
* @param ClassMetadataInfo $metadata
*
* @return array $fields
*/
private function getFieldsFromMetadata(ClassMetadataInfo $metadata)
{
$fields = (array) $metadata->fieldNames;
if (!$metadata->isIdentifierNatural()) {
$fields = array_diff($fields, $metadata->identifier);
}
$fieldsMapping = array();
foreach ($fields as $field) {
$fieldsMapping[$field] = $metadata->getTypeOfField($field);
}
foreach ($metadata->associationMappings as $fieldName => $relation) {
if ($relation['type'] !== ClassMetadataInfo::ONE_TO_MANY) {
$fieldsMapping[$fieldName] = 'relation';
}
}
return $fieldsMapping;
}
/**
* @param \Doctrine\ORM\Mapping\ClassMetadataInfo $metadata
*/
public static function loadMetadata(ORM\ClassMetadataInfo $metadata)
{
$metadata->setTableName('user_opt_in');
$metadata->setIdGeneratorType(ORM\ClassMetadataInfo::GENERATOR_TYPE_NONE);
$metadata->setCustomRepositoryClass('Orm\\Repository\\OptInRepository');
$metadata->mapField(array('id' => true, 'fieldName' => 'userid', 'type' => 'string', 'length' => 100));
$metadata->mapField(array('id' => true, 'unique' => true, 'fieldName' => 'code', 'type' => 'string', 'length' => 100));
$metadata->mapField(array('fieldName' => 'timestamp', 'type' => 'datetime'));
$metadata->mapField(array('fieldName' => 'mode', 'type' => 'string', 'length' => 100));
}
public function generateBookEntityFixture()
{
$metadata = new ClassMetadataInfo($this->_namespace . '\\EntityGeneratorBook');
$metadata->namespace = $this->_namespace;
$metadata->customRepositoryClassName = $this->_namespace . '\\EntityGeneratorBookRepository';
$metadata->table['name'] = 'book';
$metadata->mapField(array('fieldName' => 'name', 'type' => 'string'));
$metadata->mapField(array('fieldName' => 'status', 'type' => 'string', 'default' => 'published'));
$metadata->mapField(array('fieldName' => 'id', 'type' => 'integer', 'id' => true));
$metadata->mapOneToOne(array('fieldName' => 'author', 'targetEntity' => 'Doctrine\\Tests\\ORM\\Tools\\EntityGeneratorAuthor', 'mappedBy' => 'book'));
$joinColumns = array(array('name' => 'author_id', 'referencedColumnName' => 'id'));
$metadata->mapManyToMany(array('fieldName' => 'comments', 'targetEntity' => 'Doctrine\\Tests\\ORM\\Tools\\EntityGeneratorComment', 'joinTable' => array('name' => 'book_comment', 'joinColumns' => array(array('name' => 'book_id', 'referencedColumnName' => 'id')), 'inverseJoinColumns' => array(array('name' => 'comment_id', 'referencedColumnName' => 'id')))));
$metadata->addLifecycleCallback('loading', 'postLoad');
$metadata->addLifecycleCallback('willBeRemoved', 'preRemove');
$metadata->setIdGeneratorType(ClassMetadataInfo::GENERATOR_TYPE_AUTO);
$this->_generator->writeEntityClass($metadata, $this->_tmpDir);
return $metadata;
}
/**
* Get default order by.
*
* @return array|null
*/
protected function getDefaultOrderBy()
{
$ids = $this->metadata->getIdentifierFieldNames();
$orderBy = $ids ? [] : null;
foreach ($ids as $pk) {
$orderBy[$pk] = 'ASC';
}
return $orderBy;
}
