this should be fun :)

thank you for your help so far.

the test:

    [TestFixture]
    public class ValidationMapping_Fixture
    {
        protected readonly string _connstr = @"Data
Source=(local);Initial Catalog=TestDb;Integrated Security=SSPI";

        [Test]
        public void
Domain_validation_rules_should_map_to_db_schema_using_attributes()
        {
            var configuration = new
NHibernate.Validator.Cfg.Loquacious.FluentConfiguration();
 
configuration.IntegrateWithNHibernate.ApplyingDDLConstraints();
            var validatorEngine = new
NHibernate.Validator.Engine.ValidatorEngine();
            validatorEngine.Configure(configuration);

            DoMapping(validatorEngine);
        }

        [Test]
        public void
Domain_validation_rules_should_map_to_db_schema_using_validation_defs()
        {
            var configuration = new
NHibernate.Validator.Cfg.Loquacious.FluentConfiguration();
 
configuration.Register(typeof(Customer).Assembly.ValidationDefinitions()).SetDefaultValidatorMode(ValidatorMode.UseExternal).IntegrateWithNHibernate.ApplyingDDLConstraints();
            var validatorEngine = new
NHibernate.Validator.Engine.ValidatorEngine();
            validatorEngine.Configure(configuration);

            DoMapping(validatorEngine);
        }

        private void DoMapping(ValidatorEngine ve)
        {
            var orm = new ConfOrm.ObjectRelationalMapper();

            //customizations are the 'DearDbaDomainMapper' .. can't
live without it

            orm.Patterns.ManyToOneRelations.Remove(
                orm.Patterns.ManyToOneRelations.Single(p =>
p.GetType() ==
typeof(ConfOrm.Patterns.OneToOneUnidirectionalToManyToOnePattern)));

            orm.Patterns.PoidStrategies.Add(new
ConfOrm.Patterns.NativePoidPattern());
            ConfOrm.NH.IPatternsAppliersHolder patternsAppliers =
                (new ConfOrm.Shop.Packs.SafePropertyAccessorPack())
                    .Merge(new
ConfOrm.Shop.Packs.OneToOneRelationPack(orm))
                    .Merge(new
ConfOrm.Shop.Packs.BidirectionalManyToManyRelationPack(orm))
                    .Merge(new
ConfOrm.Shop.Packs.BidirectionalOneToManyRelationPack(orm))
                    .Merge(new
ConfOrm.Shop.Packs.DiscriminatorValueAsClassNamePack(orm))
                    .Merge(new
ConfOrm.Shop.DearDbaNaming.DearDbaTablesAndColumnsNamingPack(orm, new
ConfOrm.Shop.Inflectors.EnglishInflector()))
                    .Merge(new ConfOrm.Shop.Packs.TablePerClassPack())
                    .Merge(new
ConfOrm.Shop.Appliers.DatePropertyByNameApplier())
                    .Merge(new
ConfOrm.Shop.Appliers.MsSQL2008DateTimeApplier());

            patternsAppliers.Merge(new
ConfOrm.Shop.Appliers.DatePropertyByNameApplier()).Merge(new
ConfOrm.Shop.Appliers.MsSQL2008DateTimeApplier());

            var mapper = new Mapper(orm, patternsAppliers);

            var entities = new[] { typeof(Customer), typeof(Product),
typeof(Purchase), typeof(PurchaseItem) };

            orm.TablePerClass(entities);

            orm.Cascade<PurchaseItem, Purchase>(ConfOrm.Cascade.All);
            orm.Cascade<PurchaseItem, Product>(ConfOrm.Cascade.All);

            var isSqlSrvCe = false;
            var config = new NHibernate.Cfg.Configuration();

            config.DataBaseIntegration(db =>
            {
 
db.ConnectionProvider<NHibernate.Connection.DriverConnectionProvider>();
                db.Dialect<NHibernate.Dialect.MsSql2008Dialect>();
                db.Driver<NHibernate.Driver.SqlClientDriver>();
                db.ConnectionString = _connstr;

                if (!isSqlSrvCe)
                    db.KeywordsAutoImport =
NHibernate.Cfg.Hbm2DDLKeyWords.AutoQuote;

                db.IsolationLevel =
System.Data.IsolationLevel.ReadCommitted;
                db.Timeout = 10;
                db.HqlToSqlSubstitutions = "true 1, false 0, yes 'Y',
no 'N'";
            });

            config.Properties["proxyfactory.factory_class"] =
"NHibernate.ByteCode.Castle.ProxyFactoryFactory,
NHibernate.ByteCode.Castle";

 
NHibernate.Validator.Cfg.ValidatorInitializer.Initialize(config, ve);

            var mapping = mapper.CompileMappingFor(entities);
            System.Diagnostics.Debug.Write(Serialize(mapping));

            config.AddDeserializedMapping(mapping, "AgileDomain");

            if (!isSqlSrvCe)
 
NHibernate.Tool.hbm2ddl.SchemaMetadataUpdater.QuoteTableAndColumns(config);

            new
NHibernate.Tool.hbm2ddl.SchemaExport(config).Create(true, true);

            var sessionFactory = config.BuildSessionFactory();
        }

        private string Serialize<T>(T item)
        {
            string result;
            var setting = new System.Xml.XmlWriterSettings { Indent =
true };
            var serializer = new
System.Xml.Serialization.XmlSerializer(typeof(T));
            using (var memStream = new System.IO.MemoryStream(2048))
            {
                using (System.Xml.XmlWriter xmlWriter =
System.Xml.XmlWriter.Create(memStream, setting))
                {
                    serializer.Serialize(xmlWriter, item);
                }
                memStream.Position = 0;
                using (var sr = new System.IO.StreamReader(memStream))
                {
                    result = sr.ReadToEnd();
                }
            }
            return result;
        }
    }


