Ejemplo n.º 1
0
		protected override HbmMapping GetMappings()
		{
			var mapper = new ModelMapper();
			mapper.Class<Product>(cm =>
				{
					cm.Id(x => x.Id, m => m.Generator(Generators.GuidComb));
					cm.Property(x => x.Name);
					cm.ManyToOne(x => x.Family);
				});
			mapper.Class<Family>(cm =>
				{
					cm.Id(x => x.Id, m => m.Generator(Generators.GuidComb));
					cm.Property(x => x.Name);
					cm.ManyToOne(x => x.Segment);
					cm.Set(x => x.Products, m => { }, m => m.OneToMany());
					cm.Set(x => x.Cultivations, m => { }, m => m.OneToMany());
				});
			mapper.Class<Cultivation>(cm =>
				{
					cm.Id(x => x.Id, m => m.Generator(Generators.GuidComb));
					cm.Property(x => x.Name);
					cm.ManyToOne(x => x.Family);
				});
			mapper.Class<Segment>(cm =>
				{
					cm.Id(x => x.Id, m => m.Generator(Generators.GuidComb));
					cm.Property(x => x.Name);
					cm.Set(x => x.Families, m => { }, m => m.OneToMany());
				});

			return mapper.CompileMappingForAllExplicitlyAddedEntities();
		}
Ejemplo n.º 2
0
		public void SpecifiedForeignKeyNameInByCodeMappingIsUsedInGeneratedSchema()
		{
			var mapper = new ModelMapper();

			// Generates a schema in which a Person record cannot be created unless an Employee
			// with the same primary key value already exists. The Constrained property of the
			// one-to-one mapping is required to create the foreign key constraint on the Person
			// table, and the optional ForeignKey property is used to name it; otherwise a
			// generated name is used

			mapper.Class<Person>(rc =>
			{
				rc.Id(x => x.Id, map => map.Generator(Generators.Foreign<Employee>(p => p.Person)));
				rc.Property(x => x.Name);
				rc.OneToOne(x => x.Employee, map =>
				{
					map.Constrained(true);
					map.ForeignKey(ForeignKeyName);
				});
			});

			mapper.Class<Employee>(rc =>
			{
				rc.Id(x => x.Id);
				rc.OneToOne(x => x.Person, map => { });
			});

			var script = new StringBuilder();
			var cfg = new Configuration();
			cfg.AddMapping(mapper.CompileMappingForAllExplicitlyAddedEntities());

			new SchemaExport(cfg).Execute(s => script.AppendLine(s), false, false);
			script.ToString().Should().Contain(string.Format("constraint {0}", ForeignKeyName));
		}
		protected override HbmMapping GetMappings()
		{
			var mapper = new ModelMapper();

			mapper.Class<Employee>(mc =>
			{
				mc.Id(x => x.Id, map =>
				{
					map.Generator(Generators.Identity);
					map.Column("Id");
				});
				mc.OneToOne<EmployeeInfo>(x => x.Info, map =>
				{
					map.Cascade(Mapping.ByCode.Cascade.All | Mapping.ByCode.Cascade.DeleteOrphans);
					map.Constrained(false);
				});
			});

			mapper.Class<EmployeeInfo>(mc =>
			{
				mc.Id(x => x.Id, map =>
				{
					map.Generator(Generators.Foreign<EmployeeInfo>(x => x.EmployeeDetails));
					map.Column("Id");
				});
				mc.OneToOne<Employee>(x => x.EmployeeDetails, map =>
				{
					map.Constrained(true);
				});
			});

			return mapper.CompileMappingForAllExplicitlyAddedEntities();
		}
Ejemplo n.º 4
0
		private HbmMapping GetMappings()
		{
			var mapper = new ModelMapper();

			mapper.BeforeMapClass += (mi, t, map) => map.Id(x => x.Generator(Generators.GuidComb));

			mapper.Class<Parent>(rc =>
			{
				rc.Id(p => p.Id);
				rc.Property(p => p.ParentCode, m => m.Unique(true));
				rc.Property(p => p.Name);
				rc.Bag(p => p.Children, m =>
				{
					m.Key(km => { km.Column(cm => cm.Name("ParentParentCode")); km.PropertyRef(pg => pg.ParentCode); });
					m.Inverse(true);
					m.Cascade(Mapping.ByCode.Cascade.Persist);
				}, rel => rel.OneToMany());
			});

			mapper.Class<Child>(rc =>
			{
				rc.Id(p => p.Id);
				rc.Property(p => p.Name);
				rc.ManyToOne<Parent>(p => p.Parent, m => { m.Column("ParentParentCode"); m.PropertyRef("ParentCode"); });
			});

			return mapper.CompileMappingForAllExplicitlyAddedEntities();
		}
		protected override HbmMapping GetMappings()
		{
			var mapper = new ModelMapper();
			mapper.Class<Author>(rc =>
			{
				rc.Id(x => x.Id, m => m.Generator(Generators.Identity));
				rc.Property(x => x.Name);
				rc.ManyToOne(x => x.Publisher, m => m.Cascade(Mapping.ByCode.Cascade.All));
				rc.Set(x => x.Books, m =>
				{
					m.Cascade(Mapping.ByCode.Cascade.All);
					m.Lazy(CollectionLazy.Lazy);
				}, r => r.OneToMany());
			});
			mapper.Class<Book>(rc =>
			{
				rc.Id(x => x.Id, m => m.Generator(Generators.Identity));
				rc.Property(x => x.Title);
				rc.ManyToOne(x => x.Author);
			});
			mapper.Class<Publisher>(rc =>
			{
				rc.Id(x => x.Id, m => m.Generator(Generators.Identity));
				rc.Property(x => x.Name);
				rc.Set(x => x.Authors, m => m.Cascade(Mapping.ByCode.Cascade.All), r => r.OneToMany());
			});

			return mapper.CompileMappingForAllExplicitlyAddedEntities();
		}
Ejemplo n.º 6
0
		protected override HbmMapping GetMappings()
		{
			var mapper = new ModelMapper();
			mapper.Class<Order>(rc =>
				{
					rc.Table("Orders");
					rc.Id(x => x.Id, m => m.Generator(Generators.GuidComb));
					rc.Property(x => x.Name);
					rc.Set(x => x.OrderLines, m =>
						{
							m.Inverse(true);
							m.Key(k =>
								{
									k.Column("OrderId");
									k.NotNullable(true);
								});
							m.Cascade(Mapping.ByCode.Cascade.All.Include(Mapping.ByCode.Cascade.DeleteOrphans));
							m.Access(Accessor.NoSetter);
						}, m => m.OneToMany());
				});
			mapper.Class<OrderLine>(rc =>
				{
					rc.Table("OrderLines");
					rc.Id(x => x.Id, m => m.Generator(Generators.GuidComb));
					rc.Property(x => x.Name);
					rc.ManyToOne(x => x.Order, m => m.Column("OrderId"));
				});

			return mapper.CompileMappingForAllExplicitlyAddedEntities();
		}
Ejemplo n.º 7
0
		protected override HbmMapping GetMappings()
		{
			var mapper = new ModelMapper();
			mapper.Class<Parent>(rc =>
			{
				rc.Id(x => x.Id, m => m.Generator(Generators.GuidComb));
				rc.Property(x => x.Name);
				rc.List(x => x.Children,
					m =>
					{
						m.Lazy(CollectionLazy.Extra);
						m.Cascade(Mapping.ByCode.Cascade.All | Mapping.ByCode.Cascade.DeleteOrphans);
						m.Inverse(true);
					},
					relation => relation.OneToMany());
			});
			mapper.Class<Child>(rc =>
			{
				rc.Id(x => x.Id, m => m.Generator(Generators.GuidComb));
				rc.Property(x => x.Name);
				rc.ManyToOne(x => x.Parent);
			});

			return mapper.CompileMappingForAllExplicitlyAddedEntities();
		}
Ejemplo n.º 8
0
		private HbmMapping GetMappings()
		{
			var mapper = new ModelMapper();
			mapper.Class<User>(rt =>
			                   {
			                   	rt.Id(x => x.Id, map => map.Generator(Generators.Guid));
			                   	rt.Property(x => x.Name);
													rt.Set(x => x.Roles, map =>
																							 {
																								 map.Table("UsersToRoles");
																								 map.Inverse(true);
																								 map.Key(km => km.Column("UserId"));
																							 }, rel => rel.ManyToMany(mm =>
																							                          {
																																					mm.Column("RoleId");
																							                          	mm.ForeignKey("FK_RoleInUser");
																							                          }));
			                   });
			mapper.Class<Role>(rt =>
			                   {
			                   	rt.Id(x => x.Id, map => map.Generator(Generators.Guid));
			                   	rt.Property(x => x.Name);
			                   	rt.Set(x => x.Users, map =>
			                   	                     {
			                   	                     	map.Table("UsersToRoles");
																								map.Key(km => km.Column("RoleId"));
																							 }, rel => rel.ManyToMany(mm =>
																							                          {
																																					mm.Column("UserId");
																							                          	mm.ForeignKey("FK_UserInRole");
																							                          }));
			                   });
			var mappings = mapper.CompileMappingForAllExplicitlyAddedEntities();
			return mappings;
		}
