public static function loadMetadata(ClassMetadata $data) { $builder = new ClassMetadataBuilder($data); $builder->setTable('sample'); $builder->createField('id', 'integer')->isPrimaryKey()->generatedValue()->build(); $builder->createField('text', 'string')->length(64)->build(); }
public static function loadMetadata(ClassMetadata $metadata) { $builder = new ClassMetadataBuilder($metadata); $builder->createField('id', 'integer')->isPrimaryKey()->generatedValue()->build(); $builder->addField('name', 'string'); $builder->addOwningManyToMany('albums', 'Album', 'performers'); }
public static function loadMetadata(ClassMetadata $metadata) { $builder = new ClassMetadataBuilder($metadata); $builder->createField('id', 'integer')->isPrimaryKey()->generatedValue()->build(); $builder->addField('url', 'string'); $builder->addOwningManyToMany('songs', 'Song', 'singleCoverArt'); }
public static function loadMetadata(ClassMetadata $metadata) { $builder = new ClassMetadataBuilder($metadata); $builder->createField('id', 'integer')->isPrimaryKey()->generatedValue()->build(); $builder->addField('title', 'string'); $builder->addManyToOne('album', 'Album', 'songs'); }
public function test_can_add_no_prefix() { $this->embedded->noPrefix(); $this->embedded->build(); $embedded = $this->builder->getClassMetadata()->embeddedClasses['field']; $this->assertFalse($embedded['columnPrefix']); }
public function test_can_set_map_as_array() { $this->inheritance->map(['stub1' => StubEntity::class, 'stub2' => StubEntity2::class, 'stub3' => StubEntity3::class]); $map = $this->builder->getClassMetadata()->discriminatorMap; $this->assertEquals(StubEntity::class, $map['stub1']); $this->assertEquals(StubEntity2::class, $map['stub2']); $this->assertEquals(StubEntity3::class, $map['stub3']); }
public function build(ClassMetadataBuilder $builder) { if ($this->association->getAssociationType() == ManyToManyAssociation::TYPE_OWNING) { $builder->addOwningManyToMany($this->association->getComputedTargetPropertyName(), $this->association->getTargetEntity()->getName(), $this->association->getComputedInversedByPropertyName()); } else { $builder->addInverseManyToMany($this->association->getComputedTargetPropertyName(), $this->association->getTargetEntity()->getName(), $this->association->getComputedInversedByPropertyName()); } }
public static function loadMetadata(ClassMetadata $metadata) { $builder = new ClassMetadataBuilder($metadata); $builder->createField('id', 'integer')->isPrimaryKey()->generatedValue()->build(); $builder->addField('title', 'string'); $builder->addOneToMany('songs', 'Song', 'album'); $builder->addInverseManyToMany('performers', 'Performer', 'albums'); }
/** * Execute the build process. */ public function build() { foreach ($this->events as $event => $methods) { foreach ($methods as $method) { $this->builder->addLifecycleEvent($method, $event); } } }
public function test_can_create_association_override() { $builder = new ClassMetadataBuilder(new ClassMetadataInfo(StubEntity::class)); $builder->addOwningManyToMany('owner', StubEntity::class); $override = OverrideBuilderFactory::create($builder, new DefaultNamingStrategy(), 'owner', function ($relation) { return $relation; }); $this->assertInstanceOf(AssociationOverride::class, $override); }
/** * @param ClassMetadataBuilder $builder * @param NamingStrategy $namingStrategy * @param $name * @param callable $callback * * @return */ public static function create(ClassMetadataBuilder $builder, NamingStrategy $namingStrategy, $name, callable $callback) { foreach (self::getFactories() as $buildable => $check) { if ($check($builder->getClassMetadata(), $name)) { return new $buildable($builder, $namingStrategy, $name, $callback); } } throw new InvalidArgumentException('No attribute or association could be found for ' . $name); }
private function doEventTest($event) { $this->assertFalse($this->fluent->getClassMetadata()->hasLifecycleCallbacks($event), "Event [{$event}] is already associated!"); for ($i = 0, $max = mt_rand(1, 5); $i < $max; ++$i) { $this->builder->{$event}(uniqid()); } $this->builder->build(); $this->assertTrue($this->fluent->getClassMetadata()->hasLifecycleCallbacks($event), "Event [{$event}] was not associated!"); $this->assertCount($max, $actual = $this->fluent->getClassMetadata()->getLifecycleCallbacks($event), "Expected [{$max}] events associated for [{$event}], got " . count($actual)); }
public function test_adding_new_options_will_merge_them() { $this->builder->addField('nullable_attribute', 'string', ['options' => ['default' => 'some_default']]); $override = $this->override('nullable_attribute', function ($field) { return $field->name('overridden_name')->option('some_option', 'some_value'); }); $override->build(); $this->assertEquals('overridden_name', $this->builder->getClassMetadata()->getColumnName('nullable_attribute')); $this->assertEquals('some_value', $this->builder->getClassMetadata()->getFieldMapping('nullable_attribute')['options']['some_option']); $this->assertEquals('some_default', $this->builder->getClassMetadata()->getFieldMapping('nullable_attribute')['options']['default']); }
public function test_can_set_a_custom_unique_name() { $index = new UniqueConstraint($this->builder, ['name']); $index->name('custom_unique'); $this->assertCount(1, $index->getColumns()); $this->assertEquals('custom_unique', $index->getName()); $index->build(); $uniqueConstraints = $this->builder->getClassMetadata()->table['uniqueConstraints']; $this->assertTrue(isset($uniqueConstraints['custom_unique'])); $this->assertCount(1, $uniqueConstraints['custom_unique']['columns']); }
public function test_can_set_a_custom_index_name() { $index = new Index($this->builder, ['name']); $index->name('custom_index'); $this->assertCount(1, $index->getColumns()); $this->assertEquals('custom_index', $index->getName()); $index->build(); $indexes = $this->builder->getClassMetadata()->table['indexes']; $this->assertTrue(isset($indexes['custom_index'])); $this->assertCount(1, $indexes['custom_index']['columns']); }
public function test_can_build_association_override() { $meta = new ClassMetadataInfo(StubEntity::class); $builder = new ClassMetadataBuilder($meta); $builder->addOwningManyToMany('owner', StubEntity::class); $override = new Override($builder, new DefaultNamingStrategy(), 'owner', function ($relation) { return $relation; }); $this->assertInstanceOf(Delay::class, $override); $override->build(); }
/** * @param string $name * @param string|null $class * * @return Inheritance */ public function map($name, $class = null) { if (is_array($name)) { foreach ($name as $name => $class) { $this->map($name, $class); } return $this; } $this->builder->addDiscriminatorMapClass($name, $class); return $this; }
public function test_can_add_primary_for_multiple_columns() { $index = new Primary($this->builder, ['relation1', 'relation2']); $this->assertCount(2, $index->getFields()); $this->assertContains('relation1', $index->getFields()); $this->assertContains('relation2', $index->getFields()); $index->build(); $indexes = $this->builder->getClassMetadata()->getIdentifier(); $this->assertCount(2, $indexes); $this->assertContains('relation1', $indexes); $this->assertContains('relation2', $indexes); }
/** * @param ConfigInterface $config * @param ClassMetadataBuilder $cmBuilder */ protected function prepareRelations(ConfigInterface $config, ClassMetadataBuilder $cmBuilder) { if ($config->is('relation')) { foreach ($config->get('relation') as $relation) { /** @var FieldConfigId $fieldId */ if ($relation['assign'] && ($fieldId = $relation['field_id'])) { /** @var FieldConfigId $targetFieldId */ $targetFieldId = $relation['target_field_id']; $targetFieldName = $targetFieldId ? ExtendConfigDumper::FIELD_PREFIX . $targetFieldId->getFieldName() : null; $fieldName = ExtendConfigDumper::FIELD_PREFIX . $fieldId->getFieldName(); $defaultName = ExtendConfigDumper::DEFAULT_PREFIX . $fieldId->getFieldName(); switch ($fieldId->getFieldType()) { case 'manyToOne': $builder = $cmBuilder->createManyToOne($fieldName, $relation['target_entity']); if ($targetFieldName) { $builder->inversedBy($targetFieldName); } $builder->addJoinColumn($fieldName . '_id', 'id', true, false, 'SET NULL'); $builder->cascadeDetach(); $builder->build(); break; case 'oneToMany': /** create 1:* */ $builder = $cmBuilder->createOneToMany($fieldName, $relation['target_entity']); $builder->mappedBy($targetFieldName); $builder->cascadeDetach(); $builder->build(); /** create 1:1 default */ $builder = $cmBuilder->createOneToOne($defaultName, $relation['target_entity']); $builder->addJoinColumn($defaultName . '_id', 'id', true, false, 'SET NULL'); $builder->build(); break; case 'manyToMany': if ($relation['owner']) { $builder = $cmBuilder->createManyToMany($fieldName, $relation['target_entity']); if ($targetFieldName) { $builder->inversedBy($targetFieldName); } $builder->setJoinTable(ExtendHelper::generateManyToManyJoinTableName($fieldId, $relation['target_entity'])); $builder->build(); $builder = $cmBuilder->createOneToOne($defaultName, $relation['target_entity']); $builder->addJoinColumn($defaultName . '_id', 'id', true, false, 'SET NULL'); $builder->build(); } else { $cmBuilder->addInverseManyToMany($fieldName, $relation['target_entity'], $targetFieldName); } break; } } } } }
public static function loadMetadata(ORM\ClassMetadata $metadata) { $builder = new ORM\Builder\ClassMetadataBuilder($metadata); $builder->setTable('tasks'); $builder->createField('id', 'integer')->isPrimaryKey()->generatedValue()->build(); $builder->createField('name', 'string')->columnName('name')->build(); $builder->createField('dueDate', 'datetime')->columnName('due_date')->build(); $builder->createField('isCompleted', 'boolean')->columnName('is_completed')->build(); $builder->createField('dateAdded', 'datetime')->columnName('date_added')->build(); $builder->createField('dateCompleted', 'datetime')->columnName('date_completed')->nullable()->build(); $builder->createManyToOne('lead', 'Mautic\\LeadBundle\\Entity\\Lead')->addJoinColumn('lead_id', 'id', true, false, 'CASCADE')->build(); $builder->createManyToOne('assignUser', 'Mautic\\UserBundle\\Entity\\User')->addJoinColumn('assign_user_id', 'id', true, false, 'CASCADE')->build(); }
/** * {@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); } } }
/** * Insert enabled widgets in base widget DiscriminatorMap * * @param LoadClassMetadataEventArgs $eventArgs */ public function loadClassMetadata(LoadClassMetadataEventArgs $eventArgs) { $metadata = $eventArgs->getClassMetadata(); //set a relation between Page and User to define the page author $metaBuilder = new ClassMetadataBuilder($metadata); //Add author relation on view if ($this->userClass && $metadata->name === 'Victoire\\Bundle\\CoreBundle\\Entity\\View') { $metadata->mapManyToOne(array('fieldName' => 'author', 'targetEntity' => $this->userClass, 'cascade' => array('persist'), 'inversedBy' => 'pages', 'joinColumns' => array(array('name' => 'author_id', 'referencedColumnName' => 'id', 'onDelete' => 'SET NULL')))); } // if $pages property exists, add the inversed side on User if ($metadata->name === $this->userClass && property_exists($this->userClass, 'pages')) { $metaBuilder->addOneToMany('pages', 'Victoire\\Bundle\\PageBundle\\Entity\\View', 'author'); } }
public function test_has_one_implies_an_inverse_one_to_one() { $relation = $this->fluent->hasOne(FakeEntity::class, 'one'); $relation->build(); $result = $this->builder->getClassMetadata()->associationMappings['one']; $this->assertFalse($result['isOwningSide'], "HasOne relation is an inversed one-to-one, but resulted in the owning side."); }
public function test_can_change_target_on_many_to_one() { $this->assertEquals('manyToOne_id', $this->builder->getClassMetadata()->getAssociationMapping('manyToOne')['joinColumns'][0]['name']); $override = $this->override('manyToOne', function (ManyToOne $relation) { return $relation->target('foreign_key'); }); $override->build(); $this->assertEquals('foreign_key', $this->builder->getClassMetadata()->getAssociationMapping('manyToOne')['joinColumns'][0]['name']); }
public static function loadMetadata(ClassMetadata $metadata) { $builder = new ClassMetadataBuilder($metadata); $builder->setTable('user')->setCustomRepositoryClass(UsersRepository::class); $builder->createField('id', Type::INTEGER)->isPrimaryKey()->generatedValue()->build(); $builder->createField('name', Type::STRING)->length(255)->nullable(false)->build(); $builder->createField('login', Type::STRING)->length(255)->nullable(false)->build(); $builder->createField('email', Type::STRING)->length(255)->nullable(false)->build(); $builder->createField('password', Type::STRING)->length(255)->nullable(false)->build(); $builder->createField('role', Type::STRING)->length(255)->nullable(false)->build(); }
/** * Parses configuration for a field and adds it to the class metadata. * * @param ClassMetadataBuilder $builder * @param string $name * @param array|string $config */ protected function mapField(ClassMetadataBuilder $builder, $name, $config) { if (!empty($config['name'])) { $name = $config['name']; } if (empty($config['type'])) { $type = $config; } else { $type = $config['type']; } $field = $builder->createField($name, $type); if (!empty($config['strategy'])) { $field->generatedValue(strtoupper($config['strategy'])); } if (!empty($config['nullable'])) { $field->nullable(true); } $builder->mapField($config); $field->build(); }
/** * Load the metadata for the specified class into the provided container. * * @param string $className * @param ClassMetadata $metadata */ public function loadMetadataForClass($className, ClassMetadata $metadata) { $metadataFactory = $this->getObjectManager()->getMetadataFactory(); $builder = new ClassMetadataBuilder($metadata); $identifiers = array(); // Get the entity this entity audits $metadataClassName = $metadata->getName(); $metadataClass = new $metadataClassName(); $auditedClassMetadata = $metadataFactory->getMetadataFor($metadataClass->getAuditedEntityClass()); $builder->addManyToOne('revisionEntity', 'ZF\\Doctrine\\Audit\\Entity\\RevisionEntity'); $identifiers[] = 'revisionEntity'; // Add fields from target to audit entity foreach ($auditedClassMetadata->getFieldNames() as $fieldName) { $builder->addField($fieldName, $auditedClassMetadata->getTypeOfField($fieldName), array('columnName' => $auditedClassMetadata->getColumnName($fieldName), 'nullable' => true, 'quoted' => true)); if ($auditedClassMetadata->isIdentifier($fieldName)) { $identifiers[] = $fieldName; } } foreach ($auditedClassMetadata->getAssociationMappings() as $mapping) { if (!$mapping['isOwningSide'] || isset($mapping['joinTable'])) { continue; } if (isset($mapping['joinTableColumns'])) { foreach ($mapping['joinTableColumns'] as $field) { // FIXME: set data type correct for mapping info $builder->addField($mapping['fieldName'], 'bigint', array('nullable' => true, 'columnName' => $field)); } } elseif (isset($mapping['joinColumnFieldNames'])) { foreach ($mapping['joinColumnFieldNames'] as $field) { // FIXME: set data type correct for mapping info $builder->addField($mapping['fieldName'], 'bigint', array('nullable' => true, 'columnName' => $field)); } } else { throw new Exception('Unhandled association mapping'); } } $metadata->setTableName($this->getAuditOptions()['audit_table_name_prefix'] . $auditedClassMetadata->getTableName() . $this->getAuditOptions()['audit_table_name_suffix']); $metadata->setIdentifier($identifiers); return; }
/** * Insert enabled widgets in base widget add relationship between BusinessEntities and EntityProxy * @param LoadClassMetadataEventArgs $eventArgs */ public static function loadClassMetadata($eventArgs) { //this functions is called during the extract of translations //but the argument is not the same //so to avoid an error during extractions, we test the argument if ($eventArgs instanceof LoadClassMetadataEventArgs) { $annotationReader = self::$annotationReader; $metadatas = $eventArgs->getClassMetadata(); if ($metadatas->name === 'Victoire\\Bundle\\CoreBundle\\Entity\\EntityProxy') { foreach ($annotationReader->getBusinessClasses() as $field => $entity) { if (!$metadatas->hasAssociation($field)) { $metadatas->mapManyToOne(array('fieldName' => $field, 'targetEntity' => $entity, 'cascade' => array('persist'), 'inversedBy' => 'proxies')); } } } // Test if the current entity is a businessEntity $key = array_search($metadatas->name, $annotationReader->getBusinessClasses()); // If so, and if proxies relation has already been injected (by a parent BusinessEntity) if ($key && !$metadatas->hasAssociation('proxies')) { $metaBuilder = new ClassMetadataBuilder($metadatas); $metaBuilder->addOneToMany('proxies', 'Victoire\\Bundle\\CoreBundle\\Entity\\EntityProxy', $key); } } }
public function test_can_enable_2nd_level_cache() { $this->assertFalse($this->builder->getClassMetadata()->isReadOnly); $this->entity->cacheable(); $this->assertEquals(ClassMetadataInfo::CACHE_USAGE_READ_ONLY, $this->builder->getClassMetadata()->cache['usage']); $this->assertEquals('tests_stubs_entities_stubentity', $this->builder->getClassMetadata()->cache['region']); $this->entity->cacheable(ClassMetadataInfo::CACHE_USAGE_READ_WRITE, 'custom_region'); $this->assertEquals(ClassMetadataInfo::CACHE_USAGE_READ_WRITE, $this->builder->getClassMetadata()->cache['usage']); $this->assertEquals('custom_region', $this->builder->getClassMetadata()->cache['region']); }
/** * @return ClassMetadataBuilder * * @throws \InvalidArgumentException */ public function build() { $mapping = $this->mapping; if ($this->joinColumns) { $mapping['joinColumns'] = $this->joinColumns; } $cm = $this->builder->getClassMetadata(); if ($this->type == ClassMetadata::MANY_TO_ONE) { $cm->mapManyToOne($mapping); } else { if ($this->type == ClassMetadata::ONE_TO_ONE) { $cm->mapOneToOne($mapping); } else { throw new \InvalidArgumentException("Type should be a ToOne Association here"); } } return $this->builder; }