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('title', 'string');
$builder->addManyToOne('album', 'Album', 'songs');
}
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->addOneToMany('songs', 'Song', 'album');
$builder->addInverseManyToMany('performers', 'Performer', 'albums');
}
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();
}
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();
}
/**
* 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();
}
/**
* Kept for BC-compatibility purposes : people expect this lib to map ids for
* translations.
*
* @deprecated It should be removed because it probably does not work with
* every doctrine version.
*
* @see https://github.com/doctrine/doctrine2/blob/0bff6aadbc9f3fd8167a320d9f4f6cf269382da0/lib/Doctrine/ORM/Mapping/ClassMetadataFactory.php#L508
*/
private function mapId(ClassMetadata $class, EntityManager $em)
{
$platform = $em->getConnection()->getDatabasePlatform();
if (!$class->hasField('id')) {
$builder = new ClassMetadataBuilder($class);
$builder->createField('id', 'integer')->isPrimaryKey()->generatedValue()->build();
/// START DOCTRINE CODE
$idGenType = $class->generatorType;
if ($idGenType == ClassMetadata::GENERATOR_TYPE_AUTO) {
if ($platform->prefersSequences()) {
$class->setIdGeneratorType(ClassMetadata::GENERATOR_TYPE_SEQUENCE);
} else {
if ($platform->prefersIdentityColumns()) {
$class->setIdGeneratorType(ClassMetadata::GENERATOR_TYPE_IDENTITY);
} else {
$class->setIdGeneratorType(ClassMetadata::GENERATOR_TYPE_TABLE);
}
}
}
// Create & assign an appropriate ID generator instance
switch ($class->generatorType) {
case ClassMetadata::GENERATOR_TYPE_IDENTITY:
// For PostgreSQL IDENTITY (SERIAL) we need a sequence name. It defaults to
// <table>_<column>_seq in PostgreSQL for SERIAL columns.
// Not pretty but necessary and the simplest solution that currently works.
$sequenceName = null;
$fieldName = $class->identifier ? $class->getSingleIdentifierFieldName() : null;
if ($platform instanceof Platforms\PostgreSQLPlatform) {
$columnName = $class->getSingleIdentifierColumnName();
$quoted = isset($class->fieldMappings[$fieldName]['quoted']) || isset($class->table['quoted']);
$sequenceName = $class->getTableName() . '_' . $columnName . '_seq';
$definition = array('sequenceName' => $platform->fixSchemaElementName($sequenceName));
if ($quoted) {
$definition['quoted'] = true;
}
$sequenceName = $em->getConfiguration()->getQuoteStrategy()->getSequenceName($definition, $class, $platform);
}
$generator = $fieldName && $class->fieldMappings[$fieldName]['type'] === 'bigint' ? new BigIntegerIdentityGenerator($sequenceName) : new IdentityGenerator($sequenceName);
$class->setIdGenerator($generator);
break;
case ClassMetadata::GENERATOR_TYPE_SEQUENCE:
// If there is no sequence definition yet, create a default definition
$definition = $class->sequenceGeneratorDefinition;
if (!$definition) {
$fieldName = $class->getSingleIdentifierFieldName();
$columnName = $class->getSingleIdentifierColumnName();
$quoted = isset($class->fieldMappings[$fieldName]['quoted']) || isset($class->table['quoted']);
$sequenceName = $class->getTableName() . '_' . $columnName . '_seq';
$definition = array('sequenceName' => $platform->fixSchemaElementName($sequenceName), 'allocationSize' => 1, 'initialValue' => 1);
if ($quoted) {
$definition['quoted'] = true;
}
$class->setSequenceGeneratorDefinition($definition);
}
$sequenceGenerator = new \Doctrine\ORM\Id\SequenceGenerator($em->getConfiguration()->getQuoteStrategy()->getSequenceName($definition, $class, $platform), $definition['allocationSize']);
$class->setIdGenerator($sequenceGenerator);
break;
case ClassMetadata::GENERATOR_TYPE_NONE:
$class->setIdGenerator(new \Doctrine\ORM\Id\AssignedGenerator());
break;
case ClassMetadata::GENERATOR_TYPE_UUID:
$class->setIdGenerator(new \Doctrine\ORM\Id\UuidGenerator());
break;
case ClassMetadata::GENERATOR_TYPE_TABLE:
throw new ORMException("TableGenerator not yet implemented.");
break;
case ClassMetadata::GENERATOR_TYPE_CUSTOM:
$definition = $class->customGeneratorDefinition;
if (!class_exists($definition['class'])) {
throw new ORMException("Can't instantiate custom generator : " . $definition['class']);
}
$class->setIdGenerator(new $definition['class']());
break;
default:
throw new ORMException("Unknown generator type: " . $class->generatorType);
}
/// END DOCTRINE COPY / PASTED code
}
}
/**
* Loads the metadata for the specified class into the provided container.
*
* @param string $className
* @param ClassMetadata $metadata
*/
function loadMetadataForClass($className, ClassMetadata $metadata)
{
$moduleOptions = \SoliantEntityAudit\Module::getModuleOptions();
$entityManager = $moduleOptions->getEntityManager();
$metadataFactory = $entityManager->getMetadataFactory();
$builder = new ClassMetadataBuilder($metadata);
if ($className == 'SoliantEntityAudit\\Entity\\RevisionEntity') {
$builder->createField('id', 'integer')->isPrimaryKey()->generatedValue()->build();
$builder->addManyToOne('revision', 'SoliantEntityAudit\\Entity\\Revision', 'revisionEntities');
$builder->addField('entityKeys', 'string');
$builder->addField('auditEntityClass', 'string');
$builder->addField('targetEntityClass', 'string');
$builder->addField('revisionType', 'string');
$builder->addField('title', 'string', array('nullable' => true));
$metadata->setTableName($moduleOptions->getRevisionEntityTableName());
return;
}
// Revision is managed here rather than a separate namespace and driver
if ($className == 'SoliantEntityAudit\\Entity\\Revision') {
$builder->createField('id', 'integer')->isPrimaryKey()->generatedValue()->build();
$builder->addField('comment', 'text', array('nullable' => true));
$builder->addField('timestamp', 'datetime');
// Add association between RevisionEntity and Revision
$builder->addOneToMany('revisionEntities', 'SoliantEntityAudit\\Entity\\RevisionEntity', 'revision');
// Add assoication between User and Revision
$userMetadata = $metadataFactory->getMetadataFor($moduleOptions->getUserEntityClassName());
$builder->createManyToOne('user', $userMetadata->getName())->addJoinColumn('user_id', $userMetadata->getSingleIdentifierColumnName())->build();
$metadata->setTableName($moduleOptions->getRevisionTableName());
return;
}
# $builder->createField('audit_id', 'integer')->isPrimaryKey()->generatedValue()->build();
$identifiers = array();
# $metadata->setIdentifier(array('audit_id'));
// Build a discovered many to many join class
$joinClasses = $moduleOptions->getJoinClasses();
if (in_array($className, array_keys($joinClasses))) {
$builder->createField('id', 'integer')->isPrimaryKey()->generatedValue()->build();
$builder->addManyToOne('targetRevisionEntity', 'SoliantEntityAudit\\Entity\\RevisionEntity');
$builder->addManyToOne('sourceRevisionEntity', 'SoliantEntityAudit\\Entity\\RevisionEntity');
$metadata->setTableName($moduleOptions->getTableNamePrefix() . $joinClasses[$className]['joinTable']['name'] . $moduleOptions->getTableNameSuffix());
// $metadata->setIdentifier($identifiers);
return;
}
// Get the entity this entity audits
$metadataClassName = $metadata->getName();
$metadataClass = new $metadataClassName();
$auditedClassMetadata = $metadataFactory->getMetadataFor($metadataClass->getAuditedEntityClass());
try {
$builder->addManyToOne($moduleOptions->getRevisionEntityFieldName(), 'SoliantEntityAudit\\Entity\\RevisionEntity');
} catch (MappingException $e) {
// do nothing
}
// Compound keys removed in favor of auditId (audit_id)
$identifiers[] = $moduleOptions->getRevisionEntityFieldName();
// Add fields from target to audit entity
foreach ($auditedClassMetadata->getFieldNames() as $fieldName) {
$fieldMapping = $auditedClassMetadata->getFieldMapping($fieldName);
if (!isset($fieldMapping['inherited']) && !isset($fieldMapping['declared'])) {
$fieldMapping['nullable'] = true;
$fieldMapping['quoted'] = true;
$builder->addField($fieldName, $auditedClassMetadata->getTypeOfField($fieldName), $fieldMapping);
}
if ($auditedClassMetadata->isIdentifier($fieldName)) {
$identifiers[] = $fieldName;
}
}
foreach ($auditedClassMetadata->getAssociationMappings() as $mapping) {
if (!isset($mapping['inherited']) && !isset($mapping['declared'])) {
if (!$mapping['isOwningSide']) {
continue;
}
if (isset($mapping['joinTable'])) {
continue;
}
if (isset($mapping['joinTableColumns'])) {
foreach ($mapping['joinTableColumns'] as $field) {
$builder->addField($mapping['fieldName'], 'integer', array('nullable' => true, 'columnName' => $field));
}
} elseif (isset($mapping['joinColumnFieldNames'])) {
foreach ($mapping['joinColumnFieldNames'] as $field) {
$builder->addField($mapping['fieldName'], 'integer', array('nullable' => true, 'columnName' => $field));
}
} else {
throw new \Exception('Unhandled association mapping');
}
}
}
if ($auditedClassMetadata->isInheritanceTypeJoined() || $auditedClassMetadata->isInheritanceTypeSingleTable()) {
$metadata->setInheritanceType($auditedClassMetadata->inheritanceType);
$metadata->setDiscriminatorColumn($auditedClassMetadata->discriminatorColumn);
$parentAuditClasses = array();
$subAuditClasses = array();
foreach ($auditedClassMetadata->parentClasses as $idx => $parentClass) {
$parentAuditClass = 'SoliantEntityAudit\\Entity\\' . str_replace('\\', '_', $parentClass);
$parentAuditClasses[$idx] = $parentAuditClass;
}
$metadata->setParentClasses($parentAuditClasses);
foreach ($auditedClassMetadata->subClasses as $idx => $subClass) {
$subAuditClass = 'SoliantEntityAudit\\Entity\\' . str_replace('\\', '_', $subClass);
$subAuditClasses[$idx] = $subAuditClass;
}
$metadata->setSubClasses($subAuditClasses);
foreach ($auditedClassMetadata->discriminatorMap as $mapName => $mapClass) {
$mapAuditClass = 'SoliantEntityAudit\\Entity\\' . str_replace('\\', '_', $mapClass);
$metadata->addDiscriminatorMapClass($mapName, $mapAuditClass);
}
}
$metadata->setPrimaryTable(array('name' => $moduleOptions->getTableNamePrefix() . $auditedClassMetadata->getTableName() . $moduleOptions->getTableNameSuffix()));
$metadata->setIdentifier($identifiers);
return;
}
public function testCreatePrimaryField()
{
$this->builder->createField('id', 'integer')->isPrimaryKey()->generatedValue()->build();
$this->assertEquals(array('id'), $this->cm->identifier);
$this->assertEquals(array('columnName' => 'id', 'fieldName' => 'id', 'id' => true, 'type' => 'integer'), $this->cm->fieldMappings['id']);
}
/**
* Loads the metadata for the specified class into the provided container.
*
* @param string $className
* @param ClassMetadata $metadata
*/
function loadMetadataForClass($className, ClassMetadata $metadata)
{
$moduleOptions = \ZF\Doctrine\Audit\Module::getModuleOptions();
$entityManager = $moduleOptions->getEntityManager();
$metadataFactory = $entityManager->getMetadataFactory();
$builder = new ClassMetadataBuilder($metadata);
if ($className == 'ZF\\Doctrine\\Audit\\Entity\\RevisionEntity') {
$builder->createField('id', 'integer')->isPrimaryKey()->generatedValue()->build();
$builder->addManyToOne('revision', 'ZF\\Doctrine\\Audit\\Entity\\Revision', 'revisionEntities');
$builder->addField('entityKeys', 'string');
$builder->addField('auditEntityClass', 'string');
$builder->addField('targetEntityClass', 'string');
$builder->addField('revisionType', 'string');
$builder->addField('title', 'string', array('nullable' => true));
$metadata->setTableName($moduleOptions->getRevisionEntityTableName());
return;
}
// Revision is managed here rather than a separate namespace and driver
if ($className == 'ZF\\Doctrine\\Audit\\Entity\\Revision') {
$builder->createField('id', 'integer')->isPrimaryKey()->generatedValue()->build();
$builder->addField('comment', 'text', array('nullable' => true));
$builder->addField('timestamp', 'datetime');
// Add association between RevisionEntity and Revision
$builder->addOneToMany('revisionEntities', 'ZF\\Doctrine\\Audit\\Entity\\RevisionEntity', 'revision');
// Add assoication between User and Revision
$userMetadata = $metadataFactory->getMetadataFor($moduleOptions->getUserEntityClassName());
$builder->createManyToOne('user', $userMetadata->getName())->addJoinColumn('user_id', $userMetadata->getSingleIdentifierColumnName())->build();
$metadata->setTableName($moduleOptions->getRevisionTableName());
return;
}
# $builder->createField('audit_id', 'integer')->isPrimaryKey()->generatedValue()->build();
$identifiers = array();
# $metadata->setIdentifier(array('audit_id'));
// Build a discovered many to many join class
$joinClasses = $moduleOptions->getJoinClasses();
if (in_array($className, array_keys($joinClasses))) {
$builder->createField('id', 'integer')->isPrimaryKey()->generatedValue()->build();
$builder->addManyToOne('targetRevisionEntity', 'ZF\\Doctrine\\Audit\\Entity\\RevisionEntity');
$builder->addManyToOne('sourceRevisionEntity', 'ZF\\Doctrine\\Audit\\Entity\\RevisionEntity');
$metadata->setTableName($moduleOptions->getTableNamePrefix() . $joinClasses[$className]['joinTable']['name'] . $moduleOptions->getTableNameSuffix());
// $metadata->setIdentifier($identifiers);
return;
}
// Get the entity this entity audits
$metadataClassName = $metadata->getName();
$metadataClass = new $metadataClassName();
$auditedClassMetadata = $metadataFactory->getMetadataFor($metadataClass->getAuditedEntityClass());
$builder->addManyToOne($moduleOptions->getRevisionEntityFieldName(), 'ZF\\Doctrine\\Audit\\Entity\\RevisionEntity');
# Compound keys removed in favor of auditId (audit_id)
$identifiers[] = $moduleOptions->getRevisionEntityFieldName();
// Add fields from target to audit entity
foreach ($auditedClassMetadata->getFieldNames() as $fieldName) {
$builder->addField($fieldName, $auditedClassMetadata->getTypeOfField($fieldName), array('nullable' => true, 'quoted' => true));
if ($auditedClassMetadata->isIdentifier($fieldName)) {
$identifiers[] = $fieldName;
}
}
foreach ($auditedClassMetadata->getAssociationMappings() as $mapping) {
if (!$mapping['isOwningSide']) {
continue;
}
if (isset($mapping['joinTable'])) {
continue;
}
if (isset($mapping['joinTableColumns'])) {
foreach ($mapping['joinTableColumns'] as $field) {
$builder->addField($mapping['fieldName'], 'integer', array('nullable' => true, 'columnName' => $field));
}
} elseif (isset($mapping['joinColumnFieldNames'])) {
foreach ($mapping['joinColumnFieldNames'] as $field) {
$builder->addField($mapping['fieldName'], 'integer', array('nullable' => true, 'columnName' => $field));
}
} else {
throw new \Exception('Unhandled association mapping');
}
}
$metadata->setTableName($moduleOptions->getTableNamePrefix() . $auditedClassMetadata->getTableName() . $moduleOptions->getTableNameSuffix());
$metadata->setIdentifier($identifiers);
return;
}
/**
* @param ClassMetadataBuilder $builder
* @param string $type
* @param string $name
*
* @throws \Doctrine\DBAL\DBALException
* @return Field
*/
public static function make(ClassMetadataBuilder $builder, $type, $name)
{
$type = Type::getType($type);
$field = $builder->createField($name, $type->getName());
return new static($field, $builder->getClassMetadata());
}
public function testCreateUnsignedOptionField()
{
$this->builder->createField('state', 'integer')->option('unsigned', true)->build();
$this->assertEquals(array('fieldName' => 'state', 'type' => 'integer', 'options' => array('unsigned' => true), 'columnName' => 'state'), $this->cm->fieldMappings['state']);
}