Ejemplo n.º 9
0
		protected override HbmMapping GetMappings()
		{
			var mapper = new ModelMapper();
			mapper.Class<Document>(rc =>
			{
				rc.Id(x => x.Id, idMapper => idMapper.Generator(Generators.Identity));
				rc.ManyToOne(x => x.Blob, m =>
					{
						m.Cascade(Mapping.ByCode.Cascade.All);
					});
				rc.Property(x => x.Name);
			});
			
			mapper.Class<Blob>(map =>
				{
					map.Id(x => x.Id, idMapper => idMapper.Generator(Generators.Identity));
					map.Property(x => x.Bytes, y =>
						{
							y.Column(x =>
							{
								x.SqlType("varbinary(max)");
								x.Length(int.MaxValue);
							});
							y.Lazy(true);
						});
				});

			return mapper.CompileMappingForAllExplicitlyAddedEntities();
		}
Ejemplo n.º 10
0
        private static void Customize(ModelMapper mapper)
        {
            mapper.Class<EntityBase>(map =>
                               {
                                 map.Id(e => e.Id, id => id.Generator(Generators.HighLow));
                                 map.Version(e => e.Version, d => { });
                               });
              mapper.Class<Product>(map => map.Set(p => p.Customizations,
                                           set => set.Cascade(Cascade.All),
                                           rel => rel.ManyToMany()));

              mapper.Class<Customization>(map => map.Set(p => p.PossibleValues,
                                                 set => set.Cascade(Cascade.All),
                                                 rel => rel.Element()));

              mapper.Class<Order>(map =>
                          {
                            map.Set(p => p.Items, set =>
                                                  {
                                                    set.Cascade(Cascade.All);
                                                    set.Inverse(true);
                                                  });
                            map.ManyToOne(o => o.Payment, o => o.Cascade(Cascade.All));
                          });
        }
Ejemplo n.º 11
0
		protected override HbmMapping GetMappings()
		{
			// The impl/mapping of the bidirectional one-to-many sucks but was provided as is
			var mapper = new ModelMapper();
			mapper.BeforeMapClass += (i, t, cm) => cm.Id(map =>
																									 {
																										 map.Column((t.Name + "Id").ToUpperInvariant());
																										 map.Generator(Generators.HighLow, g => g.Params(new { max_lo = "1000" }));
																									 });
			mapper.Class<Customer>(ca =>
			{
				ca.Lazy(false);
				ca.Id(x => x.Id, m => { });
				ca.NaturalId(x => x.Property(c => c.Name, p => p.NotNullable(true)));
				ca.Property(x => x.Address, p => p.Lazy(true));
				ca.Set(c => c.Orders, c =>
				{
					c.Key(x => x.Column("CUSTOMERID"));
					c.Inverse(true);
					c.Cascade(Mapping.ByCode.Cascade.All);
				}, c => c.OneToMany());
			});
			mapper.Class<Order>(cm =>
			                    {
														cm.Id(x => x.Id, m => { });
														cm.Property(x => x.Date);
														cm.ManyToOne(x => x.Customer, map => map.Column("CUSTOMERID"));
			                    });
			return mapper.CompileMappingForAllExplicitlyAddedEntities();
		}
		protected override HbmMapping GetMappings()
		{
			var mapper = new ModelMapper();

			mapper.Class<Employee>(mc =>
			{
				mc.Id(x => x.Id, map =>
				{
					map.Generator(Generators.Identity);
					map.Column("Id");
				});
				mc.ManyToOne<EmployeeInfo>(x => x.Info, map =>
				{
					// Columns have to be declared first otherwise other properties are reset.
					map.Columns(x => { x.Name("COMP_ID"); },
								x => { x.Name("PERS_ID"); });
					map.Unique(true);
					map.Cascade(Mapping.ByCode.Cascade.All | Mapping.ByCode.Cascade.DeleteOrphans);
					map.NotFound(NotFoundMode.Exception);
				});
			});

			mapper.Class<EmployeeInfo>(mc =>
			{
				mc.ComponentAsId<EmployeeInfo.Identifier>(x => x.Id, map =>
				{
					map.Property(x => x.CompanyId, m => m.Column("COMPS_ID"));
					map.Property(x => x.PersonId, m => m.Column("PERS_ID"));
				});
			});

			return mapper.CompileMappingForAllExplicitlyAddedEntities();
		}
Ejemplo n.º 13
0
		protected override HbmMapping GetMappings()
		{
			var mapper = new ModelMapper();
			mapper.BeforeMapClass += (inspector, type, map) => map.Id(x=> x.Generator(Generators.GuidComb));
			mapper.Class<Foo>(mc =>
			                  {
													mc.Id(x => x.Id);
													mc.Bag(x => x.Bars, map =>
													                    {
													                    	map.Inverse(true);
													                    	map.Cascade(Mapping.ByCode.Cascade.All);
																								map.Key(km =>
																								        {
																								        	km.Column("FooId");
																													km.OnDelete(OnDeleteAction.Cascade);
																								        });
													                    }, rel => rel.OneToMany());
			                  });
			mapper.Class<Bar>(mc =>
			                  {
													mc.Id(x => x.Id);
			                  	mc.ManyToOne(x=> x.Foo, map=> map.Column("FooId"));
			                  });
			var mappings = mapper.CompileMappingForAllExplicitlyAddedEntities();
			return mappings;
		}
		protected override void Mapping(Configuration config)
		{
			var mapper = new ModelMapper();
			mapper.Class<Software>(map =>
			{
				map.Id(s => s.Id, o => o.Generator(Generators.GuidComb));
				map.Property(s => s.Name, o =>
				{
					o.NotNullable(true);
					o.Unique(true);
				});
			});

			mapper.Class<AssignedSoftware>(map =>
			{
				map.Id(s => s.Key, o => o.Generator(Generators.Assigned));
				map.Property(s => s.Name, o =>
				{
					o.NotNullable(true);
					o.Unique(true);
				});
			});

			var mapping = mapper.CompileMappingForAllExplicitlyAddedEntities();
			config.AddMapping(mapping);
			config.DataBaseIntegration(db => db.LogSqlInConsole = true);
		}
		protected override HbmMapping GetMappings()
		{
			var mapper = new ModelMapper();

			mapper.Class<Employee>(mc =>
			{
				mc.Id(x => x.Id, map =>
				{
					map.Generator(Generators.Identity);
					map.Column("Id");
				});
				mc.ManyToOne<EmployeeInfo>(x => x.Info, map =>
				{
					map.Column("Info_id");
					map.Unique(true);
					map.Cascade(Mapping.ByCode.Cascade.All | Mapping.ByCode.Cascade.DeleteOrphans);

				});
			});

			mapper.Class<EmployeeInfo>(cm =>
			{
				cm.Id(x => x.Id, m =>
				{
					m.Generator(Generators.Identity);
					m.Column("Id");
				});
				cm.OneToOne<Employee>(x => x.EmployeeDetails, map =>
				{
					map.PropertyReference(x => x.Info);
				});
			});

			return mapper.CompileMappingForAllExplicitlyAddedEntities();
		}
Ejemplo n.º 16
0
		public override void InitDbModel(ModelMapper mapper)
		{
			mapper.Class<Dashboard>(cfg => cfg.Table("UniUI_Dashboard"));
			mapper.Class<Widget>(cfg => cfg.Table("UniUI_Widget"));
            mapper.Class<Panel>(cfg => cfg.Table("UniUI_Panel"));
            mapper.Class<WidgetParameter>(cfg => cfg.Table("UniUI_WidgetParameter"));
		}
        public void Override(ModelMapper mapper)
        {
            mapper.Class<Movie>(map =>
               map.Bag(x => x.Collectors,
                   bag =>
                   {
                       bag.Key(key =>
                       {
                           key.Column("MovieFk");
                       });
                       bag.Table("Movies_Collectors");
                       bag.Cascade(Cascade.None);
                   },
                   collectionRelation =>
                       collectionRelation.ManyToMany(m => m.Column("CollectorFk"))));

            mapper.Class<Movie>(map =>
               map.Bag(x => x.Directors,
                   bag =>
                   {
                       bag.Key(key =>
                       {
                           key.Column("MovieFk");
                       });
                       bag.Table("Movies_Directors");
                       bag.Cascade(Cascade.None);
                   },
                   collectionRelation =>
                       collectionRelation.ManyToMany(m => m.Column("DirectorFk"))));

            mapper.Class<Movie>(map =>
               map.Bag(x => x.Writers,
                   bag =>
                   {
                       bag.Key(key =>
                       {
                           key.Column("MovieFk");
                       });
                       bag.Table("Movies_Writers");
                       bag.Cascade(Cascade.None);
                   },
                   collectionRelation =>
                       collectionRelation.ManyToMany(m => m.Column("WriterFk"))));

            mapper.Class<Movie>(map =>
               map.Bag(x => x.Genres,
                   bag =>
                   {
                       bag.Key(key =>
                       {
                           key.Column("MovieFk");
                       });
                       bag.Table("Movies_Genres");
                       bag.Cascade(Cascade.None);
                   },
                   collectionRelation =>
                       collectionRelation.ManyToMany(m => m.Column("GenreFk"))));
        }
        public override void AlterConfiguration(NHibernate.Cfg.Configuration cfg)
        {
            ModelMapper mm = new ModelMapper();
            mm.Class<FileSystemItem>(FileSystemItemCustomization);
            mm.Class<FileSystemChunk>(FileSystemChunkCustomization);

            var compiledMapping = mm.CompileMappingForAllExplicitlyAddedEntities();
            cfg.AddDeserializedMapping(compiledMapping, "N2");
        }
