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