Example #1
0
        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));
        }
Example #2
0
        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);
            }
        }
Example #5
0
        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);
        }