Ejemplo n.º 19
0
		private IModelInspector GetConfiguredInspector()
		{
			var autoinspector = new SimpleModelInspector();
			var mapper = new ModelMapper(autoinspector);
			mapper.Class<MyClass>(x => { });
			mapper.Class<Related>(x => { });
			mapper.Class<Bidirectional>(x => { });
			return autoinspector;
		}
Ejemplo n.º 20
0
		public void WhenRelatedDeclaredAsOneToOneThenIsNotManyToOne()
		{
			var autoinspector = new SimpleModelInspector();
			var mapper = new ModelMapper(autoinspector);
			mapper.Class<AEntity>(map => map.OneToOne(a => a.B, x => { }));
			mapper.Class<BEntity>(x=> { });
			var inspector = (IModelInspector)autoinspector;
			Assert.That(inspector.IsManyToOne(typeof(AEntity).GetProperty("B")), Is.False);
		}
		public override void AlterConfiguration(NHibernate.Cfg.Configuration cfg)
		{
            ModelMapper mm = new ModelMapper();
			mm.Class<Bucket>(BucketCustomization);
			mm.Class<Statistic>(StatisticCustomization);
			

			var compiledMapping = mm.CompileMappingForAllExplicitlyAddedEntities();
			cfg.AddDeserializedMapping(compiledMapping, "N2");
		}
Ejemplo n.º 22
0
		public void TestGenerators()
		{
			var mapper = new ModelMapper();

			mapper.Class<A>(e => { e.Id(c => c.Id, c => c.Generator(Generators.Counter)); });
			mapper.Class<B>(e => { e.Id(c => c.Id, c => c.Generator(Generators.UUIDHex)); });
			mapper.Class<C>(e => { e.Id(c => c.Id, c => c.Generator(Generators.UUIDString)); });
			mapper.Class<D>(e => { e.Id(c => c.Id, c => c.Generator(Generators.Increment)); });
			mapper.Class<E>(e => { e.Id(c => c.Id, c => c.Generator(Generators.Select)); });
			mapper.Class<F>(e => { e.Id(c => c.Id, c => c.Generator(Generators.SequenceHiLo)); });
			mapper.Class<G>(e => { e.Id(c => c.Id, c => c.Generator(Generators.SequenceIdentity)); });
			mapper.Class<H>(e => { e.Id(c => c.Id, c => c.Generator(Generators.Table)); });
			mapper.Class<I>(e => { e.Id(c => c.Id, c => c.Generator(Generators.TriggerIdentity)); });

			var hbmMapping = mapper.CompileMappingForAllExplicitlyAddedEntities();
			Assert.AreEqual(hbmMapping.RootClasses.Single(x => x.Name == typeof(A).Name).Id.generator.@class, Generators.Counter.Class);
			Assert.AreEqual(hbmMapping.RootClasses.Single(x => x.Name == typeof(B).Name).Id.generator.@class, Generators.UUIDHex.Class);
			Assert.AreEqual(hbmMapping.RootClasses.Single(x => x.Name == typeof(C).Name).Id.generator.@class, Generators.UUIDString.Class);
			Assert.AreEqual(hbmMapping.RootClasses.Single(x => x.Name == typeof(D).Name).Id.generator.@class, Generators.Increment.Class);
			Assert.AreEqual(hbmMapping.RootClasses.Single(x => x.Name == typeof(E).Name).Id.generator.@class, Generators.Select.Class);
			Assert.AreEqual(hbmMapping.RootClasses.Single(x => x.Name == typeof(F).Name).Id.generator.@class, Generators.SequenceHiLo.Class);
			Assert.AreEqual(hbmMapping.RootClasses.Single(x => x.Name == typeof(G).Name).Id.generator.@class, Generators.SequenceIdentity.Class);
			Assert.AreEqual(hbmMapping.RootClasses.Single(x => x.Name == typeof(H).Name).Id.generator.@class, Generators.Table.Class);
			Assert.AreEqual(hbmMapping.RootClasses.Single(x => x.Name == typeof(I).Name).Id.generator.@class, Generators.TriggerIdentity.Class);
		}
		private HbmMapping GetMappings()
		{
			var mapper = new ModelMapper();
			mapper.Class<MyRelated>(rm=> rm.Id(x=> x.Id));
			mapper.Class<MyEntity>(rm =>
			                       {
			                       	rm.Id(x => x.Id);
															rm.Bag(x => x.Relateds, am => am.Persister<MyCollectionPersister>(), rel=> rel.OneToMany());
			                       });
			var mappings = mapper.CompileMappingForAllExplicitlyAddedEntities();
			return mappings;
		}
Ejemplo n.º 24
0
		public void ExplicitColumnNameIsAlwaysMapped(string columnName)
		{
			var mapper = new ModelMapper();
			mapper.Class<Foo>(cm => cm.Bag(x => x.Bars,
			 							   bpm => { },
										   cer => cer.ManyToMany(mtmm => mtmm.Column(columnName))));
			mapper.Class<Bar>(cm => cm.Id(x => x.Id));
			var mapping = mapper.CompileMappingFor(new[] { typeof(Foo), typeof(Bar) });
			var hbmClass = mapping.RootClasses.Single(x => x.Name == "Foo");
			var hbmBag = hbmClass.Properties.OfType<HbmBag>().Single();
			var hbmManyToMany = (HbmManyToMany)hbmBag.ElementRelationship;
			Assert.AreEqual(columnName, hbmManyToMany.column);
		}
		public void ComponentMappingJustOnceDemo()
		{
			var mapper = new ModelMapper();
			mapper.Component<Name>(comp =>
			{
				comp.Property(name => name.First);
				comp.Property(name => name.Last);
			});
			mapper.Component<Address>(comp =>
			{
				comp.Property(address => address.CivicNumber);
				comp.Property(address => address.Street);
			});
			mapper.Class<Person1>(cm =>
			{
				cm.Id(person => person.Id, map => map.Generator(Generators.HighLow));
				cm.Property(person => person.Test);
				cm.Component(person => person.Name, comp => { });
				cm.Component(person => person.Address, comp => { });
			});

			var hbmMapping = mapper.CompileMappingForAllExplicitlyAddedEntities();

			var hbmClass = hbmMapping.RootClasses[0];

			var hbmComponents = hbmClass.Properties.OfType<HbmComponent>();
			hbmComponents.Should().Have.Count.EqualTo(2);
			hbmComponents.Select(x => x.Name).Should().Have.SameValuesAs("Name","Address");
		} 
Ejemplo n.º 26
0
        public static Configuration BuildConfiguration(string connStr)
        {
            var cfg = new Configuration();

            // See http://fabiomaulo.blogspot.com/2009/07/nhibernate-configuration-through.html
            cfg.DataBaseIntegration(db => {
                db.Driver<SqlClientDriver>();
                db.Dialect<MsSql2012Dialect>();
                db.ConnectionString = connStr; // db.ConnectionStringName = "ConnStr";
                db.HqlToSqlSubstitutions = "true 1, false 0, yes 'Y', no 'N'";

                // See http://geekswithblogs.net/lszk/archive/2011/07/12/showing-a-sql-generated-by-nhibernate-on-the-vs-build-in.aspx
                //db.LogSqlInConsole = true; // Remove if using Log4Net
                //db.LogFormattedSql = true;
                //db.AutoCommentSql = true;

                db.SchemaAction = SchemaAutoAction.Validate; // This correspond to "hbm2ddl.validate", see http://nhforge.org/blogs/nhibernate/archive/2008/11/23/nhibernate-hbm2ddl.aspx
            });

            var mapper = new ModelMapper();
            mapper.Class<Parent>(map => {
                map.Id(x => x.Id, m => {
                    m.Generator(Generators.GuidComb);
                    m.UnsavedValue(Guid.Empty);
                });
                map.Version(x => x.RowVersion, m => m.UnsavedValue(0));
                map.Property(x => x.Description);
            });
            cfg.AddMapping(mapper.CompileMappingForAllExplicitlyAddedEntities());
            return cfg;
        }
		public void WhenMapDynCompoAttributesThenMapAttributes()
		{
			var mapper = new ModelMapper();
			mapper.Class<Person>(map =>
			{
				map.Id(x => x.Id, idmap => { });
				map.Component(x => x.Info, new { MyInt = 5}, z =>
				                                             {
																											 z.Access(Accessor.Field);
																											 z.Insert(false);
																											 z.Update(false);
																											 z.Unique(true);
																											 z.OptimisticLock(false);
				                                             });
			});

			var hbmMapping = mapper.CompileMappingFor(new[] { typeof(Person) });
			var hbmClass = hbmMapping.RootClasses[0];
			var hbmDynamicComponent = hbmClass.Properties.OfType<HbmDynamicComponent>().SingleOrDefault();
			hbmDynamicComponent.access.Should().Contain("field");
			hbmDynamicComponent.insert.Should().Be.False();
			hbmDynamicComponent.update.Should().Be.False();
			hbmDynamicComponent.optimisticlock.Should().Be.False();
			hbmDynamicComponent.unique.Should().Be.True();
		}
