예제 #1
0
        protected void ExcludeRelationData(System.Type entityType, string property)
        {
            var member = getMemberOrThrow(entityType, property);
            var attr   = new AuditedAttribute {
                TargetAuditMode = RelationTargetAuditMode.NotAudited
            };

            AttributeCollection.Add(new MemberInfoAndAttribute(entityType, member, attr));
        }
예제 #2
0
        public IFluentAudit <T> ExcludeRelationData(Expression <Func <T, object> > property)
        {
            var methodInfo = property.MethodInfo();
            var attr       = new AuditedAttribute {
                TargetAuditMode = RelationTargetAuditMode.NotAudited
            };

            AttributeCollection.Add(new MemberInfoAndAttribute(typeof(T), methodInfo, attr));
            return(this);
        }
        private ModificationStore getDefaultAudited(System.Type typ)
        {
            AuditedAttribute defaultAudited = (AuditedAttribute)Attribute.GetCustomAttribute(typ, typeof(AuditedAttribute));

            //AuditedAttribute defaultAudited = typ.GetCustomAttributes(typeof(AuditedAttribute),);

            if (defaultAudited != null)
            {
                return(defaultAudited.ModStore);
            }
            else
            {
                return(ModificationStore._NULL);
            }
        }
        /// <summary>
        /// Checks if a property is audited and if yes, fills all of its data.
        /// </summary>
        /// <param name="property">Property to check.</param>
        /// <param name="mappedPropertyName">NH Property name</param>
        /// <param name="propertyData">Property data, on which to set this property's modification store.</param>
        /// <param name="accessType">Access type for the property.</param>
        /// <param name="allClassAudited">Is class fully audited</param>
        /// <returns>False if this property is not audited.</returns>
        private bool fillPropertyData(MemberInfo property,
                                      string mappedPropertyName,
                                      PropertyAuditingData propertyData,
                                      string accessType,
                                      AuditedAttribute allClassAudited)
        {
            // check if a property is declared as not audited to exclude it
            // useful if a class is audited but some properties should be excluded
            if ((_metaDataStore.MemberMeta <NotAuditedAttribute>(property) != null && !_overriddenAuditedProperties.Contains(mappedPropertyName)) ||
                _overriddenNotAuditedProperties.Contains(mappedPropertyName))
            {
                return(false);
            }
            // if the optimistic locking field has to be unversioned and the current property
            // is the optimistic locking field, don't audit it
            if (_globalCfg.DoNotAuditOptimisticLockingField &&
                _persistentPropertiesSource.VersionedProperty != null &&
                _persistentPropertiesSource.VersionedProperty.Name.Equals(mappedPropertyName))
            {
                return(false);
            }

            if (!CheckAudited(property, mappedPropertyName, propertyData, allClassAudited))
            {
                return(false);
            }

            var propertyName = _propertyNamePrefix + mappedPropertyName;

            propertyData.Name             = propertyName;
            propertyData.ModifiedFlagName = MetadataTools.ModifiedFlagPropertyName(propertyName, _globalCfg.ModifiedFlagSuffix);
            propertyData.BeanName         = mappedPropertyName;
            propertyData.AccessType       = accessType;

            addPropertyJoinTables(property, propertyData);
            addPropertyAuditingOverrides(property, propertyData);
            if (!processPropertyAuditingOverrides(property, propertyData))
            {
                return(false);                // not audited due to AuditOverride annotation
            }
            setPropertyAuditMappedBy(property, propertyData);
            setCustomMapper(property, propertyData);

            return(true);
        }
        protected virtual bool CheckAudited(MemberInfo property, string mappedPropertyName, PropertyAuditingData propertyData, AuditedAttribute allClassAudited)
        {
            // Checking if this property is explicitly audited or if all properties are.
            var aud = _metaDataStore.MemberMeta <AuditedAttribute>(property) ?? allClassAudited;

            if (aud == null && _overriddenAuditedProperties.Contains(mappedPropertyName) && !_overriddenNotAuditedProperties.Contains(mappedPropertyName))
            {
                // Assigning AuditedAttribute defaults. If anyone needs to customize those values in the future,
                // appropriate fields shall be added to AuditOverrideAttribute annotation.
                aud = new AuditedAttribute();
            }
            if (aud != null)
            {
                propertyData.RelationTargetAuditMode = aud.TargetAuditMode;
                propertyData.UsingModifiedFlag       = checkUsingModifiedFlag(aud);
                return(true);
            }
            return(false);
        }
        private void addFromProperties(AuditedAttribute allClassAudited, System.Type currentClass)
        {
            foreach (var declaredPersistentProperty in _persistentPropertiesSource.DeclaredPersistentProperties)
            {
                // If the property was already defined by the subclass, is ignored by superclasses
                if (_auditedPropertiesHolder.Contains(declaredPersistentProperty.Property.Name))
                {
                    continue;
                }

                //only get the property on specific class if not a component
                if ((declaredPersistentProperty.Member.DeclaringType != currentClass && !_persistentPropertiesSource.IsComponent) &&
                    !declaredPersistentProperty.Member.Equals(DeclaredPersistentProperty.NotAvailableMemberInfo) &&
                    !_overriddenAuditedProperties.Contains(declaredPersistentProperty.Property.Name))
                {
                    continue;
                }

                var propertyValue = declaredPersistentProperty.Property.Value;

                var componentValue = propertyValue as Component;
                if (componentValue != null)
                {
                    if (declaredPersistentProperty.Member.Equals(DeclaredPersistentProperty.NotAvailableMemberInfo))
                    {
                        addFromPropertiesGroup(declaredPersistentProperty, componentValue, allClassAudited);
                    }
                    else
                    {
                        addFromComponentProperty(declaredPersistentProperty, componentValue, allClassAudited);
                    }
                }
                else
                {
                    addFromNotComponentProperty(declaredPersistentProperty, allClassAudited);
                }
            }
        }
