private Tuple <XElement, IExtendedPropertyMapper, string> generateInheritanceMappingData(
PersistentClass pc, EntityXmlMappingData xmlMappingData, AuditTableData auditTableData,
string inheritanceMappingType)
{
var extendsEntityName = VerEntCfg.GetAuditEntityName(pc.Superclass.EntityName);
var hasDiscriminator = pc.Discriminator != null;
var classMapping = MetadataTools.CreateSubclassEntity(xmlMappingData.MainXmlMapping,
inheritanceMappingType, auditTableData, extendsEntityName, hasDiscriminator ? pc.DiscriminatorValue : null,
pc.IsAbstract.HasValue && pc.IsAbstract.Value);
// The id and revision type is already mapped in the parent
// Getting the property mapper of the parent - when mapping properties, they need to be included
var parentEntityName = pc.Superclass.EntityName;
EntityConfiguration parentConfiguration;
if (!EntitiesConfigurations.TryGetValue(parentEntityName, out parentConfiguration))
{
throw new MappingException("Entity '" + pc.EntityName + "' is audited, but its superclass: '" + parentEntityName + "' is not.");
}
var parentPropertyMapper = parentConfiguration.PropertyMapper;
var propertyMapper = new SubclassPropertyMapper(new MultiPropertyMapper(), parentPropertyMapper);
return(new Tuple <XElement, IExtendedPropertyMapper, string>(classMapping, propertyMapper, parentEntityName));
}
private void createJoins(PersistentClass pc, XElement parent, ClassAuditingData auditingData)
{
var joinElements = new Dictionary <Join, XElement>();
entitiesJoins.Add(pc.EntityName, joinElements);
foreach (var join in pc.JoinIterator)
{
// Checking if any of the join properties are audited
if (!checkAnyPropertyAudited(join.PropertyIterator, auditingData))
{
continue;
}
// Determining the table name. If there is no entry in the dictionary, just constructing the table name
// as if it was an entity (by appending/prepending configured strings).
string auditTableName;
if (!auditingData.JoinTableDictionary.TryGetValue(join.Table.Name, out auditTableName))
{
auditTableName = VerEntCfg.JoinTableName(join);
}
var schema = GetSchema(auditingData.AuditTable.Schema, join.Table);
var catalog = GetCatalog(auditingData.AuditTable.Catalog, join.Table);
var joinElement = MetadataTools.CreateJoin(parent, auditTableName, schema, catalog);
joinElements.Add(join, joinElement);
var joinKey = new XElement(MetadataTools.CreateElementName("key"));
joinElement.Add(joinKey);
MetadataTools.AddColumns(joinKey, join.Key.ColumnIterator.OfType <Column>());
MetadataTools.AddColumn(joinKey, VerEntCfg.RevisionFieldName, -1, -1, -1, null, false);
}
}
private Triple<XmlElement, IExtendedPropertyMapper, String> GenerateInheritanceMappingData(
PersistentClass pc, EntityXmlMappingData xmlMappingData, AuditTableData auditTableData,
String inheritanceMappingType)
{
String extendsEntityName = VerEntCfg.GetAuditEntityName(pc.Superclass.EntityName);
XmlElement class_mapping = MetadataTools.CreateSubclassEntity(xmlMappingData.MainXmlMapping,
inheritanceMappingType, auditTableData, extendsEntityName, pc.DiscriminatorValue);
// The id and revision type is already mapped in the parent
// Getting the property mapper of the parent - when mapping properties, they need to be included
String parentEntityName = pc.Superclass.EntityName;
EntityConfiguration parentConfiguration = EntitiesConfigurations[parentEntityName];
if (parentConfiguration == null)
{
throw new MappingException("Entity '" + pc.EntityName + "' is audited, but its superclass: '" +
parentEntityName + "' is not.");
}
IExtendedPropertyMapper parentPropertyMapper = parentConfiguration.PropertyMapper;
IExtendedPropertyMapper propertyMapper = new SubclassPropertyMapper(new MultiPropertyMapper(), parentPropertyMapper);
return Triple<XmlElement, IExtendedPropertyMapper, String>.Make<XmlElement, IExtendedPropertyMapper, String>(class_mapping, propertyMapper, parentEntityName);
}
//@SuppressWarnings({"unchecked"})
private void CreateJoins(PersistentClass pc, XmlElement parent, ClassAuditingData auditingData)
{
IEnumerator<Join> joins = pc.JoinIterator.GetEnumerator();
IDictionary<Join, XmlElement> JoinElements = new Dictionary<Join, XmlElement>();
entitiesJoins.Add(pc.EntityName, JoinElements);
while (joins.MoveNext())
{
Join join = joins.Current;
// Checking if all of the join properties are audited
if (!CheckPropertiesAudited(join.PropertyIterator.GetEnumerator(), auditingData))
{
continue;
}
// Determining the table name. If there is no entry in the dictionary, just constructing the table name
// as if it was an entity (by appending/prepending configured strings).
String originalTableName = join.Table.Name;
String auditTableName = auditingData.SecondaryTableDictionary[originalTableName];
if (auditTableName == null)
{
auditTableName = VerEntCfg.GetAuditEntityName(originalTableName);
}
String schema = GetSchema(auditingData.AuditTable.schema, join.Table);
String catalog = GetCatalog(auditingData.AuditTable.catalog, join.Table);
XmlElement joinElement = MetadataTools.CreateJoin(parent, auditTableName, schema, catalog);
JoinElements.Add(join, joinElement);
XmlElement joinKey = joinElement.OwnerDocument.CreateElement("key");
joinElement.AppendChild(joinKey);
MetadataTools.AddColumns(joinKey, (IEnumerator<ISelectable>)join.Key.ColumnIterator.GetEnumerator());
MetadataTools.AddColumn(joinKey, VerEntCfg.RevisionFieldName, -1, 0, 0, null);
}
}
public void GenerateFirstPass(PersistentClass pc, ClassAuditingData auditingData,
EntityXmlMappingData xmlMappingData, bool isAudited)
{
var schema = GetSchema(auditingData.AuditTable.Schema, pc.Table);
var catalog = GetCatalog(auditingData.AuditTable.Catalog, pc.Table);
Func <System.Type, object> factory = auditingData.Factory.Factory.Instantiate;
var entityName = pc.EntityName;
if (!isAudited)
{
var _idMapper = idMetadataGenerator.AddId(pc);
if (_idMapper == null)
{
// Unsupported id mapping, e.g. key-many-to-one. If the entity is used in auditing, an exception
// will be thrown later on.
if (log.IsDebugEnabled)
{
log.DebugFormat("Unable to create auditing id mapping for entity {0}" +
", because of an unsupported Hibernate id mapping (e.g. key-many-to-one).", entityName);
}
return;
}
//ORIG:
//IExtendedPropertyMapper propertyMapper = null;
//String parentEntityName = null;
var _entityCfg = new EntityConfiguration(entityName, pc.ClassName, _idMapper, null, null, factory);
NotAuditedEntitiesConfigurations.Add(entityName, _entityCfg);
return;
}
if (log.IsDebugEnabled)
{
log.DebugFormat("Generating first-pass auditing mapping for entity {0}.", entityName);
}
var auditEntityName = VerEntCfg.GetAuditEntityName(entityName);
var auditTableName = VerEntCfg.AuditTableName(entityName, pc);
// Registering the audit entity name, now that it is known
AuditEntityNameRegister.Register(auditEntityName);
var auditTableData = new AuditTableData(auditEntityName, auditTableName, schema, catalog);
// Generating a mapping for the id
var idMapper = idMetadataGenerator.AddId(pc);
if (idMapper == null)
{
throw new AuditException("Id mapping for type " + pc.ClassName +
" is currently not supported in Envers. If you need composite-id, use 'Components as composite identifiers'.");
}
var inheritanceType = pc.GetInheritanceType();
// These properties will be read from the mapping data
Tuple <XElement, IExtendedPropertyMapper, string> mappingData;
// Reading the mapping data depending on inheritance type (if any)
switch (inheritanceType)
{
case InheritanceType.None:
mappingData = generateMappingData(pc, xmlMappingData, auditTableData, idMapper);
break;
case InheritanceType.Single:
auditTableData = new AuditTableData(auditEntityName, null, schema, catalog);
mappingData = generateInheritanceMappingData(pc, xmlMappingData, auditTableData, "subclass");
break;
case InheritanceType.Joined:
mappingData = generateInheritanceMappingData(pc, xmlMappingData, auditTableData, "joined-subclass");
// Adding the "key" element with all id columns...
var keyMapping = new XElement(MetadataTools.CreateElementName("key"));
mappingData.Item1.Add(keyMapping);
MetadataTools.AddColumns(keyMapping, pc.Table.PrimaryKey.ColumnIterator);
// ... and the revision number column, read from the revision info relation mapping.
keyMapping.Add(cloneAndSetupRevisionInfoRelationMapping().Element(MetadataTools.CreateElementName("column")));
break;
case InheritanceType.TablePerClass:
mappingData = generateInheritanceMappingData(pc, xmlMappingData, auditTableData, "union-subclass");
break;
default:
throw new AssertionFailure("AuditMetadataGenerator.GenerateFirstPass: Impossible enum value.");
}
var classMapping = mappingData.Item1;
var propertyMapper = mappingData.Item2;
var parentEntityName = mappingData.Item3;
xmlMappingData.ClassMapping = classMapping;
// Mapping unjoined properties
addProperties(classMapping, pc.UnjoinedPropertyIterator, propertyMapper,
auditingData, pc.EntityName, xmlMappingData,
true);
// Creating and mapping joins (first pass)
createJoins(pc, classMapping, auditingData);
addJoins(pc, propertyMapper, auditingData, pc.EntityName, xmlMappingData, true);
// Storing the generated configuration
var entityCfg = new EntityConfiguration(auditEntityName, pc.ClassName, idMapper,
propertyMapper, parentEntityName, factory);
EntitiesConfigurations.Add(pc.EntityName, entityCfg);
}
//@SuppressWarnings({"unchecked"})
public void GenerateFirstPass(PersistentClass pc, ClassAuditingData auditingData,
EntityXmlMappingData xmlMappingData, bool isAudited)
{
String schema = GetSchema(auditingData.AuditTable.schema, pc.Table);
String catalog = GetCatalog(auditingData.AuditTable.catalog, pc.Table);
String entityName = pc.EntityName;
if (!isAudited)
{
IdMappingData _idMapper = idMetadataGenerator.AddId(pc);
if (_idMapper == null)
{
// Unsupported id mapping, e.g. key-many-to-one. If the entity is used in auditing, an exception
// will be thrown later on.
if (log.IsDebugEnabled)
{
log.Debug("Unable to create auditing id mapping for entity " + entityName +
", because of an unsupported Hibernate id mapping (e.g. key-many-to-one).");
}
return;
}
//ORIG:
//IExtendedPropertyMapper propertyMapper = null;
//String parentEntityName = null;
EntityConfiguration _entityCfg = new EntityConfiguration(entityName, _idMapper, null,
null);
NotAuditedEntitiesConfigurations.Add(entityName, _entityCfg);
return;
}
if (log.IsDebugEnabled)
{
log.Debug("Generating first-pass auditing mapping for entity " + entityName + ".");
}
String auditEntityName = VerEntCfg.GetAuditEntityName(entityName);
String auditTableName = VerEntCfg.GetAuditTableName(entityName, pc.Table.Name);
// Registering the audit entity name, now that it is known
AuditEntityNameRegister.register(auditEntityName);
AuditTableData auditTableData = new AuditTableData(auditEntityName, auditTableName, schema, catalog);
// Generating a mapping for the id
IdMappingData idMapper = idMetadataGenerator.AddId(pc);
InheritanceType.Type inheritanceType = InheritanceType.GetForChild(pc);
// These properties will be read from the mapping data
XmlElement class_mapping;
IExtendedPropertyMapper propertyMapper;
String parentEntityName;
Triple<XmlElement, IExtendedPropertyMapper, String> mappingData;
// Reading the mapping data depending on inheritance type (if any)
switch (inheritanceType)
{
case InheritanceType.Type.NONE:
mappingData = GenerateMappingData(pc, xmlMappingData, auditTableData, idMapper);
break;
case InheritanceType.Type.SINGLE:
mappingData = GenerateInheritanceMappingData(pc, xmlMappingData, auditTableData, "subclass");
break;
case InheritanceType.Type.JOINED:
mappingData = GenerateInheritanceMappingData(pc, xmlMappingData, auditTableData, "joined-subclass");
AddJoinedInheritancePersisterHack(mappingData.First);
// Adding the "key" element with all id columns...
XmlElement keyMapping = mappingData.First.OwnerDocument.CreateElement("key");
mappingData.First.AppendChild(keyMapping);
MetadataTools.AddColumns(keyMapping, (IEnumerator<ISelectable>)pc.Table.PrimaryKey.ColumnIterator.GetEnumerator());
// ... and the revision number column, read from the revision info relation mapping.
keyMapping.AppendChild((XmlElement)CloneAndSetupRevisionInfoRelationMapping(keyMapping.OwnerDocument).GetElementsByTagName("column")[0].Clone());
break;
case InheritanceType.Type.TABLE_PER_CLASS:
mappingData = GenerateInheritanceMappingData(pc, xmlMappingData, auditTableData, "union-subclass");
AddTablePerClassInheritancePersisterHack(mappingData.First);
break;
default:
throw new AssertionFailure("Envers.NET: AuditMetadataGenerator.GenerateFirstPass: Impossible enum value.");
}
class_mapping = mappingData.First;
propertyMapper = mappingData.Second;
parentEntityName = mappingData.Third;
xmlMappingData.ClassMapping = class_mapping;
// Mapping unjoined properties
AddProperties(class_mapping, (IEnumerator<Property>)pc.UnjoinedPropertyIterator.GetEnumerator(), propertyMapper,
auditingData, pc.EntityName, xmlMappingData,
true);
// Creating and mapping joins (first pass)
CreateJoins(pc, class_mapping, auditingData);
AddJoins(pc, propertyMapper, auditingData, pc.EntityName, xmlMappingData, true);
// Storing the generated configuration
EntityConfiguration entityCfg = new EntityConfiguration(auditEntityName, idMapper,
propertyMapper, parentEntityName);
EntitiesConfigurations.Add(pc.EntityName, entityCfg);
}