Ejemplo n.º 28
0
		public void TestMapElementElement()
		{
			var mapper = new ModelMapper();

			mapper.Class<ClassWithMapElementElement>(
				c =>
				{
					c.Lazy(false);
					c.Id(id => id.Id, id => id.Generator(Generators.Identity));

					c.Map(
						m => m.Map,
						col =>
						{
							col.Table("element_element");
							col.Key(k => k.Column("id"));
						},
						key => key.Element(e => e.Column("key")),
						element => element.Element(e => e.Column("element")));
				});

			var mappings = mapper.CompileMappingForAllExplicitlyAddedEntities();
			var hbmClass = mappings.RootClasses.FirstOrDefault(c => c.Name == typeof (ClassWithMapElementElement).Name);
			var hbmMap = hbmClass.Properties.OfType<HbmMap>().SingleOrDefault();

			Assert.That(hbmMap, Is.Not.Null);
			Assert.That(hbmMap.Item, Is.TypeOf<HbmMapKey>());
			Assert.That(hbmMap.Item1, Is.TypeOf<HbmElement>());
		}
Ejemplo n.º 29
0
		public void ShouldProperlyMapComponentWhenMappingOnlyPartOfItInSomePlaces()
		{
			var mapper = new ModelMapper();
			mapper.Class<ClassWithComponents>(cm =>
			{
				cm.Component(x => x.Component1, c =>
				{
					c.Property(x => x.PropertyOne, p => p.Column("OnePropertyOne"));
				});

				cm.Component(x => x.Component2, c =>
				{
					c.Property(x => x.PropertyOne, p => p.Column("TwoPropertyOne"));
					c.Property(x => x.PropertyTwo, p => p.Column("TwoPropertyTwo"));
				});
			});

			//Compile, and get the component property in which we mapped only one inner property
			var mappings = mapper.CompileMappingForAllExplicitlyAddedEntities();

			var component1PropertyMapping = (HbmComponent)mappings.RootClasses[0].Properties.Single(x => x.Name == "Component1");

			//There should be only one inner property in the mapping of this component
			// Note: take a look at how CURRENTLY the test fails with 1 expected vs 2, instead of vs 3. 
			//       This means that the "PropertyThree" property of the component that was never mapped, is not taken into account (which is fine).
			Assert.That(component1PropertyMapping.Items.Length, Is.EqualTo(1));
		}
		public void MapClassWithIdAndProperty()
		{
			var mapper = new ModelMapper();
			mapper.Class<MyClass>(ca =>
			{
				ca.Id("id", map =>
				{
					map.Column("MyClassId");
					map.Generator(Generators.HighLow, gmap => gmap.Params(new { max_low = 100 }));
				});
				ca.Version("version", map => { });
				ca.Property("something", map => map.Length(150));
			});
			var hbmMapping = mapper.CompileMappingFor(new[] { typeof(MyClass) });
			var hbmClass = hbmMapping.RootClasses[0];
			hbmClass.Should().Not.Be.Null();
			var hbmId = hbmClass.Id;
			hbmId.Should().Not.Be.Null();
			hbmId.name.Should().Be("id");
			hbmId.access.Should().Be("field");
			var hbmGenerator = hbmId.generator;
			hbmGenerator.Should().Not.Be.Null();
			[email protected]().Be("hilo");
			hbmGenerator.param[0].name.Should().Be("max_low");
			hbmGenerator.param[0].GetText().Should().Be("100");
			var hbmVersion = hbmClass.Version;
			hbmVersion.name.Should().Be("version");
			var hbmProperty = hbmClass.Properties.OfType<HbmProperty>().Single();
			hbmProperty.name.Should().Be("something");
			hbmProperty.access.Should().Be("field");
			hbmProperty.length.Should().Be("150");
		}
Ejemplo n.º 31
0
 public override void InitDbModel(ModelMapper mapper)
 {
     mapper.Class <ReceivedData>(cfg => cfg.Table("Mqtt_ReceivedData"));
 }
        protected override HbmMapping GetMappings()
        {
            var mapper = new ModelMapper();

            mapper.Class <EntityComplex>(
                rc =>
            {
                rc.Id(x => x.Id, m => m.Generator(Generators.GuidComb));

                rc.Version(ep => ep.Version, vm => { });

                rc.Property(x => x.Name);

                rc.Property(ep => ep.LazyProp, m => m.Lazy(true));

                rc.ManyToOne(ep => ep.SameTypeChild, m => m.Column("SameTypeChildId"));

                rc.ManyToOne(ep => ep.SameTypeChild2, m => m.Column("SameTypeChild2Id"));
            });

            mapper.Class <EntityWithCompositeId>(
                rc =>
            {
                rc.ComponentAsId(
                    e => e.Key,
                    ekm =>
                {
                    ekm.Property(ek => ek.Id1);
                    ekm.Property(ek => ek.Id2);
                });

                rc.Property(e => e.Name);
            });

            mapper.Class <EntityWithCompositeId>(
                rc =>
            {
                rc.ComponentAsId(
                    e => e.Key,
                    ekm =>
                {
                    ekm.Property(ek => ek.Id1);
                    ekm.Property(ek => ek.Id2);
                });

                rc.Property(e => e.Name);
            });

            mapper.Class <EntityWithNoAssociation>(
                rc =>
            {
                rc.Id(e => e.Id, m => m.Generator(Generators.GuidComb));

                rc.Property(e => e.Complex1Id);
                rc.Property(e => e.Complex2Id);
                rc.Property(e => e.Simple1Id);
                rc.Property(e => e.Simple2Id);
                rc.Property(e => e.Composite1Key1);
                rc.Property(e => e.Composite1Key2);
                rc.Property(e => e.CustomEntityNameId);
            });

            mapper.Class <EntityCustomEntityName>(
                rc =>
            {
                rc.EntityName(_customEntityName);

                rc.Id(e => e.Id, m => m.Generator(Generators.GuidComb));
                rc.Property(e => e.Name);
            });

            return(mapper.CompileMappingForAllExplicitlyAddedEntities());
        }
        protected override HbmMapping GetMappings()
        {
            var mapper = new ModelMapper();

            mapper.Class <EntityComplex>(
                rc =>
            {
                rc.Id(x => x.Id, m => m.Generator(Generators.GuidComb));

                rc.Version(ep => ep.Version, vm => { });

                rc.Property(x => x.Name);

                rc.Property(ep => ep.LazyProp, m => m.Lazy(true));

                rc.ManyToOne(ep => ep.Child1, m => m.Column("Child1Id"));
                rc.ManyToOne(ep => ep.Child2, m => m.Column("Child2Id"));
                rc.ManyToOne(ep => ep.SameTypeChild, m => m.Column("SameTypeChildId"));

                rc.Bag(
                    ep => ep.ChildrenList,
                    m =>
                {
                    m.Cascade(Mapping.ByCode.Cascade.All);
                    m.Inverse(true);
                },
                    a => a.OneToMany());
            });

            mapper.Class <EntitySimpleChild>(
                rc =>
            {
                rc.Id(x => x.Id, m => m.Generator(Generators.GuidComb));
                rc.Property(x => x.Name);
            });

            mapper.Class <EntityWithCompositeId>(
                rc =>
            {
                rc.ComponentAsId(
                    e => e.Key,
                    ekm =>
                {
                    ekm.Property(ek => ek.Id1);
                    ekm.Property(ek => ek.Id2);
                });

                rc.Property(e => e.Name);
            });

            mapper.Class <EntityCustomEntityName>(
                rc =>
            {
                rc.EntityName(customEntityName);

                rc.Id(x => x.Id, m => m.Generator(Generators.GuidComb));
                rc.Property(x => x.Name);
            });

            return(mapper.CompileMappingForAllExplicitlyAddedEntities());
        }
Ejemplo n.º 34
0
 public override void InitDbModel(ModelMapper mapper)
 {
     mapper.Class <UserScript>(cfg => cfg.Table("Scripts_UserScript"));
     mapper.Class <ScriptEventHandler>(cfg => cfg.Table("Scripts_EventHandler"));
 }
Ejemplo n.º 35
0
 public override void InitDbModel(ModelMapper mapper)
 {
     mapper.Class <AlarmTime>(cfg => cfg.Table("AlarmClock_AlarmTime"));
 }