예제 #7
0
        protected override bool CheckAudited(MemberInfo property, string mappedPropertyName, PropertyAuditingData propertyData, AuditedAttribute allClassAudited)
        {
            // Checking if this property is explicitly audited or if all properties are.
            var aud = _metaDataStore.MemberMeta <AuditedAttribute>(property);

            if (aud != null)
            {
                propertyData.RelationTargetAuditMode = aud.TargetAuditMode;
            }
            return(true);
        }
        /**
         * Checks if a property is audited and if yes, fills all of its data.
         * @param property Property to check.
         * @param propertyData Property data, on which to set this property's modification store.
         * @param accessType Access type for the property.
         * @return False if this property is not audited.
         */
        private bool FillPropertyData(PropertyInfo property, PropertyAuditingData propertyData,
                                      String accessType)
        {
            // check if a property is declared as not audited to exclude it
            // useful if a class is audited but some properties should be excluded
            NotAuditedAttribute unVer = (NotAuditedAttribute)Attribute.GetCustomAttribute(property, typeof(NotAuditedAttribute));

            if (unVer != null)
            {
                return(false);
            }
            else
            {
                // if the optimistic locking field has to be unversioned and the current property
                // is the optimistic locking field, don't audit it
                if (_globalCfg.isDoNotAuditOptimisticLockingField())
                {
                    //Version jpaVer = property.getAnnotation(typeof(Version));
                    VersionAttribute jpaVer = (VersionAttribute)Attribute.GetCustomAttribute(property, typeof(VersionAttribute));
                    if (jpaVer != null)
                    {
                        return(false);
                    }
                }
            }

            // Checking if this property is explicitly audited or if all properties are.
            //AuditedAttribute aud = property.getAnnotation(typeof(AuditedAttribute));
            AuditedAttribute aud = (AuditedAttribute)Attribute.GetCustomAttribute(property, typeof(AuditedAttribute));

            if (aud != null)
            {
                propertyData.Store = aud.ModStore;
                propertyData.setRelationTargetAuditMode(aud.TargetAuditMode);
            }
            else
            {
                if (_defaultStore != ModificationStore._NULL)
                {
                    propertyData.Store = _defaultStore;
                }
                else
                {
                    return(false);
                }
            }

            propertyData.Name       = _propertyNamePrefix + property.Name;
            propertyData.BeanName   = property.Name;
            propertyData.AccessType = accessType;

            AddPropertyJoinTables(property, propertyData);
            AddPropertyAuditingOverrides(property, propertyData);
            if (!ProcessPropertyAuditingOverrides(property, propertyData))
            {
                return(false);            // not audited due to AuditOverride annotation
            }
            AddPropertyMapKey(property, propertyData);
            SetPropertyAuditMappedBy(property, propertyData);

            return(true);
        }
 private bool checkUsingModifiedFlag(AuditedAttribute aud)
 {
     return(_globalCfg.IsGlobalWithModifiedFlag || aud.WithModifiedFlag);
 }
        private void addFromNotComponentProperty(DeclaredPersistentProperty property, AuditedAttribute allClassAudited)
        {
            var propertyData = new PropertyAuditingData();
            var isAudited    = fillPropertyData(property.Member,
                                                property.Property.Name,
                                                propertyData,
                                                property.Property.PropertyAccessorName,
                                                allClassAudited);

            if (isAudited)
            {
                // Now we know that the property is audited
                _auditedPropertiesHolder.AddPropertyAuditingData(property.Property.Name, propertyData);
            }
        }
        private void addFromComponentProperty(DeclaredPersistentProperty property, Component componentValue, AuditedAttribute allClassAudited)
        {
            var componentData = new ComponentAuditingData();
            var isAudited     = fillPropertyData(property.Member,
                                                 property.Property.Name,
                                                 componentData,
                                                 property.Property.PropertyAccessorName,
                                                 allClassAudited);

            var componentPropertiesSource = new ComponentPropertiesSource(componentValue);
            var audPropReader             = new ComponentAuditedPropertiesReader(_metaDataStore,
                                                                                 componentPropertiesSource, componentData,
                                                                                 _globalCfg,
                                                                                 _propertyNamePrefix +
                                                                                 MappingTools.CreateComponentPrefix(property.Property.Name));

            audPropReader.Read();

            if (isAudited)
            {
                // Now we know that the property is audited
                _auditedPropertiesHolder.AddPropertyAuditingData(property.Property.Name, componentData);
            }
        }