Validation through persistence: synchronized

This post is about one possible answer to the question mememem ask me in this post (ah… nice nick).

The task is create a validator to validate the uniqueness, of an entity instance, using some properties’ values instead its POID (Persistence Object ID).

The implementation

public class BlogPost
{
   public string Title { get; set; }
   public DateTime Date { get; set; }
   public string Content { get; set; }
}

we want check the uniqueness using the value of Title and the value of Date obviously without use both properties as composite-PK; so, we can’t have two posts with the same title in the same day.

Since NHibernate2.1.0GA we can instruct NH about our concept of uniqueness in a very explicit, self documented, and nice way:

<class name="BlogPost">
   <id type="guid">
       <generator class="guid.comb"/>
   </id>
   <natural-id mutable="true">
       <property name="Title"/>
       <property name="Date" type="Date"/>
   </natural-id>
   <property name="Content" type="string(10000)"/>
</class>

clear no ? we are defining explicitly which is our natural-id, that mean we want a unique key with Title and Date. The result DDL is:

create table BlogPost (
id UNIQUEIDENTIFIER not null,
Title NVARCHAR(255) null,
Date DATETIME null,
Content NVARCHAR(MAX) null,
primary key (id),
unique (Title, Date)
)

We having NHibernate and the DataBase synchronized with the same rule and now we want create a validator to use with NHibernate.Validator to synchronize even our business logic (and prevent ADO.NET exceptions).

First the attribute to “mark” my classes:

[AttributeUsage(AttributeTargets.Class)]
[ValidatorClass(typeof(NaturalIdUniquenessValidator))]
public class NaturalIdUniquenessAttribute : Attribute, IRuleArgs
{
   public string Message { get; set; }
}

then the validator implementation with NHibernate integration. In this implementation I’m using the Stateless-Session but you can use, a new statefull session or factory.GetCurrentSessionContext or whatever you have as session-provider. The matter is not from where you get the session but how create the query in a generic way that can be used for any entity without need any kind of “invasion” in my existing implementation.

Note: this is a classic usage of the stateless-session but take care with the BestGuessEntityName method.

public class NaturalIdUniquenessValidator : IValidator
{
   private readonly ISessionFactory factory;

   public NaturalIdUniquenessValidator(ISessionFactory sessionFactory)
   {
       factory = sessionFactory;
   }

   public bool IsValid(object value, IConstraintValidatorContext constraintContext)
   {
       if (ReferenceEquals(value, null))
       {
           return true;
       }
       using (var session = factory.OpenStatelessSession())
       {
           var entityName = ((ISessionImplementor) session).BestGuessEntityName(value);
           var meta = factory.GetClassMetadata(entityName);
           if (ReferenceEquals(meta, null) || !meta.HasNaturalIdentifier)
           {
               return true;
           }
           var propsValues = meta.GetPropertyValues(value, EntityMode.Poco);
           var propsNames = meta.PropertyNames;
           var criteria = session.CreateCriteria(entityName);
           foreach (var propIdx in meta.NaturalIdentifierProperties)
           {
               criteria.Add(Restrictions.Eq(propsNames[propIdx], propsValues[propIdx]));
           }
           return criteria.UniqueResult() == null;
       }
   }
}

In the implementation I’m using some NHibernate advanced information to create a ICriteria with the properties defined as natural-id; the implementation is working with any entity of your domain. The strange thing, there, is another: the validator does not have a default constructor… where is the trick ?

Well… first the implementation with an home-made-2-minutes-IoC:

public class ConstraintValidatorFactory : DefaultConstraintValidatorFactory
{
   public override IValidator GetInstance(Type type)
   {
       var persistenceCtor = type.GetConstructor(new[] {typeof (ISessionFactory)});
       if(persistenceCtor != null)
       {
           return (IValidator)
               persistenceCtor.Invoke(new object[] { NHibernateStaticContainer.Factory });
       }
       return base.GetInstance(type);
   }
}

The IConstraintValidatorFactory is the factory for classes implementing IValidator and you can inject the concrete implementation through NHV configuration.

var nhvConfig = new FluentConfiguration();
nhvConfig.SetConstraintValidatorFactory<ConstraintValidatorFactory>();

Another, more generic, implementation of the IConstraintValidatorFactory could be:

public class ServiceLocatorValidatorFactory : DefaultConstraintValidatorFactory
{
   #region Implementation of IConstraintValidatorFactory

   public override IValidator GetInstance(Type type)
   {
       ConstructorInfo defaultConstructorInfo = type.GetConstructor(new Type[0]);
       if (defaultConstructorInfo == null)
       {
           return (IValidator) ServiceLocator.Current.GetInstance(type);
       }
       return base.GetInstance(type);
   }

   #endregion
}

here you can use your preferred IoC framework as the factory/container of validators instances (take care with statefull validators).

The usage

Well… it is completely transparent, you can use this entity-validator as you are using any other.

the definition

public class BlogPostValidation: ValidationDef<BlogPost>
{
   public BlogPostValidation()
   {
       ValidateInstance.Using(new NaturalIdUniquenessAttribute());
   }
}

a simple test

var blogPost = new BlogPost
{
   Title = "something new",
   Date = DateTime.Today,
   Content = "there is something new to say."
};

validatorEngine.IsValid(blogPost).Should().Be.True();

using (var s = sessionFactory.OpenSession())
using (var tx = s.BeginTransaction())
{
   s.Save(blogPost);
   tx.Commit();
}

var otherBlogPost = new BlogPost
{
   Title = "something new",
   Date = DateTime.Today,
   Content = "bha?!?."
};

validatorEngine.IsValid(otherBlogPost).Should().Be.False();

otherBlogPost.Title = "very new";

validatorEngine.IsValid(otherBlogPost).Should().Be.True();

Conclusion

The implementation of the entity BlogPost was NEVER TOUCHED (I did it my way)… now :

• go to your system
• copy&paste the implementation of NaturalIdUniquenessAttribute and NaturalIdUniquenessValidator
• change the implementation of the ConstraintValidatorFactory according to your system
• change the mapping defining your natural-id in the entities where needed
• Enjoy NHibernate.Validator, its flexibility, its injectability and its easy integration with NHibernate.

Tomorrow, perhaps, the no synchronized implementation.