Ejemplo n.º 36
0
        public void IdBag_InBaseEntity_WithDifferentTables_ShouldBeMappedAccordingly()
        {
            var mapper = new ModelMapper();

            mapper.Class <Entity1>(cm =>
            {
                cm.Table("Legacy1");
                cm.Id(p => p.Id);
                cm.Property(p => p.Foo);
                cm.IdBag(p => p.ComponentCollection,
                         m =>
                {
                    m.Access(Accessor.Field);
                    m.Fetch(CollectionFetchMode.Select);
                    m.Table("Legacy1_Comp");
                },
                         m => m.Component(c =>
                {
                    c.Property(p => p.Property1);
                    c.Property(p => p.Property2);
                }));
            });
            mapper.Class <Entity2>(cm =>
            {
                cm.Table("Legacy2");
                cm.Id(p => p.Id);
                cm.Property(p => p.Bar);
                cm.IdBag(p => p.ComponentCollection,
                         m =>
                {
                    m.Access(Accessor.Field);
                    m.Fetch(CollectionFetchMode.Select);
                    m.Table("Legacy2_Comp");
                },
                         m => m.Component(c =>
                {
                    c.Property(p => p.Property1);
                    c.Property(p => p.Property2);
                }));
            });
            mapper.Class <Entity3>(cm =>
            {
                cm.Id(p => p.Id);
                cm.IdBag(p => p.ComponentCollection,
                         m =>
                {
                    m.Access(Accessor.Field);
                    m.Fetch(CollectionFetchMode.Select);
                },
                         m => m.Component(c =>
                {
                    c.Property(p => p.Property1);
                    c.Property(p => p.Property2);
                }));
                cm.Property(p => p.Baz);
            });
            //set some defaults:
            //our bags are by default stored in a table called RootType_Component (unless overridden by the mapping)
            mapper.BeforeMapIdBag += (mi, m, pc) => pc.Table(m.GetRootMember().ReflectedType.Name + "_Component");
            //all entities are by default stored in a table called Type
            mapper.BeforeMapClass += (mi, t, pc) => pc.Table(t.Name);
            var mappings = mapper.CompileMappingForAllExplicitlyAddedEntities();

            var classMappings = mappings.Items.OfType <HbmClass>();

            Assert.That(classMappings.Count(), Is.EqualTo(3));
            var e1Mapping = classMappings.FirstOrDefault(c => c.Name == typeof(Entity1).Name);

            Assert.That(e1Mapping, Is.Not.Null);
            Assert.That(e1Mapping.table, Is.EqualTo("Legacy1"));

            var e1Bag = e1Mapping.Items.OfType <HbmIdbag>().FirstOrDefault();

            Assert.That(e1Bag, Is.Not.Null);
            Assert.That(e1Bag.Table, Is.EqualTo("Legacy1_Comp"));

            var e2Mapping = classMappings.FirstOrDefault(c => c.Name == typeof(Entity2).Name);

            Assert.That(e2Mapping, Is.Not.Null);
            Assert.That(e2Mapping.table, Is.EqualTo("Legacy2"));

            var e2Bag = e2Mapping.Items.OfType <HbmIdbag>().FirstOrDefault();

            Assert.That(e2Bag, Is.Not.Null);
            Assert.That(e2Bag.Table, Is.EqualTo("Legacy2_Comp"));

            var e3Mapping = classMappings.FirstOrDefault(c => c.Name == typeof(Entity3).Name);

            Assert.That(e3Mapping, Is.Not.Null);
            Assert.That(e3Mapping.table, Is.EqualTo("Entity3"));

            var e3Bag = e3Mapping.Items.OfType <HbmIdbag>().FirstOrDefault();

            Assert.That(e3Bag, Is.Not.Null);
            Assert.That(e3Bag.Table, Is.EqualTo("Entity3_Component"));
        }
Ejemplo n.º 37
0
        public const int PERIOD = 36;           // in hours

        public override void InitDbModel(ModelMapper mapper)
        {
            mapper.Class <TemperatureSensor>(cfg => cfg.Table("Microclimate_TemperatureSensor"));
            mapper.Class <TemperatureData>(cfg => cfg.Table("Microclimate_TemperatureData"));
        }
Ejemplo n.º 38
0
 public override void InitDbModel(ModelMapper mapper)
 {
     mapper.Class <Location>(cfg => cfg.Table("Weather_Location"));
     mapper.Class <WeatherData>(cfg => cfg.Table("Weather_Data"));
 }
Ejemplo n.º 39
0
        public override Configuration Map(Configuration cfg)
        {
            ModelMapper mapper = new ModelMapper();

            mapper.Class <Address>(ca =>
            {
                ca.Table("address");
                ca.Lazy(true);
                ca.Id(x => x.CustomerId, map =>
                {
                    map.Column("customer_id");
                    map.Generator(Generators.Foreign <Address>(x => x.Customer));
                });
                ca.Property(x => x.City, x =>
                {
                    x.NotNullable(true);
                    x.Column("city");
                    x.Length(50);
                });
                ca.Property(x => x.Country, x =>
                {
                    x.NotNullable(true);
                    x.Column("country");
                    x.Length(50);
                });
                ca.Property(x => x.Street, x =>
                {
                    x.NotNullable(true);
                    x.Column("street");
                    x.Length(50);
                });
                ca.Property(x => x.ZipCode, x =>
                {
                    x.NotNullable(true);
                    x.Column("zipcode");
                    x.Length(10);
                });
                ca.OneToOne(x => x.Customer, x =>
                {
                    x.Constrained(true);
                });
            });

            mapper.Class <Customer>(ca =>
            {
                ca.Table("customer");
                ca.Lazy(true);
                ca.Id(x => x.CustomerId, map =>
                {
                    map.Column("customer_id");
                    map.Generator(Generators.HighLow);
                });
                ca.NaturalId(x => x.Property(c => c.Name, y =>
                {
                    y.Column("name");
                    y.Length(50);
                    y.NotNullable(true);
                }));
                ca.NaturalId(x => x.Property(c => c.Email, y =>
                {
                    y.Column("email");
                    y.Length(50);
                }));
                ca.Property(x => x.Name, p =>
                {
                    p.NotNullable(true);
                    p.Column("name");
                });
                ca.Set(c => c.Orders, c =>
                {
                    c.Key(x => x.Column("customer_id"));
                    c.Fetch(CollectionFetchMode.Select);
                    c.Inverse(true);
                    c.Lazy(CollectionLazy.Extra);
                    c.Cascade(Cascade.All | Cascade.DeleteOrphans);
                }, c => c.OneToMany());
                ca.Set(c => c.RecentOrders, c =>
                {
                    c.Key(x => x.Column("customer_id"));
                    c.Fetch(CollectionFetchMode.Select);
                    c.Where("(date >= (GETDATE() - 7))");
                    c.Inverse(true);
                    c.Mutable(false);
                    c.Cascade(Cascade.None);
                    c.Lazy(CollectionLazy.Lazy);
                }, c => c.OneToMany());
                ca.OneToOne(x => x.Address, x =>
                {
                    x.Cascade(Cascade.All | Cascade.DeleteOrphans);
                    x.Constrained(false);
                });
            });

            mapper.Class <Order>(ca =>
            {
                ca.Table("order");
                ca.Lazy(true);
                ca.Id(x => x.OrderId, map =>
                {
                    map.Column("order_id");
                    map.Generator(Generators.HighLow);
                });
                ca.Property(x => x.State, x =>
                {
                    x.NotNullable(true);
                    x.Column("state");
                    x.Type <EnumType <OrderState> >();
                });
                ca.Property(x => x.Date, x =>
                {
                    x.NotNullable(true);
                    x.Column("date");
                });
                ca.ManyToOne(c => c.Customer, a =>
                {
                    a.Column("customer_id");
                    a.NotNullable(true);
                    a.Fetch(FetchKind.Select);
                    a.Lazy(LazyRelation.NoProxy);
                    a.Cascade(Cascade.All);
                });
                ca.Set(x => x.Details, x =>
                {
                    x.Key(c => c.Column("order_id"));
                    x.Fetch(CollectionFetchMode.Subselect);
                    x.Inverse(true);
                    x.Lazy(CollectionLazy.Extra);
                    x.Cascade(Cascade.All | Cascade.DeleteOrphans);
                }, c => c.OneToMany());
            });

            mapper.Class <OrderDetail>(ca =>
            {
                ca.Table("order_detail");
                ca.Lazy(true);
                ca.Id(x => x.OrderDetailId, map =>
                {
                    map.Column("order_detail_id");
                    map.Generator(Generators.HighLow);
                });
                ca.Property(x => x.Quantity, x =>
                {
                    x.NotNullable(true);
                    x.Column("quantity");
                });
                ca.Property(x => x.ItemsPrice, x =>
                {
                    x.Formula("(quantity * (SELECT product.price FROM product WHERE product.product_id = product_id))");
                    x.Access(Accessor.None);
                    x.Update(false);
                    x.Type(NHibernateUtil.Decimal);
                    x.Insert(false);
                });
                ca.ManyToOne(x => x.Order, x =>
                {
                    x.NotNullable(true);
                    x.Column("order_id");
                    x.Fetch(FetchKind.Select);
                    x.Lazy(LazyRelation.NoProxy);
                    x.Cascade(Cascade.None);
                });
                ca.ManyToOne(x => x.Product, x =>
                {
                    x.NotNullable(true);
                    x.Column("product_id");
                    x.Fetch(FetchKind.Select);
                    x.Lazy(LazyRelation.NoProxy);
                    x.Cascade(Cascade.None);
                });
            });

            mapper.Class <Product>(ca =>
            {
                ca.Table("product");
                ca.Lazy(true);
                ca.Id(x => x.ProductId, map =>
                {
                    map.Column("product_id");
                    map.Generator(Generators.HighLow);
                });
                ca.NaturalId(x => x.Property(c => c.Name));
                ca.Property(x => x.OrderCount, x =>
                {
                    x.Formula("(SELECT COUNT(1) FROM order_detail WHERE order_detail.product_id = product_id)");
                });
                ca.Property(x => x.Name, x =>
                {
                    x.NotNullable(true);
                    x.Column("name");
                });
                ca.Property(x => x.Price, x =>
                {
                    x.NotNullable(true);
                    x.Column("price");
                });
                ca.Property(x => x.Picture, x =>
                {
                    x.NotNullable(false);
                    x.Column("picture");
                    x.Lazy(true);
                    x.Type <ImageUserType>(new { ImageFormat = ImageFormat.Gif });
                });
                ca.Property(x => x.Specification, x =>
                {
                    x.NotNullable(true);
                    x.Column("specification");
                    x.Lazy(true);
                    x.Type <XDocType>();
                });
                ca.Set(x => x.OrderDetails, x =>
                {
                    x.Key(c => c.Column("product_id"));
                    x.Inverse(true);
                    x.Cascade(Cascade.All | Cascade.DeleteOrphans);
                    x.Lazy(CollectionLazy.Lazy);
                }, c => c.OneToMany());
                ca.Map(x => x.Attributes, c =>
                {
                    c.Cascade(Cascade.All);
                    c.Lazy(CollectionLazy.Extra);
                    c.Table("product_attribute");
                    c.Key(y =>
                    {
                        y.Column("product_id");
                        y.NotNullable(true);
                    });
                }, k =>
                {
                    k.Element(e =>
                    {
                        e.Column(y =>
                        {
                            y.Name("name");
                            y.NotNullable(true);
                        });
                    });
                }, r =>
                {
                    r.Element(e =>
                    {
                        e.Column("value");
                        e.NotNullable(true);
                    });
                });
            });

            mapper.AddMapping <PersonMapping>();
            mapper.AddMapping <ForeignCitizenMapping>();
            mapper.AddMapping <NationalCitizenMappping>();

            mapper.AddMapping <LanguageMapping>();
            mapper.AddMapping <TermMapping>();
            mapper.AddMapping <TranslationMapping>();

            mapper.AddMapping <RecordMapping>();

            //for mapping by code
            mapper.AddMapping <BlogMapping>();
            mapper.AddMapping <UserMapping>();
            mapper.AddMapping <PostMapping>();
            mapper.AddMapping <CommentMapping>();
            mapper.AddMapping <AttachmentMapping>();

            //mapper.AddMappings(typeof(BlogMapping).Assembly.GetTypes().Where(x => x.BaseType.IsGenericType && x.BaseType.GetGenericTypeDefinition() == typeof(ClassMapping<>)));

            HbmMapping mappings = mapper.CompileMappingForAllExplicitlyAddedEntities();

            cfg.AddDeserializedMapping(mappings, null);

            return(cfg);
        }