the domain:


public class Entity
        {
    public Guid Id { get; protected set: }
    }

    public class Customer : Entity
    {
        public Customer()
        {
            this.Orders = new
ObservableEditableCollection<Purchase>();
        }

        [NotNullNotEmpty(Message = "Name must be set.")]
        public virtual string Name { get; set; }
        [NotNullNotEmpty(Message = "PIN must be set."), Length(Min =
11, Max = 11, Message = "PIN must have eleven digits.")]
        public virtual string PIN { get; set; }
        public virtual IList<Purchase> Orders { get; set; }

        public virtual void AddOrder(Purchase order)
        {
            order.SetCustomer(this);
        }
    }

    public class CustomerValidationDef : ValidationDef<Customer>
    {
        public CustomerValidationDef()
        {
            Define(c =>
c.Name).NotNullableAndNotEmpty().WithMessage("Name must be set.");
            Define(c =>
c.PIN).NotNullableAndNotEmpty().WithMessage("PIN must be set.");
            Define(c => c.PIN).LengthBetween(11, 11).WithMessage("PIN
must have eleven digits.");
        }
    }

    public class Product : Entity
    {
        public Product()
        {
            this.Items = new
ObservableEditableCollection<PurchaseItem>();
        }

        public virtual string Name { get; set; }
        public virtual decimal Price { get; set; }

        public virtual IList<PurchaseItem> Items { get; set; }
    }

    public class Purchase : Entity
    {
        public Purchase()
        {
            this.Items = new
ObservableEditableCollection<PurchaseItem>();
        }

        public virtual int Nr { get; set; }
        public virtual DateTime Date { get; set; }
        public virtual Customer Customer { get; private set; }
        public virtual IList<PurchaseItem> Items { get; set; }

        public virtual void SetCustomer(Customer customer)
        {
            this.Customer = customer;
            customer.Orders.Add(this);
        }

        public virtual void AddItem(PurchaseItem item)
        {
            item.SetPurchase(this);
        }
    }

    public class PurchaseItem : Entity
    {
        public virtual Purchase Order { get; set; }
        public virtual Product Product { get; set; }
        public virtual decimal Price { get; set; }
        public virtual int Quantity { get; set; }

        public virtual void SetPurchase(Purchase order)
        {
            order.Items.Add(this);
            this.Order = order;
        }

        public virtual void SetProduct(Product product)
        {
            product.Items.Add(this);
            this.Product = product;
        }
    }

-- 
You received this message because you are subscribed to the Google Groups 
"nhusers" group.
To post to this group, send email to [email protected].
To unsubscribe from this group, send email to 
[email protected].
For more options, visit this group at 
http://groups.google.com/group/nhusers?hl=en.

Reply via email to