public void AddComponent(XmlElement parent, PropertyAuditingData propertyAuditingData, IValue value, ICompositeMapperBuilder mapper, string entityName, EntityXmlMappingData xmlMappingData, bool firstPass, bool insertable) { var propComponent = (Component) value; var componentMapper = mapper.AddComponent(propertyAuditingData.GetPropertyData(), propComponent.ComponentClassName); // The property auditing data must be for a component. var componentAuditingData = (ComponentAuditingData) propertyAuditingData; // Adding all properties of the component foreach (var property in propComponent.PropertyIterator) { var componentPropertyAuditingData = componentAuditingData.GetPropertyAuditingData(property.Name); // Checking if that property is audited if (componentPropertyAuditingData != null) { mainGenerator.AddValue(parent, property.Value, componentMapper, entityName, xmlMappingData, componentPropertyAuditingData, property.IsInsertable && insertable, firstPass); } } }
//@SuppressWarnings({"unchecked"}) public void AddComponent(XmlElement parent, PropertyAuditingData propertyAuditingData, IValue value, ICompositeMapperBuilder mapper, String entityName, EntityXmlMappingData xmlMappingData, bool firstPass) { Component prop_component = (Component) value; ICompositeMapperBuilder componentMapper = mapper.AddComponent(propertyAuditingData.getPropertyData(), prop_component.ComponentClassName); // The property auditing data must be for a component. ComponentAuditingData componentAuditingData = (ComponentAuditingData) propertyAuditingData; // Adding all properties of the component IEnumerator<Property> properties = (IEnumerator<Property>) prop_component.PropertyIterator.GetEnumerator(); while (properties.MoveNext()) { Property property = properties.Current; PropertyAuditingData componentPropertyAuditingData = componentAuditingData.getPropertyAuditingData(property.Name); // Checking if that property is audited if (componentPropertyAuditingData != null) { mainGenerator.AddValue(parent, property.Value, componentMapper, entityName, xmlMappingData, componentPropertyAuditingData, property.IsInsertable, firstPass); } } }
/** * @param mainGenerator Main generator, giving access to configuration and the basic mapper. * @param propertyValue Value of the collection, as mapped by Hibernate. * @param currentMapper Mapper, to which the appropriate {@link org.hibernate.envers.entities.mapper.PropertyMapper} * will be added. * @param referencingEntityName Name of the entity that owns this collection. * @param xmlMappingData In case this collection requires a middle table, additional mapping documents will * be created using this object. * @param propertyAuditingData Property auditing (meta-)data. Among other things, holds the name of the * property that references the collection in the referencing entity, the user data for middle (join) * table and the value of the <code>@MapKey</code> annotation, if there was one. */ public CollectionMetadataGenerator(AuditMetadataGenerator mainGenerator, Mapping.Collection propertyValue, ICompositeMapperBuilder currentMapper, String referencingEntityName, EntityXmlMappingData xmlMappingData, PropertyAuditingData propertyAuditingData) { this.mainGenerator = mainGenerator; this.propertyValue = propertyValue; this.currentMapper = currentMapper; this.referencingEntityName = referencingEntityName; this.xmlMappingData = xmlMappingData; this.propertyAuditingData = propertyAuditingData; this.propertyName = propertyAuditingData.Name; referencingEntityConfiguration = mainGenerator.EntitiesConfigurations[referencingEntityName]; if (referencingEntityConfiguration == null) { throw new MappingException("Unable to read auditing configuration for " + referencingEntityName + "!"); } referencedEntityName = MappingTools.getReferencedEntityName(propertyValue.Element); }
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 Triple<XmlElement, IExtendedPropertyMapper, String> GenerateMappingData( PersistentClass pc, EntityXmlMappingData xmlMappingData, AuditTableData auditTableData, IdMappingData idMapper) { bool hasDiscriminator = pc.Discriminator != null; XmlElement class_mapping = MetadataTools.CreateEntity(xmlMappingData.MainXmlMapping, auditTableData, hasDiscriminator ? pc.DiscriminatorValue : null); IExtendedPropertyMapper propertyMapper = new MultiPropertyMapper(); // Checking if there is a discriminator column if (hasDiscriminator) { XmlElement discriminator_element = class_mapping.OwnerDocument.CreateElement("discriminator"); class_mapping.AppendChild(discriminator_element); MetadataTools.AddColumns(discriminator_element, (IEnumerator<ISelectable>)pc.Discriminator.ColumnIterator.GetEnumerator()); discriminator_element.SetAttribute("type", pc.Discriminator.Type.Name); } InheritanceType.Type parentInheritance = InheritanceType.GetForParent(pc); switch (parentInheritance) { case InheritanceType.Type.NONE: break; case InheritanceType.Type.SINGLE: AddSingleInheritancePersisterHack(class_mapping); break; case InheritanceType.Type.JOINED: AddJoinedInheritancePersisterHack(class_mapping); break; case InheritanceType.Type.TABLE_PER_CLASS: AddTablePerClassInheritancePersisterHack(class_mapping); break; } // Adding the id mapping XmlNode xmlMp = class_mapping.OwnerDocument.ImportNode(idMapper.XmlMapping,true); class_mapping.AppendChild(xmlMp); // Adding the "revision type" property AddRevisionType(class_mapping); return Triple<XmlElement, IExtendedPropertyMapper, string>.Make<XmlElement, IExtendedPropertyMapper, string>(class_mapping, propertyMapper, null); }
//@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 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); } } }
//@SuppressWarnings({"unchecked"}) public void AddValue(XmlElement parent, IValue value, ICompositeMapperBuilder currentMapper, String entityName, EntityXmlMappingData xmlMappingData, PropertyAuditingData propertyAuditingData, bool insertable, bool firstPass) { IType type = value.Type; // only first pass if (firstPass) { if (BasicMetadataGenerator.AddBasic(parent, propertyAuditingData, value, currentMapper, insertable, false)) { // The property was mapped by the basic generator. return; } } if (type is ComponentType) { // both passes componentMetadataGenerator.AddComponent(parent, propertyAuditingData, value, currentMapper, entityName, xmlMappingData, firstPass); } else if (type is ManyToOneType) { // only second pass if (!firstPass) { toOneRelationMetadataGenerator.AddToOne(parent, propertyAuditingData, value, currentMapper, entityName, insertable); } } else if (type is OneToOneType) { // only second pass if (!firstPass) { toOneRelationMetadataGenerator.AddOneToOneNotOwning(propertyAuditingData, value, currentMapper, entityName); } } else if (type is CollectionType) { // only second pass if (!firstPass) { CollectionMetadataGenerator collectionMetadataGenerator = new CollectionMetadataGenerator(this, (Mapping.Collection)value, currentMapper, entityName, xmlMappingData, propertyAuditingData); collectionMetadataGenerator.AddCollection(); } } else { if (firstPass) { // If we got here in the first pass, it means the basic mapper didn't map it, and none of the // above branches either. ThrowUnsupportedTypeException(type, entityName, propertyAuditingData.Name); } } }
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); }
private void addProperties(XElement 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, true); } } }
private Triple<XmlElement, IExtendedPropertyMapper, string> GenerateMappingData( PersistentClass pc, EntityXmlMappingData xmlMappingData, AuditTableData auditTableData, IdMappingData idMapper) { var hasDiscriminator = pc.Discriminator != null; var classMapping = MetadataTools.CreateEntity(xmlMappingData.MainXmlMapping, auditTableData, hasDiscriminator ? pc.DiscriminatorValue : null); var propertyMapper = new MultiPropertyMapper(); // Adding the id mapping var xmlMp = classMapping.OwnerDocument.ImportNode(idMapper.XmlMapping, true); classMapping.AppendChild(xmlMp); // Checking if there is a discriminator column if (hasDiscriminator) { var discriminatorElement = classMapping.OwnerDocument.CreateElement("discriminator"); classMapping.AppendChild(discriminatorElement); // Database column or SQL formula allowed to distinguish entity types MetadataTools.AddColumnsOrFormulas(discriminatorElement, pc.Discriminator.ColumnIterator); discriminatorElement.SetAttribute("type", pc.Discriminator.Type.Name); } // Adding the "revision type" property AddRevisionType(classMapping); return new Triple<XmlElement, IExtendedPropertyMapper, string>(classMapping, propertyMapper, 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); } } }
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); }
//@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); }
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); }
public EntitiesConfigurations Configure(NHibernate.Cfg.Configuration cfg, GlobalConfiguration globalCfg, AuditEntitiesConfiguration verEntCfg, XmlDocument revisionInfoXmlMapping, XmlElement revisionInfoRelationMapping) { // Creating a name register to capture all audit entity names created. AuditEntityNameRegister auditEntityNameRegister = new AuditEntityNameRegister(); //XmlWriter writer = new XmlTextWriter(.. // Sorting the persistent class topologically - superclass always before subclass IEnumerator<PersistentClass> classes = GraphTopologicalSort.Sort<PersistentClass, String>(new PersistentClassGraphDefiner(cfg)).GetEnumerator(); ClassesAuditingData classesAuditingData = new ClassesAuditingData(); IDictionary<PersistentClass, EntityXmlMappingData> xmlMappings = new Dictionary<PersistentClass, EntityXmlMappingData>(); // Reading metadata from annotations while (classes.MoveNext()) { PersistentClass pc = classes.Current; // Collecting information from annotations on the persistent class pc AnnotationsMetadataReader annotationsMetadataReader = new AnnotationsMetadataReader(globalCfg, pc); ClassAuditingData auditData = annotationsMetadataReader.AuditData; classesAuditingData.AddClassAuditingData(pc, auditData); } // Now that all information is read we can update the calculated fields. classesAuditingData.UpdateCalculatedFields(); AuditMetadataGenerator auditMetaGen = new AuditMetadataGenerator(cfg, globalCfg, verEntCfg, revisionInfoRelationMapping, auditEntityNameRegister, classesAuditingData); // First pass foreach (KeyValuePair<PersistentClass, ClassAuditingData> pcDatasEntry in classesAuditingData.GetAllClassAuditedData()) { PersistentClass pc = pcDatasEntry.Key; ClassAuditingData auditData = pcDatasEntry.Value; EntityXmlMappingData xmlMappingData = new EntityXmlMappingData(); if (auditData.IsAudited()) { if (!String.IsNullOrEmpty(auditData.AuditTable.value)){ // .getAuditTable().value())) { verEntCfg.AddCustomAuditTableName(pc.EntityName, auditData.AuditTable.value); } auditMetaGen.GenerateFirstPass(pc, auditData, xmlMappingData, true); } else { auditMetaGen.GenerateFirstPass(pc, auditData, xmlMappingData, false); } xmlMappings.Add(pc, xmlMappingData); } // Second pass foreach (KeyValuePair<PersistentClass, ClassAuditingData> pcDatasEntry in classesAuditingData.GetAllClassAuditedData()) { EntityXmlMappingData xmlMappingData = xmlMappings[pcDatasEntry.Key]; if (pcDatasEntry.Value.IsAudited()) { auditMetaGen.GenerateSecondPass(pcDatasEntry.Key, pcDatasEntry.Value, xmlMappingData); try { //cfg.AddDocument(writer.write(xmlMappingData.MainXmlMapping)); cfg.AddDocument(xmlMappingData.MainXmlMapping); //WriteDocument(xmlMappingData.getMainXmlMapping()); foreach (XmlDocument additionalMapping in xmlMappingData.AdditionalXmlMappings) { //cfg.AddDocument(writer.write(additionalMapping)); cfg.AddDocument(additionalMapping); //WriteDocument(additionalMapping); } } catch (MappingException e) { //catch (DocumentException e) { //?Catalina DocumentException NOT IMPLEMENTED throw new MappingException(e); } } } // Only if there are any versioned classes if (classesAuditingData.GetAllClassAuditedData().Count > 0) { try { if (revisionInfoXmlMapping != null) { //WriteDocument(revisionInfoXmlMapping); //cfg.addDocument(writer.write(revisionInfoXmlMapping)); cfg.AddDocument((revisionInfoXmlMapping)); } } catch (MappingException e) { //catch (DocumentException e) { //?Catalina throw new MappingException(e); } } return new EntitiesConfigurations(auditMetaGen.EntitiesConfigurations, auditMetaGen.NotAuditedEntitiesConfigurations); }
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); }
public void AddValue(XmlElement parent, IValue value, ICompositeMapperBuilder currentMapper, string entityName, EntityXmlMappingData xmlMappingData, PropertyAuditingData propertyAuditingData, bool insertable, bool firstPass) { var type = value.Type; // only first pass if (firstPass) { if (BasicMetadataGenerator.AddBasic(parent, propertyAuditingData, value, currentMapper, insertable, false)) { // The property was mapped by the basic generator. return; } } if (type is ComponentType) { // both passes componentMetadataGenerator.AddComponent(parent, propertyAuditingData, value, currentMapper, entityName, xmlMappingData, firstPass, insertable); } else if (type is ManyToOneType) { // only second pass if (!firstPass) { toOneRelationMetadataGenerator.AddToOne(parent, propertyAuditingData, value, currentMapper, entityName, insertable, null); } } else if (type is OneToOneType) { // only second pass if (!firstPass) { var oneToOneType = (OneToOneType)type; var oneToOneValue = (OneToOne)value; if (oneToOneType.IsReferenceToPrimaryKey && oneToOneValue.IsConstrained) { //if pk onetoone is used, "value" has no corresponding columns var pkColumns = new List<string>(); foreach (Column column in Cfg.GetClassMapping(oneToOneValue.ReferencedEntityName).Identifier.ColumnIterator) { pkColumns.Add("Ref" + column.Name); } toOneRelationMetadataGenerator.AddToOne(parent, propertyAuditingData, value, currentMapper, entityName, insertable, pkColumns); } else { toOneRelationMetadataGenerator.AddOneToOneNotOwning(propertyAuditingData, oneToOneValue, currentMapper, entityName); } } } else if (type is CollectionType) { // only second pass if (!firstPass) { var collectionMetadataGenerator = new CollectionMetadataGenerator(this, (Mapping.Collection)value, currentMapper, entityName, xmlMappingData, propertyAuditingData); collectionMetadataGenerator.AddCollection(); } } else { if (firstPass) { // If we got here in the first pass, it means the basic mapper didn't map it, and none of the // above branches either. ThrowUnsupportedTypeException(type, entityName, propertyAuditingData.Name); } } }