/**
* @param ClassMetadata $class
* @param array $reference
*/
protected function setModelReference(ClassMetadata $class, array $reference)
{
$class->setIdentifier($reference['manager'], $reference['field']);
foreach ($reference['config'] as $name => $config) {
switch ($name) {
case 'reference':
$class->addRefenceIdentifier($config['manager'], isset($config['referenceField']) ? $config['referenceField'] : $reference['field'], $config['field']);
break;
case 'idGenerator':
$class->setManagerReferenceGenerator($config['target-manager']);
break;
}
}
}
/**
* 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;
}
/**
* Extract the property annotations.
*
* @param \ReflectionProperty[] $reflProperties
* @param ClassMetadata|\Revinate\SearchBundle\Lib\Search\Mapping\ClassMetadata $metadata
*
* @return ClassMetadata|\Revinate\SearchBundle\Lib\Search\Mapping\ClassMetadata
*/
private function extractPropertiesAnnotations(array $reflProperties, ClassMetadata $metadata)
{
foreach ($reflProperties as $reflProperty) {
foreach ($this->reader->getPropertyAnnotations($reflProperty) as $annotation) {
foreach ($this->entityFieldAnnotationClasses as $fieldAnnotationClass) {
if ($annotation instanceof $fieldAnnotationClass) {
if ($annotation instanceof $this->entityIdAnnotationClass) {
$metadata->setIdentifier($reflProperty->name);
} elseif ($annotation instanceof $this->entityTimeSeriesFieldAnnotationClass) {
$metadata->setTimeSeriesField($reflProperty->name);
} elseif ($annotation instanceof $this->entityParamAnnotationClass) {
$metadata->addParameterMapping($reflProperty, $annotation);
} elseif ($annotation instanceof $this->entityParentFieldAnnotationClass) {
$metadata->setParentField($reflProperty->name);
} elseif ($annotation instanceof $this->entityVersionFieldAnnotationClass) {
/** @var Search\VersionField $annotation */
$metadata->setVersionField($reflProperty->name);
$metadata->setVersionType($annotation->versionType);
} else {
$metadata->addFieldMapping($reflProperty, $annotation);
}
continue 2;
}
}
}
}
$id = $metadata->getIdentifier();
if (empty($id)) {
throw new \Exception(__METHOD__ . ': Id field must be defined!');
}
if ($metadata->timeSeriesScale && !$metadata->getTimeSeriesField()) {
throw new \Exception(__METHOD__ . ': TimeSeriesField must be defined for a time series index!');
}
return $metadata;
}
/**
* 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;
}
/**
* 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;
}
/**
* Extract the property annotations.
*
* @param \ReflectionProperty[] $reflProperties
* @param ClassMetadata|\Doctrine\Search\Mapping\ClassMetadata $metadata
*
* @return ClassMetadata|\Doctrine\Search\Mapping\ClassMetadata
*/
private function extractPropertiesAnnotations(array $reflProperties, ClassMetadata $metadata)
{
$documentsFieldAnnotations = array();
foreach ($reflProperties as $reflProperty) {
foreach ($this->reader->getPropertyAnnotations($reflProperty) as $annotation) {
foreach ($this->entityFieldAnnotationClasses as $fieldAnnotationClass) {
if ($annotation instanceof $fieldAnnotationClass) {
if ($annotation instanceof $this->entityIdAnnotationClass) {
$metadata->setIdentifier($reflProperty->name);
} elseif ($annotation instanceof $this->entityParamAnnotationClass) {
$metadata->addParameterMapping($reflProperty, $annotation);
} else {
$metadata->addFieldMapping($reflProperty, $annotation);
}
continue 2;
}
}
}
}
return $metadata;
}
private function addFieldMapping(ClassMetadataInterface $class, ClassMetadataInterface $parent)
{
foreach ($parent->reflFields as $name => $field) {
$class->reflFields[$name] = $field;
}
foreach ($parent->fieldMappings as $name => $field) {
$class->fieldMappings[$name] = $field;
}
foreach ($parent->jsonNames as $name => $field) {
$class->jsonNames[$name] = $field;
}
if ($parent->identifier) {
$class->setIdentifier($parent->identifier);
}
}
