public static ISessionFactory GetSessionFactory(NhDataContext context, FluentConfiguration factoryConfig, AutoPersistenceModel autoPersistanceModel = null)
        {
            var contextType = context.GetType();
            var contextAssembly = Assembly.GetAssembly(contextType);

            return _factories.GetOrAdd(contextType, CreateSessionFactory(contextAssembly, factoryConfig, autoPersistanceModel));
        }

 private static ISessionFactory CreateSessionFactory(Assembly contextAssembly, IPersistenceConfigurer dbPersister, AutoPersistenceModel autoPersistanceModel = null)
 {
     // Create config
     var factoryConfig = Fluently.Configure();
     factoryConfig.Database(dbPersister);
     return CreateSessionFactory(contextAssembly, factoryConfig, autoPersistanceModel);
 }

 protected virtual void AdditionalModelConfig(AutoPersistenceModel model)
 {
     // 29.12.2011 - Who would have thought that apparently only know I managed to surpass 4000 chars.
     // seems crazy but anyways, here's a fix for NH cutting off my text
     model.Override<Content>(
         a => a.Map(c => c.Body).Length(4001).CustomSqlType("nvarchar(MAX)"));
 }

 public MyAutoPersistenceModel()
 {
     this.AutoPersistenceModel = AutoMap.AssemblyOf<Entity>(new CustomAutomappingConfiguration())
             .IgnoreBase<Entity>()
             .Override<User>(map => map.IgnoreProperty(x => x.DisplayedName))
             .Override<Appointment>(map => map.IgnoreProperty(x => x.DateRange))
             .Override<IllnessPeriod>(map => map.IgnoreProperty(p => p.Duration))
             .Override<Role>(map => map.HasManyToMany(x => x.Tasks).Cascade.All())
             .Override<DbSetting>(map => map.Map(p => p.Key).Unique())
             .Override<Patient>(map =>
             {
                 map.DynamicUpdate();
                 map.IgnoreProperty(x => x.Age);
                 map.Map(x => x.IsDeactivated).Default("0").Not.Nullable();
                 map.HasMany<Bmi>(x => x.BmiHistory).KeyColumn("Patient_Id");
                 map.HasMany<MedicalRecord>(x => x.MedicalRecords).KeyColumn("Patient_Id");
                 map.HasMany<IllnessPeriod>(x => x.IllnessHistory).KeyColumn("Patient_Id");
                 map.HasMany<Appointment>(x => x.Appointments).KeyColumn("Patient_Id");
             })
             .Override<Person>(map =>
             {
                 map.Map(p => p.FirstName).Index("idx_person_FirstName");
                 map.Map(p => p.LastName).Index("idx_person_LastName");
             })
             .Override<ApplicationStatistics>(map =>
             {
                 map.Map(e => e.IsExported).Default("0").Not.Nullable();
                 map.Map(e => e.Version).Default("\"3.0.3\"").Not.Nullable();
             })
             .Conventions.Add(DefaultCascade.SaveUpdate()
                            , DynamicUpdate.AlwaysTrue()
                            , DynamicInsert.AlwaysTrue()
                            , LazyLoad.Always());
 }

        public static AutoPersistenceModel SagaPersistenceModel(IEnumerable<Type> typesToScan)
        {
            var sagaEntites = typesToScan.Where(t => typeof(ISagaEntity).IsAssignableFrom(t) && !t.IsInterface);

            var model = new AutoPersistenceModel();

            model.Conventions.AddFromAssemblyOf<IdShouldBeAssignedConvention>();

            var entityTypes = GetTypesThatShouldBeAutoMapped(sagaEntites,typesToScan);

            var assembliesContainingSagas = sagaEntites.Select(t => t.Assembly).Distinct();

            foreach (var assembly in assembliesContainingSagas)
                model.AddEntityAssembly(assembly)
                    .Where(t => entityTypes.Contains(t));

            var componentTypes = GetTypesThatShouldBeMappedAsComponents(sagaEntites);

            model.Setup(s =>
                          {
                              s.IsComponentType =
                                  type => componentTypes.Contains(type);
                          });
            return model;
        }

		public static Configuration Init(
			ISessionStorage storage, 
			string[] mappingAssemblies,
			AutoPersistenceModel autoPersistenceModel,
			string cfgFile,
			string validatorCfgFile)
		{
			return Init(storage, mappingAssemblies, autoPersistenceModel, cfgFile, null, validatorCfgFile, null);
		}

 public AutoPersistenceModel Generate()
 {
     var mappings = new AutoPersistenceModel();
     mappings.AddEntityAssembly(typeof (Class1).Assembly).Where(GetAutoMappingFilter);
     mappings.Conventions.Setup(GetConventions());
     mappings.Setup(GetSetup());
     mappings.UseOverridesFromAssemblyOf<AutoPersistenceModelGenerator>();
     return mappings;
 }

 public AutoPersistenceModel Generate()
 {
     var mappings = new AutoPersistenceModel();
     mappings.AddEntityAssembly(typeof(Site).Assembly).Where(GetAutoMappingFilter);
     //    mappings.Setup(GetSetup());
     mappings.IgnoreBase<Entity>();
     mappings.IgnoreBase(typeof(EntityWithTypedId<>));
     mappings.UseOverridesFromAssemblyOf<AutoPersistenceModelGenerator>();
     return mappings;
 }

		private void VerifyMapping(AutoPersistenceModel model, Action<CompositeIdMapping> verifier)
		{
			var idMapping = model.BuildMappings()
								.First()
								.Classes
								.First()
								.Id
								;

			idMapping.ShouldBeOfType(typeof(CompositeIdMapping));
			verifier((CompositeIdMapping)idMapping);
		}

 public Configuration Generate()
 {
     var model = new AutoPersistenceModel()
                 .AddEntityAssembly(Assembly.GetExecutingAssembly())
                 .Where(x => x.Namespace.IsNotNullOrEmpty() && x.Namespace.StartsWith("FakeVader.Core.Domain"))
                 .Conventions.AddFromAssemblyOf<HasManyConvention>();
     return Fluently.Configure()
         .Database(databaseConfig)
         .Mappings(
         configuration => configuration.AutoMappings.Add(model)
         ).BuildConfiguration();
 }

        public AutoPersistenceModel Generate()
        {
            var mappings = new AutoPersistenceModel();

            mappings.AddEntityAssembly(typeof (Class1).Assembly).Where(GetAutoMappingFilter);
            mappings.Conventions.Setup(GetConventions());
            mappings.Setup(GetSetup());
            mappings.UseOverridesFromAssemblyOf<AutoPersistenceModelGenerator>();

            mappings.Override<Idea>(i => i.Map(m => m.Text).CustomSqlType("TEXT"));
            mappings.Override<Comment>(c => c.Map(m => m.Text).CustomSqlType("TEXT"));

            return mappings;
        }

        public AutoPersistenceModel Generate()
        {
            var mappings = new AutoPersistenceModel();

            mappings
                .AddEntityAssembly(typeof(Player).Assembly)
                .UseOverridesFromAssembly(typeof(AutoPersistenceModelGenerator).Assembly)
                .Where(GetAutoMappingFilter);
                //.Setup(GetSetup())
                //.Conventions.Setup(GetConventions);

            MapEnums(mappings);

            return mappings;
        }

 public void Alter(AutoPersistenceModel model)
 {
     // if any type has a property of this type
     // that is of a type (or has a collection of a type)
     // that is abstract
     // is not generic
     // and inherits from entity
     // and has inheritors in the domain
     // then include that type
     // foreach property in type
     foreach (var strategyType in Strategies())
     {
         model.IncludeBase(strategyType);
     }
 }

        public virtual void fup()
        {
            domainModel = new AutoPersistenceModel(new AutoMapConfig())
                .AddEntityAssembly(Assembly.GetAssembly(typeof(IEntity)))
                .UseOverridesFromAssemblyOf<AirplayAutoMap>();

            var dbConfig = SQLiteConfiguration.Standard.UsingFile("gema4").ShowSql();
            //var dbConfig = SQLiteConfiguration.Standard.UsingFile("gema4");

            cfg = Fluently.Configure()
                .Mappings(m => m.AutoMappings.Add(domainModel))
                .Database(dbConfig)
                .BuildConfiguration();

            sf = cfg.BuildSessionFactory();
        }

        public AutoPersistenceModel Generate()
        {
            var mappings = new AutoPersistenceModel();

            mappings = AutoMap.AssemblyOf<Domain.Entity>();
            mappings.Where(GetAutoMappingFilter);
            mappings.Conventions.Setup(GetConventions());
            mappings.UseOverridesFromAssemblyOf<AutoPersistenceModelGenerator>();
            mappings.Setup(GetSetup());
            mappings.OverrideAll(x => x.IgnoreProperties(z => z.PropertyType.IsSubclassOf(typeof(Enumeration))));

            mappings.IgnoreBase<Domain.Entity>();
            mappings.UseOverridesFromAssemblyOf<AutoPersistenceModelGenerator>();

            return mappings;
        }

        /// <summary>
        /// Alter the model
        /// </summary>
        /// <remarks>
        /// Finds all types in the assembly (passed in the constructor) that implement IAutoMappingOverride&lt;T&gt;, then
        /// creates an AutoMapping&lt;T&gt; and applies the override to it.
        /// </remarks>
        /// <param name="model">AutoPersistenceModel instance to alter</param>
        public void Alter(AutoPersistenceModel model)
        {
            // find all types deriving from IAutoMappingOverride<T>
            var types = from type in assembly.GetExportedTypes()
                        where !type.IsAbstract
                        let entity = (from interfaceType in type.GetInterfaces()
                                      where interfaceType.IsGenericType && interfaceType.GetGenericTypeDefinition() == typeof(IAutoMappingOverride<>)
                                      select interfaceType.GetGenericArguments()[0]).FirstOrDefault()
                        where entity != null
                        select type;

            foreach (var type in types)
            {
                model.Override(type);
            }
        }

        static ISessionFactory create()
        {
            var domainModel = new AutoPersistenceModel(new AutoMapConfig())
                .AddEntityAssembly(Assembly.GetAssembly(typeof(IEntity)))
                .UseOverridesFromAssemblyOf<AirplayAutoMap>();

            var sqlite = SQLiteConfiguration.Standard
                .ConnectionString(x => x.Is("Data Source=|DataDirectory|gema4"))
                .CurrentSessionContext("web");

            var _sf = Fluently.Configure()
                .Mappings(m => m.AutoMappings.Add(domainModel))
                .Database(sqlite)
                .BuildSessionFactory();
            return _sf;
        }

        public ISessionFactory GetSessionFactory(string connection)
        {
            var model = new AutoPersistenceModel()
                        .AddEntityAssembly(typeof(Product).Assembly)
                        .Where(t => t.Namespace.StartsWith(typeof(Product).Namespace))
                        .Conventions.AddFromAssemblyOf<TableNameConvention>()
                        .UseOverridesFromAssemblyOf<CartMapOverride>();

            ISessionFactory fluentConfiguration = Fluently.Configure()
                                                   .Database(MsSqlConfiguration.MsSql2012
                                                            .ConnectionString(c => c.FromConnectionStringWithKey(connection))
                                                            .ShowSql())
                                                   .Mappings(m => m.AutoMappings.Add(model))
                                                   .BuildSessionFactory();

            return fluentConfiguration;
        }

 public NHibernatePersistenceModel()
 {
     _autoPersistenceModel = AutoPersistenceModel
         .MapEntitiesFromAssemblyOf<DomainEntity>()
         .WithAlterations(x =>
             x.Add<AutoMappingAlteration>())
         .WithSetup(s =>
         {
             s.FindIdentity = type => type.Name == "ID";
             s.IsBaseType = type => type == typeof (DomainEntity);
         })
         //.Where(type =>
         //    typeof (DomainEntity).IsAssignableFrom(type) &&
         //    type.Namespace == "Fohjin.Core.Domain")
         .ConventionDiscovery
             .AddFromAssemblyOf<IdentityColumnConvention>()
             .UseOverridesFromAssemblyOf<UserMappingOverride>();
 }

        public AutoPersistenceModel BuildPersistenceModel()
        {
            var persistenceModel = new AutoPersistenceModel();

            persistenceModel.Conventions.Setup(c =>
            {
                c.Add(typeof(ForeignKeyNameConvention));
                c.Add(typeof(ReferenceConvention));
                c.Add(typeof(PrimaryKeyNameConvention));
                c.Add(typeof(TableNameConvention));
            });

            persistenceModel.AddMappingsFromAssembly(AssemblyMapper);

            persistenceModel.WriteMappingsTo(@"./");

            return persistenceModel;
        }