public AnnotationsMetadataReader(GlobalConfiguration globalCfg, PersistentClass pc)
{
this.globalCfg = globalCfg;
this.pc = pc;
_auditData = new ClassAuditingData();
}
public AnnotationsMetadataReader(GlobalConfiguration globalCfg, PersistentClass pc)
{
this.globalCfg = globalCfg;
this.pc = pc;
_auditData = new ClassAuditingData();
}
private static void ForcePropertyInsertable(ClassAuditingData classAuditingData, string propertyName,
string entityName, string referencedEntityName)
{
if (propertyName != null)
{
if (classAuditingData.GetPropertyAuditingData(propertyName) == null)
{
throw new MappingException("@AuditMappedBy points to a property that doesn't exist: " +
referencedEntityName + "." + propertyName);
}
log.DebugFormat("Non-insertable property {0}, {1} will be made insertable because a matching @AuditMappedBy was found in the {2} entity.",
referencedEntityName, propertyName, entityName);
classAuditingData
.GetPropertyAuditingData(propertyName)
.ForceInsertable = true;
}
}
public void GenerateSecondPass(PersistentClass pc, ClassAuditingData auditingData,
EntityXmlMappingData xmlMappingData) {
String entityName = pc.EntityName;
if (log.IsDebugEnabled)
{
log.Debug("Generating first-pass auditing mapping for entity " + entityName + ".");
}
ICompositeMapperBuilder propertyMapper = EntitiesConfigurations[entityName].PropertyMapper;
// Mapping unjoined properties
XmlElement parent = xmlMappingData.ClassMapping;
AddProperties(parent, (IEnumerator<Property>) pc.UnjoinedPropertyIterator.GetEnumerator(),
propertyMapper, auditingData, entityName, xmlMappingData, false);
// Mapping joins (second pass)
AddJoins(pc, propertyMapper, auditingData, entityName, xmlMappingData, false);
}
//@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);
}
//@SuppressWarnings({"unchecked"})
private void AddJoins(PersistentClass pc, ICompositeMapperBuilder currentMapper, ClassAuditingData auditingData,
String entityName, EntityXmlMappingData xmlMappingData, bool firstPass)
{
IEnumerator<Join> joins = pc.JoinIterator.GetEnumerator();
while (joins.MoveNext())
{
Join join = joins.Current;
XmlElement joinElement = entitiesJoins[entityName][join];
if (joinElement != null)
{
AddProperties(joinElement, (IEnumerator<Property>)join.PropertyIterator.GetEnumerator(), currentMapper, auditingData, entityName,
xmlMappingData, firstPass);
}
}
}
//@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);
}
}
private bool CheckPropertiesAudited(IEnumerator<Property> properties, ClassAuditingData auditingData)
{
while (properties.MoveNext())
{
Property property = properties.Current;
String propertyName = property.Name;
PropertyAuditingData propertyAuditingData = auditingData.getPropertyAuditingData(propertyName);
if (propertyAuditingData == null)
{
return false;
}
}
return true;
}
//@SuppressWarnings({"unchecked"})
private void AddProperties(XmlElement parent, IEnumerator<Property> properties, ICompositeMapperBuilder currentMapper,
ClassAuditingData auditingData, String entityName, EntityXmlMappingData xmlMappingData,
bool firstPass)
{
while (properties.MoveNext())
{
Property property = properties.Current;
String propertyName = property.Name;
PropertyAuditingData propertyAuditingData = auditingData.getPropertyAuditingData(propertyName);
if (propertyAuditingData != null)
{
AddValue(parent, property.Value, currentMapper, entityName, xmlMappingData, propertyAuditingData,
property.IsInsertable, firstPass);
}
}
}
/// <summary>
/// Stores information about auditing meta-data for the given class.
/// </summary>
/// <param name="pc">Persistent class.</param>
/// <param name="cad">Auditing meta-data for the given class.</param>
public void AddClassAuditingData(PersistentClass pc, ClassAuditingData cad)
{
entityNameToAuditingData.Add(pc.EntityName, cad);
persistentClassToAuditingData.Add(pc, cad);
}
private void CreateJoins(PersistentClass pc, XmlElement parent, ClassAuditingData auditingData)
{
var JoinElements = new Dictionary<Join, XmlElement>();
entitiesJoins.Add(pc.EntityName, JoinElements);
foreach (var join in pc.JoinIterator)
{
// Checking if all of the join properties are audited
if (!CheckPropertiesAudited(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).
var originalTableName = join.Table.Name;
string auditTableName;
if (!auditingData.JoinTableDictionary.TryGetValue(originalTableName, out auditTableName))
{
auditTableName = VerEntCfg.GetAuditEntityName(originalTableName);
}
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 = joinElement.OwnerDocument.CreateElement("key");
joinElement.AppendChild(joinKey);
MetadataTools.AddColumns(joinKey, join.Key.ColumnIterator.OfType<Column>());
MetadataTools.AddColumn(joinKey, VerEntCfg.RevisionFieldName, -1, 0, 0, null);
}
}
private void AddProperties(XmlElement parent, IEnumerable<Property> properties, ICompositeMapperBuilder currentMapper,
ClassAuditingData auditingData, string entityName, EntityXmlMappingData xmlMappingData,
bool firstPass)
{
foreach (var property in properties)
{
var propertyName = property.Name;
var propertyAuditingData = auditingData.GetPropertyAuditingData(propertyName);
if (propertyAuditingData != null)
{
AddValue(parent, property.Value, currentMapper, entityName, xmlMappingData, propertyAuditingData,
property.IsInsertable, firstPass);
}
}
}
private void AddJoins(PersistentClass pc, ICompositeMapperBuilder currentMapper, ClassAuditingData auditingData,
string entityName, EntityXmlMappingData xmlMappingData, bool firstPass)
{
foreach (var join in pc.JoinIterator)
{
var joinElement = entitiesJoins[entityName][join];
if (joinElement != null)
{
AddProperties(joinElement, join.PropertyIterator, currentMapper, auditingData, entityName,
xmlMappingData, firstPass);
}
}
}
private static bool CheckPropertiesAudited(IEnumerable<Property> properties, ClassAuditingData auditingData)
{
foreach (var property in properties)
{
var propertyName = property.Name;
var propertyAuditingData = auditingData.GetPropertyAuditingData(propertyName);
if (propertyAuditingData == null)
{
return false;
}
}
return true;
}
public void GenerateSecondPass(PersistentClass pc, ClassAuditingData auditingData,
EntityXmlMappingData xmlMappingData)
{
var entityName = pc.EntityName;
if (log.IsDebugEnabled)
{
log.DebugFormat("Generating second-pass auditing mapping for entity {0}.", entityName);
}
var propertyMapper = EntitiesConfigurations[entityName].PropertyMapper;
// Mapping unjoined properties
var parent = xmlMappingData.ClassMapping;
AddProperties(parent, pc.UnjoinedPropertyIterator,
propertyMapper, auditingData, entityName, xmlMappingData, false);
// Mapping joins (second pass)
AddJoins(pc, propertyMapper, auditingData, entityName, xmlMappingData, false);
}
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);
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);
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.GetAuditTableName(entityName, pc.Table.Name);
// 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);
var inheritanceType = pc.GetInheritanceType();
// These properties will be read from the mapping data
Triple<XmlElement, 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 = mappingData.First.OwnerDocument.CreateElement("key");
mappingData.First.AppendChild(keyMapping);
MetadataTools.AddColumns(keyMapping, pc.Table.PrimaryKey.ColumnIterator);
// ... and the revision number column, read from the revision info relation mapping.
keyMapping.AppendChild(CloneAndSetupRevisionInfoRelationMapping(keyMapping.OwnerDocument).GetElementsByTagName("column")[0].Clone());
break;
case InheritanceType.TablePerClass:
mappingData = GenerateInheritanceMappingData(pc, xmlMappingData, auditTableData, "union-subclass");
break;
default:
throw new AssertionFailure("AuditMetadataGenerator.GenerateFirstPass: Impossible enum value.");
}
var class_mapping = mappingData.First;
var propertyMapper = mappingData.Second;
var parentEntityName = mappingData.Third;
xmlMappingData.ClassMapping = class_mapping;
// Mapping unjoined properties
AddProperties(class_mapping, pc.UnjoinedPropertyIterator, 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
var entityCfg = new EntityConfiguration(auditEntityName, pc.ClassName, idMapper,
propertyMapper, parentEntityName);
EntitiesConfigurations.Add(pc.EntityName, entityCfg);
}