Ejemplo n.º 40
0
        protected override HbmMapping GetMappings()
        {
            var mapper = new ModelMapper();

            mapper.Class <EntityComplex>(
                rc =>
            {
                rc.Id(x => x.Id, m => m.Generator(Generators.GuidComb));

                rc.Version(ep => ep.Version, vm => { });

                rc.Property(x => x.Name);

                rc.Property(ep => ep.LazyProp, m => m.Lazy(true));

                rc.ManyToOne(ep => ep.SameTypeChild, m => m.Column("SameTypeChildId"));

                rc.ManyToOne(ep => ep.SameTypeChild2, m => m.Column("SameTypeChild2Id"));
            });

            mapper.Class <EntityWithCompositeId>(
                rc =>
            {
                rc.ComponentAsId(
                    e => e.Key,
                    ekm =>
                {
                    ekm.Property(ek => ek.Id1);
                    ekm.Property(ek => ek.Id2);
                });

                rc.Property(e => e.Name);
            });

            mapper.Class <EntityWithCompositeId>(
                rc =>
            {
                rc.ComponentAsId(
                    e => e.Key,
                    ekm =>
                {
                    ekm.Property(ek => ek.Id1);
                    ekm.Property(ek => ek.Id2);
                });

                rc.Property(e => e.Name);
            });

            mapper.Class <EntityWithNoAssociation>(
                rc =>
            {
                rc.Id(e => e.Id, m => m.Generator(Generators.GuidComb));

                rc.Property(e => e.Complex1Id);
                rc.Property(e => e.Complex2Id);
                rc.Property(e => e.Simple1Id);
                rc.Property(e => e.Simple2Id);
                rc.Property(e => e.Composite1Key1);
                rc.Property(e => e.Composite1Key2);
                rc.Property(e => e.CustomEntityNameId);
            });

            mapper.Class <EntityCustomEntityName>(
                rc =>
            {
                rc.EntityName(_customEntityName);

                rc.Id(e => e.Id, m => m.Generator(Generators.GuidComb));
                rc.Property(e => e.Name);
            });

            mapper.Class <OneToOneEntity>(
                rc =>
            {
                rc.Id(e => e.Id, m => m.Generator(Generators.GuidComb));
                rc.Property(e => e.Name);
            });

            mapper.Class <PropRefEntity>(
                rc =>
            {
                rc.Id(e => e.Id, m => m.Generator(Generators.GuidComb));
                rc.Property(e => e.Name);
                rc.Property(e => e.PropertyRef, m => m.Column("EntityPropertyRef"));
            });

            mapper.Class <NullableOwner>(
                rc =>
            {
                rc.Id(e => e.Id, m => m.Generator(Generators.GuidComb));
                rc.Property(e => e.Name);
                rc.OneToOne(e => e.OneToOne, m => m.Constrained(false));
                rc.ManyToOne(
                    e => e.PropRef,
                    m =>
                {
                    m.Column("OwnerPropertyRef");
                    m.PropertyRef(nameof(PropRefEntity.PropertyRef));
                    m.ForeignKey("none");
                    m.NotFound(NotFoundMode.Ignore);
                });
                rc.ManyToOne(e => e.ManyToOne, m => m.NotFound(NotFoundMode.Ignore));
            });


            return(mapper.CompileMappingForAllExplicitlyAddedEntities());
        }
Ejemplo n.º 41
0
        protected override HbmMapping GetMappings()
        {
            var mapper = new ModelMapper();

            mapper.Class <EntityComplex>(
                rc =>
            {
                rc.Id(x => x.Id, m => m.Generator(Generators.GuidComb));

                rc.Version(ep => ep.Version, vm => { });

                rc.Property(x => x.Name);

                rc.Property(ep => ep.LazyProp, m => m.Lazy(true));

                rc.ManyToOne(ep => ep.Child1, m => m.Column("Child1Id"));
                rc.ManyToOne(ep => ep.Child2, m => m.Column("Child2Id"));
                rc.ManyToOne(ep => ep.SameTypeChild, m => m.Column("SameTypeChildId"));

                rc.Bag(
                    ep => ep.ChildrenList,
                    m =>
                {
                    m.Cascade(Mapping.ByCode.Cascade.All);
                    m.Inverse(true);
                },
                    a => a.OneToMany());
            });

            mapper.Class <EntitySimpleChild>(
                rc =>
            {
                rc.Id(x => x.Id, m => m.Generator(Generators.GuidComb));
                rc.ManyToOne(x => x.Parent);
                rc.Property(x => x.Name);
            });
            mapper.Class <EntityEager>(
                rc =>
            {
                rc.Lazy(false);

                rc.Id(x => x.Id, m => m.Generator(Generators.GuidComb));
                rc.Property(x => x.Name);

                rc.Bag(ep => ep.ChildrenListSubselect,
                       m =>
                {
                    m.Cascade(Mapping.ByCode.Cascade.All);
                    m.Inverse(true);
                    m.Fetch(CollectionFetchMode.Subselect);
                    m.Lazy(CollectionLazy.NoLazy);
                },
                       a => a.OneToMany());

                rc.Bag(ep => ep.ChildrenListEager,
                       m =>
                {
                    m.Lazy(CollectionLazy.NoLazy);
                },
                       a => a.OneToMany());
            });
            mapper.Class <EntitySubselectChild>(
                rc =>
            {
                rc.Id(x => x.Id, m => m.Generator(Generators.GuidComb));
                rc.Property(x => x.Name);
                rc.ManyToOne(c => c.Parent);
            });

            return(mapper.CompileMappingForAllExplicitlyAddedEntities());
        }
Ejemplo n.º 42
0
 public override void InitDbModel(ModelMapper mapper)
 {
     mapper.Class <Dashboard>(cfg => cfg.Table("UniUI_Dashboard"));
     mapper.Class <Widget>(cfg => cfg.Table("UniUI_Widget"));
     mapper.Class <WidgetParameter>(cfg => cfg.Table("UniUI_WidgetParameter"));
 }
Ejemplo n.º 43
0
        protected override HbmMapping GetMappings()
        {
            var mapper = new ModelMapper();

            #region Subclass hierarchy

            mapper.Class <EntityClassProxy>(
                rc =>
            {
                rc.Id(x => x.Id);
                rc.Property(x => x.Name);
            });

            mapper.UnionSubclass <SubEntityInterfaceProxy>(
                rc =>
            {
                rc.Proxy(typeof(ISubEntityProxy));

                rc.Property(x => x.AnotherName);
            });

            mapper.UnionSubclass <AnotherSubEntityInterfaceProxy>(
                rc =>
            {
                rc.Proxy(typeof(IAnotherEntityProxy));

                rc.Property(x => x.AnotherName);
            });

            mapper.Class <EntityWithSuperClassInterfaceLookup>(
                rc =>
            {
                rc.Table("ClassWithInterfaceLookup");
                rc.Id(x => x.Id);
                rc.Property(x => x.Name);
                rc.ManyToOne(x => x.EntityLookup, x => x.Class(typeof(EntityClassProxy)));
            });

            #endregion Subclass hierarchy

            mapper.Class <EntitySimple>(
                rc =>
            {
                rc.Id(x => x.Id);
                rc.Property(x => x.Name);
            });

            mapper.Class <EntityExplicitInterface>(
                rc =>
            {
                rc.Id(x => x.Id);
                rc.Property(x => x.Name);
            });

            mapper.Class <EntityMultiInterfaces>(
                rc =>
            {
                rc.Id(x => x.Id);
                rc.Property(x => x.Name);
            });

            mapper.Class <EntityMixExplicitImplicitInterface>(
                rc =>
            {
                rc.Table("multiInterface");
                rc.Id(x => x.Id);
                rc.Property(x => x.Name);
            });

            mapper.Class <EntityMultiIdProxy>(
                rc =>
            {
                rc.Proxy(typeof(IMultiIdProxy));
                rc.Id(x => x.Id);
                rc.Property(x => x.Name);
            });

            mapper.Class <EntityWithExplicitGenericInterface>(
                rc =>
            {
                rc.Table("explGenInterface");
                rc.Id(x => x.Id);
            });

            return(mapper.CompileMappingForAllExplicitlyAddedEntities());
        }
Ejemplo n.º 44
0
        /// <summary>
        /// 类型配置
        /// </summary>
        static void Mapping()
        {
            ModelMapper mapper = new ModelMapper();

            mapper.Class <Class>(m =>
            {
                m.Cache(ch => ch.Usage(CacheUsage.ReadWrite));
                m.Id <UInt32>(c => c.Id, im =>
                {
                    im.Generator(Generators.Native);
                    im.Column("Id");
                });
                m.Property <string>(c => c.Name, im => im.Column("Name"));
                m.Property <string>(c => c.Slogan);
                m.Table("t_Class");

                m.SchemaAction(SchemaAction.Export | SchemaAction.Update);

                m.Bag <Student>(c => c.Students, bm =>
                {
                    bm.BatchSize(45);
                    bm.Lazy(CollectionLazy.Lazy);
                    //bm.Fetch(CollectionFetchMode.Select);
                    bm.Inverse(true);
                    bm.Key(km =>
                    {
                        km.Column("ClassId");
                        //km.PropertyRef<UInt32>(pg => pg.Id);
                    });
                    //bm.Cascade(Cascade.Persist | Cascade.Remove | Cascade.DeleteOrphans);
                    bm.Cascade(NHibernate.Mapping.ByCode.Cascade.Persist | NHibernate.Mapping.ByCode.Cascade.Remove);
                }, er => er.OneToMany());
            });

            mapper.Class <Student>(m =>
            {
                m.Cache(ch => ch.Usage(CacheUsage.ReadWrite));
                m.Table("t_Student");
                m.Id <UInt32>(c => c.Id, im => { im.Generator(Generators.Native); im.Column("Id"); });
                m.Property <string>(c => c.Name);
                m.Property <Int32>(c => c.Age);
                //m.Property<Int32>(c => c.ClassId);
                m.SchemaAction(SchemaAction.Export | SchemaAction.Update);
                m.ManyToOne <Class>(p => p.Class, m2m =>
                {
                    m2m.Column("ClassId");
                    m2m.Lazy(LazyRelation.Proxy);
                    m2m.Class(typeof(Class));
                    //m2m.Cascade(Cascade.None);
                    //m2m.PropertyRef("Id");
                });
            });

            var hbmmap = mapper.CompileMappingForAllExplicitlyAddedEntities();

            Console.WriteLine(hbmmap.AsString());

            UnitOfWork.Configuration.AddMapping(hbmmap);

            //使用二次缓存
            //config.EntityCache<Class>(ch =>
            //{
            //    ch.Strategy = EntityCacheUsage.ReadWrite;
            //    ch.RegionName = "asd";
            //    ch.Collection(c => c.Students, chc => { chc.Strategy = EntityCacheUsage.ReadWrite; chc.RegionName = "asdCollection"; });
            //});
        }
Ejemplo n.º 45
0
        protected override HbmMapping GetMappings()
        {
            var mapper = new ModelMapper();

            mapper.Class <EntityEager>(
                rc =>
            {
                rc.Lazy(false);
                rc.Id(x => x.Id, m => m.Generator(Generators.GuidComb));
                rc.Version(ep => ep.Version, vm => { });
                rc.Property(x => x.Name);
                MapList(rc, p => p.ChildrenList, CollectionFetchMode.Join);
            });

            MapSimpleChild <EntityEagerChild>(
                mapper,
                rc => { rc.Lazy(false); });

            mapper.Class <EntityComplex>(
                rc =>
            {
                rc.Id(x => x.Id, m => m.Generator(Generators.GuidComb));

                rc.Version(ep => ep.Version, vm => { });

                rc.Property(x => x.Name);

                rc.Property(ep => ep.LazyProp, m => m.Lazy(true));

                rc.ManyToOne(
                    ep => ep.Child1,
                    m =>
                {
                    m.Column("Child1Id");
                    m.ForeignKey("none");
                });
                rc.ManyToOne(
                    ep => ep.Child2,
                    m =>
                {
                    m.Column("Child2Id");
                    m.ForeignKey("none");
                });
                rc.ManyToOne(ep => ep.SameTypeChild, m =>
                {
                    m.Column("SameTypeChildId");
                    m.ForeignKey("none");
                });
                MapList(rc, ep => ep.ChildrenList, mapper: m => m.OrderBy("OrderIdx desc"));
                MapList(rc, ep => ep.ChildrenListEmpty);
            });

            MapSimpleChild(
                mapper,
                default(EntitySimpleChild),
                c => c.Children,
                rc =>
            {
                rc.Property(sc => sc.LazyProp, mp => mp.Lazy(true));
                rc.Property(sc => sc.OrderIdx);
            });
            MapSimpleChild(mapper, default(Level2Child), c => c.Children);
            MapSimpleChild <Level3Child>(mapper);

            return(mapper.CompileMappingForAllExplicitlyAddedEntities());
        }
        public void PropertyCustomizerDifferentiatesBetweenChildClasses()
        {
            var mapper = new ModelMapper();

            mapper.Class <OwnerChildOne>(classMapper =>
            {
                classMapper.Id(p => p.Id);
                classMapper.Bag <OwnedItem>
                (
                    parent => parent.OwnedItems,
                    bagPropertyMapper =>
                {
                    bagPropertyMapper.Table("ChildOne");
                    bagPropertyMapper.Key(k => k.Column("Parent_Id"));
                },
                    r => r.Component(
                        child =>
                {
                    child.Property
                    (
                        c => c.NameOnClient,
                        pm =>
                    {
                        pm.Column("OwnerChildOne_CustomColumnName");
                    }
                    );
                }
                        )
                );
            });
            mapper.Class <OwnerChildTwo>(classMapper =>
            {
                classMapper.Id(p => p.Id);
                classMapper.Bag <OwnedItem>
                (
                    parent => parent.OwnedItems,
                    bagPropertyMapper =>
                {
                    bagPropertyMapper.Table("ChildTwo");
                    bagPropertyMapper.Key(k => k.Column("Parent_Id"));
                },
                    r => r.Component(
                        child =>
                {
                    child.Property
                    (
                        c => c.NameOnClient,
                        pm =>
                    {
                        pm.Column("OwnerChildTwo_CustomColumnName");
                    }
                    );
                }
                        )
                );
            });

            var mappings = mapper.CompileMappingForAllExplicitlyAddedEntities();

            HbmBag bag1 = mappings
                          .Items.Cast <HbmClass>()
                          .Where(c => c.Name == typeof(OwnerChildOne).FullName)
                          .Single()
                          .Properties.Cast <HbmBag>()
                          .Single();

            HbmCompositeElement childElement1    = (HbmCompositeElement)bag1.Item;
            HbmProperty         propertyMapping1 = childElement1.Properties.Cast <HbmProperty>().Single();

            Assert.That(propertyMapping1.Columns.Single().name, Is.EqualTo("OwnerChildOne_CustomColumnName"));

            HbmBag bag2 = mappings
                          .Items.Cast <HbmClass>()
                          .Where(c => c.Name == typeof(OwnerChildTwo).FullName)
                          .Single()
                          .Properties.Cast <HbmBag>()
                          .Single();

            HbmCompositeElement childElement2    = (HbmCompositeElement)bag2.Item;
            HbmProperty         propertyMapping2 = childElement2.Properties.Cast <HbmProperty>().Single();

            Assert.That(propertyMapping2.Columns.Single().name, Is.EqualTo("OwnerChildTwo_CustomColumnName"));
        }
Ejemplo n.º 47
0
        public static HbmMapping GetMapping()
        {
            var mapper = new ModelMapper();

            mapper.Component <Address>(comp =>
            {
                comp.Property(address => address.Street);
                comp.Property(address => address.City);
                comp.Property(address => address.PostalCode);
                comp.Property(address => address.Country);
                comp.ManyToOne(address => address.StateProvince);
            });

            mapper.Class <Animal>(rc =>
            {
                rc.Id(x => x.Id, map => map.Generator(Generators.Native));

                rc.Property(animal => animal.Description);
                rc.Property(animal => animal.BodyWeight);
                rc.ManyToOne(animal => animal.Mother);
                rc.ManyToOne(animal => animal.Father);
                rc.ManyToOne(animal => animal.Zoo);
                rc.Property(animal => animal.SerialNumber);
                rc.Set(animal => animal.Offspring, cm => cm.OrderBy(an => an.Father), rel => rel.OneToMany());
            });

            mapper.JoinedSubclass <Reptile>(jsc => { jsc.Property(reptile => reptile.BodyTemperature); });

            mapper.JoinedSubclass <Lizard>(jsc => { });

            mapper.JoinedSubclass <Mammal>(jsc =>
            {
                jsc.Property(mammal => mammal.Pregnant);
                jsc.Property(mammal => mammal.Birthdate);
            });

            mapper.JoinedSubclass <DomesticAnimal>(jsc =>
            {
                jsc.ManyToOne(domesticAnimal => domesticAnimal.Owner);
            });

            mapper.JoinedSubclass <Cat>(jsc => { });

            mapper.JoinedSubclass <Dog>(jsc => { });

            mapper.JoinedSubclass <Human>(jsc =>
            {
                jsc.Component(human => human.Name, comp =>
                {
                    comp.Property(name => name.First);
                    comp.Property(name => name.Initial);
                    comp.Property(name => name.Last);
                });
                jsc.Property(human => human.NickName);
                jsc.Property(human => human.Height);
                jsc.Property(human => human.IntValue);
                jsc.Property(human => human.FloatValue);
                jsc.Property(human => human.BigDecimalValue);
                jsc.Property(human => human.BigIntegerValue);
                jsc.Bag(human => human.Friends, cm => { }, rel => rel.ManyToMany());
                jsc.Map(human => human.Family, cm => { }, rel => rel.ManyToMany());
                jsc.Bag(human => human.Pets, cm => { cm.Inverse(true); }, rel => rel.OneToMany());
                jsc.Set(human => human.NickNames, cm =>
                {
                    cm.Lazy(CollectionLazy.NoLazy);
                    cm.Sort();
                }, cer => { });
                jsc.Map(human => human.Addresses, cm => { }, rel => rel.Component(comp => { }));
            });

            mapper.Class <User>(rc =>
            {
                rc.Id(u => u.Id, im => im.Generator(Generators.Foreign <User>(u => u.Human)));

                rc.Property(user => user.UserName);
                rc.OneToOne(user => user.Human, rm => rm.Constrained(true));
                rc.List(user => user.Permissions, cm => { }, cer => { });
            });

            mapper.Class <Zoo>(rc =>
            {
                rc.Id(x => x.Id, map => map.Generator(Generators.Native));
                rc.Property(zoo => zoo.Name);
                rc.Property(zoo => zoo.Classification);
                rc.Map(zoo => zoo.Mammals, cm => { }, rel => rel.OneToMany());
                rc.Map(zoo => zoo.Animals, cm => { cm.Inverse(true); }, rel => rel.OneToMany());
                rc.Component(zoo => zoo.Address, comp => { });
            });

            mapper.Subclass <PettingZoo>(sc => { });

            mapper.Class <StateProvince>(rc =>
            {
                rc.Id(x => x.Id, map => map.Generator(Generators.Native));
                rc.Property(sp => sp.Name);
                rc.Property(sp => sp.IsoCode);
            });
            return(mapper.CompileMappingFor(typeof(Animal).Assembly.GetTypes().Where(t => t.Namespace == typeof(Animal).Namespace)));
        }
Ejemplo n.º 48
0
        protected override HbmMapping GetMappings()
        {
            var mapper = new ModelMapper();

            mapper.Class <Client>(rc =>
            {
                rc.Id(x => x.Id, m => m.Generator(Generators.GuidComb));
                rc.Property(x => x.Name);
            });
            mapper.JoinedSubclass <CorporateClient>(rc =>
            {
                rc.Property(x => x.CorporateId);
            });
            mapper.Class <Project>(rc =>
            {
                rc.Id(x => x.Id, m => m.Generator(Generators.GuidComb));
                rc.Property(x => x.Name);
                rc.Property(x => x.EmailPref, m => m.Type <EnumType <EmailPref> >());
                rc.ManyToOne(x => x.Client, m => m.Column("ClientId"));
                rc.ManyToOne(x => x.BillingClient, m => m.Column("BillingClientId"));
                rc.ManyToOne(x => x.CorporateClient, m => m.Column("CorporateClientId"));
                rc.Set(x => x.Issues,
                       m =>
                {
                    m.Key(k => k.Column(c => c.Name("ProjectId")));
                },
                       rel => rel.OneToMany());
            });
            mapper.Class <Issue>(rc =>
            {
                rc.Id(x => x.Id, m => m.Generator(Generators.GuidComb));
                rc.Property(x => x.Name);
                rc.ManyToOne(x => x.Project, m => m.Column("ProjectId"));
                rc.ManyToOne(x => x.Client, m => m.Column("ClientId"));
            });
            mapper.Class <Invoice>(rc =>
            {
                rc.Id(x => x.Id, m => m.Generator(Generators.GuidComb));
                rc.Property(x => x.InvoiceNumber);
                rc.ManyToOne(x => x.Project, m => m.Column("ProjectId"));
                rc.ManyToOne(x => x.Issue, m => m.Column("IssueId"));
            });
            mapper.Class <Employee>(rc =>
            {
                rc.Id(x => x.Id, m => m.Generator(Generators.GuidComb));
                rc.Property(x => x.Name);
                rc.Property(x => x.ReviewAsPrimary);
                rc.Set(x => x.Projects,
                       m =>
                {
                    m.Table("EmployeesToProjects");
                    m.Cascade(Mapping.ByCode.Cascade.All | Mapping.ByCode.Cascade.DeleteOrphans);
                    m.Key(k => k.Column(c => c.Name("EmployeeId")));
                },
                       rel => rel.ManyToMany(m => m.Column("ProjectId")));
                rc.Set(x => x.WorkIssues,
                       m =>
                {
                    m.Table("EmployeesToWorkIssues");
                    m.Cascade(Mapping.ByCode.Cascade.All | Mapping.ByCode.Cascade.DeleteOrphans);
                    m.Key(k => k.Column(c => c.Name("EmployeeId")));
                },
                       rel => rel.ManyToMany(m => m.Column("IssueId")));
                rc.Set(x => x.ReviewIssues,
                       m =>
                {
                    m.Table("EmployeesToReviewIssues");
                    m.Cascade(Mapping.ByCode.Cascade.All | Mapping.ByCode.Cascade.DeleteOrphans);
                    m.Key(k => k.Column(c => c.Name("EmployeeId")));
                },
                       rel => rel.ManyToMany(m => m.Column("IssueId")));
            });

            return(mapper.CompileMappingForAllExplicitlyAddedEntities());
        }
Ejemplo n.º 49
0
        protected override HbmMapping GetMappings()
        {
            var mapper = new ModelMapper();

            mapper.Class <Concept>(m =>
            {
                m.Lazy(false);
                m.Id(c => c.Id, id =>
                {
                    id.Column("concept_id");
                    id.Generator(Generators.Native);
                });
                m.Set(c => c.Mappings,
                      collection =>
                {
                    collection.Fetch(CollectionFetchMode.Subselect);
                    collection.Lazy(CollectionLazy.NoLazy);
                    collection.Table("concept_mapping");
                    collection.Key(key =>
                    {
                        key.Column("concept_id");
                    });
                },
                      element =>
                {
                    element.Component(component =>
                    {
                        component.Property(c => c.Relationship, p => p.Column("relationship"));
                        component.ManyToOne(c => c.Code, manyToOne =>
                        {
                            manyToOne.Column("code_id");
                            manyToOne.Fetch(FetchKind.Join);
                            manyToOne.Cascade(NHibernate.Mapping.ByCode.Cascade.None);
                        });
                    });
                });
            });

            mapper.Class <ConceptCode>(m =>
            {
                m.Table("concept_code");
                m.Lazy(false);

                m.Id(c => c.Id, id =>
                {
                    id.Column("code_id");
                    id.Generator(Generators.Native);
                });

                m.Property(c => c.CodeSource, p =>
                {
                    p.Column("source");
                });
                m.Property(c => c.Value, p =>
                {
                    p.Column("`value`");
                });
            });

            return(mapper.CompileMappingForAllExplicitlyAddedEntities());
        }
Ejemplo n.º 50
0
        public override void InitDbModel(ModelMapper mapper)
        {
            base.InitDbModel(mapper);

            mapper.Class <Item>(cfg => cfg.Table("Storage_Item"));
        }
Ejemplo n.º 51
0
 public override void InitDbModel(ModelMapper mapper)
 {
     mapper.Class <Tile>(cfg => cfg.Table("WebUI_Tile"));
 }
Ejemplo n.º 52
0
 public override void InitDbModel(ModelMapper mapper)
 {
     mapper.Class <VoiceCommand>(cfg => cfg.Table("Speech_VoiceCommand"));
 }
Ejemplo n.º 53
0
 private void MapSpotifySession()
 {
     _modelMapper.Class <SpotifySession>(e =>
     {
         e.Id(p => p.Id, p => p.Generator(Generators.GuidComb));
         e.Property(p => p.DeviceId, p => p.NotNullable(true));
         e.Property(p => p.Time, p => p.NotNullable(true));
         e.ManyToOne(p => p.Token, mapper =>
         {
             mapper.Column("TokenId");
             mapper.NotNullable(true);
             mapper.Cascade(Cascade.None);
         });
     });
 }