private static void CreateMappings(MappingConfiguration mappingConfiguration)
{
var assembly = (typeof (CarMap).Assembly);
mappingConfiguration.FluentMappings.AddFromAssembly(assembly);
mappingConfiguration.HbmMappings.AddFromAssembly(assembly);
}
private static void AddTablePerConcreteClassMappings(MappingConfiguration conf)
{
conf.FluentMappings.Add<PageOfBob.Comparison.NH.Mapping.TablePerConcreteClass.UserMapping>();
conf.FluentMappings.Add<PageOfBob.Comparison.NH.Mapping.TablePerConcreteClass.ThingMapping>();
conf.FluentMappings.Add<PageOfBob.Comparison.NH.Mapping.TablePerConcreteClass.EventMapping>();
conf.FluentMappings.Add<PageOfBob.Comparison.NH.Mapping.TablePerConcreteClass.WorkMapping>();
}
private static void StudentMappings(MappingConfiguration m)
{
m.FluentMappings
.Add<StudentMap>().Add<StudentXrefMap>()
.Add<MarkMap>().Add<MarkXrefMap>()
.Add<StudentTypeMap>();
}
public void Apply(MappingConfiguration configuration)
{
var conventions = configuration.FluentMappings.Conventions;
conventions.Add(ConventionBuilder
.Class
.Always(x => x.Table(Inflector.Inflector.Pluralize(x.EntityType.Name).Escape())));
}
/// <summary>
/// Vordefinieren von Konventionen für die Mappings.
/// </summary>
public void Apply(MappingConfiguration configuration)
{
var conventions = configuration.FluentMappings.Conventions;
conventions.Add(ConventionBuilder
.Class
.Always(x => x.Table(Inflector.Net.Inflector.Pluralize(x.EntityType.Name).Escape())));
/* Kann man machen, muss man aber nicht...
conventions.Add(ConventionBuilder
.Id
.Always(x => x.Column(String.Format("{0}ID", x.EntityType.Name))));
conventions.Add(ConventionBuilder.Reference.Always(x =>
{
x.Column(String.Format("{0}ID", x.Property.Name));
x.ForeignKey(String.Format("FK_{0}To{1}", x.EntityType.Name, x.Property.Name));
}));
conventions.Add(ConventionBuilder.HasMany.Always(x =>
{
x.Key.Column(String.Format("{0}ID", x.Key.EntityType.Name));
x.Key.ForeignKey(String.Format("FK_{0}To{1}",
x.Relationship.StringIdentifierForModel,
x.Relationship.EntityType.Name));
}));
*/
conventions.Add(ConventionBuilder.Property.Always(x => x.Column(x.Property.Name)));
conventions.Add(DefaultLazy.Always());
}
private static void SocialMappings(MappingConfiguration m)
{
m.FluentMappings
.Add<ProfileMap>().Add<ProfileXrefMap>()
.Add<AddressMap>().Add<AddressXrefMap>()
.Add<CountryMap>();
}
public void Map(MappingConfiguration m)
{
var mapper = new AutomaticMapper(m);
mapper.LoadInterfaceMappingsFromAssemblyOf<AutoMaps>();
MapRootEntities(mapper);
m.HbmMappings.AddFromAssemblyOf<AutoMaps>();
}
private void Map(MappingConfiguration mapping)
{
foreach (var mappingConfig in _maps)
{
mappingConfig.Map(mapping);
}
}
/// <summary>
///
/// </summary>
private static void Mapper(MappingConfiguration config)
{
config
.FluentMappings
.AddFromAssemblyOf<DomainEntity>()
;
}
public override void ContributeMappings(Configuration configuration)
{
Arg.NotNull("configuration", configuration);
MappingConfiguration mappingConfiguration = new MappingConfiguration();
ContributeMappings(mappingConfiguration);
mappingConfiguration.Apply(configuration);
}
public void Configure(MappingConfiguration config, Action<IConventionFinder> defaultConventions)
{
var model = AutoMap.Assembly(GetMappingAssembly());
model = FilterModels(model);
model.Conventions.Setup(FilterConventions(defaultConventions));
config.AutoMappings.Add(model);
config.AutoMappings.ExportTo(@"c:\Projects");
}
private static void AddTablePerHierarchyMappings(MappingConfiguration conf)
{
conf.FluentMappings.Add<PageOfBob.Comparison.NH.Mapping.TablePerHierachy.BaseObjectMapping>();
conf.FluentMappings.Add<PageOfBob.Comparison.NH.Mapping.TablePerHierachy.UserMapping>();
conf.FluentMappings.Add<PageOfBob.Comparison.NH.Mapping.TablePerHierachy.ThingMapping>();
conf.FluentMappings.Add<PageOfBob.Comparison.NH.Mapping.TablePerHierachy.EventMapping>();
conf.FluentMappings.Add<PageOfBob.Comparison.NH.Mapping.TablePerHierachy.WorkMapping>();
}
private static void AddFluentMappings(MappingConfiguration cfg)
{
var assemblies = AppDomain.CurrentDomain.GetAssemblies();
foreach (Assembly assembly in assemblies)
{
cfg.FluentMappings.AddFromAssembly(assembly);
}
}
public static void Map(MappingConfiguration mappingConfiguration)
{
mappingConfiguration.AutoMappings.Add(AutoMap
.AssemblyOf<User>()
.UseOverridesFromAssemblyOf<User>()
.Conventions.AddFromAssemblyOf<User>()
.Where(t => typeof(IEntity).IsAssignableFrom(t))
);
}
private static void AddMappings(MappingConfiguration cfg)
{
cfg.FluentMappings.AddFromAssemblyOf<CountryMap>()
.Conventions.Add<PluralClassConvention>()
.Conventions.Add<UnderscorePropertyConvention>()
.Conventions.Add<SqlServer2008GeographyTypeConvention>();
// We're using geography, you can also use geometry
//.Add<SqlServer2008GeometryTypeConvention>()
}
public void Apply(MappingConfiguration configuration)
{
var conventions = configuration.FluentMappings.Conventions;
//conventions.Add(ConventionBuilder
// .Class.Always(
// x => x.Table(Inflector.Net.Inflector.Pluralize(x.EntityType.Name).Escape())));
conventions.Add(ConventionBuilder.Property.Always(x => x.Column(x.Property.Name)));
conventions.Add(DefaultLazy.Always());
}
void DiscoverClassMapsAndAddAssemblies(ITypeDiscoverer typeDiscoverer, MappingConfiguration mappings)
{
var assemblies = typeDiscoverer.FindMultiple(typeof(IMappingProvider)).Select(t => t.Assembly).Distinct();
foreach (var assembly in assemblies)
{
mappings.FluentMappings.AddFromAssembly(assembly).Conventions.Add(DefaultLazy.Never(), AutoImport.Never());
mappings.HbmMappings.AddFromAssembly(assembly);
}
}
public void CreateMappingConfiguration()
{
cfg = new Configuration();
SQLiteConfiguration.Standard
.InMemory()
.ConfigureProperties(cfg);
mapping = new MappingConfiguration();
}
static void AddAssemblies(
IEnumerable<Assembly> assembliesWithFluentMappings,
IEnumerable<Assembly> assembliesWithHbmMappings,
MappingConfiguration mappings)
{
assembliesWithFluentMappings.ForEach(
a => mappings.FluentMappings.AddFromAssembly(a).Conventions.Add(DefaultLazy.Never(), AutoImport.Never()));
assembliesWithHbmMappings.ForEach(
a => mappings.HbmMappings.AddFromAssembly(a));
}
public void CreateMappingConfiguration()
{
logger = Stub<IDiagnosticLogger>.Create();
cfg = new Configuration();
SQLiteConfiguration.Standard
.InMemory()
.ConfigureProperties(cfg);
mapping = new MappingConfiguration(logger);
}
private void ConfigureMapping(string sessionAlias, MappingConfiguration mappingConfiguration)
{
hbmMappingRegisterer.Apply(sessionAlias, mappingConfiguration.HbmMappings);
foreach (IAutoPersistenceModelProvider autoPersistenceModelProvider in autoPersistenceModelProviders)
{
AutoPersistenceModel autoPersistenceModel = autoPersistenceModelProvider.GetAutoPersistenceModel(assemblyProvider, sessionAlias);
autoPersistenceModel.Conventions.Setup(conventionFinder => conventionApplier.Apply(sessionAlias, conventionFinder));
mappingConfiguration.AutoMappings.Add(autoPersistenceModel);
}
mappingConfiguration.MergeMappings();
}
private static void CreateMappings(MappingConfiguration mappingConfiguration)
{
var assembly = typeof(EntityMap<Entity>).Assembly;
mappingConfiguration.FluentMappings.AddFromAssembly(assembly);
mappingConfiguration.HbmMappings.AddFromAssembly(assembly);
mappingConfiguration.FluentMappings.Conventions.AddFromAssemblyOf<PrimaryKeyConvention>();
mappingConfiguration.FluentMappings.Conventions.AddFromAssemblyOf<HasManyConvention>();
mappingConfiguration.FluentMappings.Conventions.AddFromAssemblyOf<HasOneConvention>();
mappingConfiguration.FluentMappings.Conventions.AddFromAssemblyOf<JoinedSubclassConvention>();
mappingConfiguration.FluentMappings.Conventions.AddFromAssemblyOf<ReferencesConvention>();
}
/// <summary>
/// Configures the given mapping
/// </summary>
/// <param name="m"></param>
public void Run(MappingConfiguration m)
{
m.HbmMappings
.AddFromAssemblyOf<AutoPersistenceModelGenerator>();
m.FluentMappings
.AddFromAssemblyOf<AutoPersistenceModelGenerator>()
.Conventions.Setup(GetConventions);
m.AutoMappings
.Add(Generate());
//m.AutoMappings.ExportTo(@"D:\_Development\JiscCollections\mappings");
m.FluentMappings.ExportTo(@"C:\_Development\FootyLinks\Database\Mappings");
}
/// <summary>
/// Mapeia dinamicamente pela referencia do assembly
/// </summary>
/// <param name="config"></param>
public static void MappingsAssembly(MappingConfiguration config)
{
string topNamespace = "Axis.Domain";
Assembly assemblyNamespace = Assembly.Load(topNamespace);
Type[] mappingList = Assembly.GetExecutingAssembly()
.GetTypes()
.Where(t => String.Equals(t.Namespace, topNamespace + ".Mapping", StringComparison.Ordinal)).ToArray();
foreach (var item in mappingList)
{
config.FluentMappings.Add(assemblyNamespace.GetType(topNamespace + ".Mapping." + item.Name, true, true));
}
}
public static void ConfigureMappings(MappingConfiguration mappingConfiguration, params IMappingConfigurationContributor[] configurationContributors)
{
mappingConfiguration.FluentMappings
.Conventions.Add(
ForeignKey.EndsWith("Id"),
PrimaryKey.Name.Is(x => x.EntityType.Name + "Id"),
DefaultCascade.None());
foreach (var configurationContributor in configurationContributors)
{
configurationContributor.ConfigureMappings(mappingConfiguration);
}
}
private void ConfigureMappings(MappingConfiguration config)
{
Database.Configuration.Mappings.ForEach(map => config.FluentMappings.AddFromAssembly(map));
config.FluentMappings.Conventions.Add<EnumConvention>();
config.FluentMappings.Conventions.Add<MonthConvention>();
config.FluentMappings.Conventions.Add(
DefaultLazy.Always(),
DefaultCascade.None(),
DynamicInsert.AlwaysTrue(),
DynamicUpdate.AlwaysTrue());
}
private static void AddImportedFluentMappings(MappingConfiguration cfg)
{
cfg.FluentMappings.Conventions.Setup(
x =>
{
x.Add(new CustomForeignKeyConvention());
});
var mappings = ServiceLocator.Current.GetAllInstances<IMappedEntity>();
foreach (IMappedEntity mapping in mappings)
{
cfg.FluentMappings.Add(mapping.GetType());
}
}
public void Configure(MappingConfiguration mappingConfig)
{
var assemblies = Assembly.GetAssembly(typeof (Entity));
var conventions = new IConvention[]
{
DefaultCascade.All(),
ConventionBuilder.Id.Always(m => m.GeneratedBy.HiLo("1000")),
ConventionBuilder.HasMany.Always(m => m.Inverse())
};
mappingConfig.AutoMappings.Add(
AutoMap.Assemblies(new AutoMapConfig(), assemblies)
.Conventions.Add(conventions));
}
private static void BuildFluentMappingConfig(MappingConfiguration mappings)
{
//mappings.FluentMappings.AddFromAssemblyOf<EmployeeMap>();
var autoCfg = new FluentAutoMappingConfiguration();
var autoMappings = AutoMap.AssemblyOf<Employee>(autoCfg)
.Conventions.AddFromAssemblyOf<CustomPrimaryKeyConvention>()
.Override<Store>(map =>
{
map.HasMany(x => x.Staff).Cascade.All();
map.HasManyToMany(x => x.Products).Cascade.All();
})
;
mappings.AutoMappings.Add(autoMappings);
}
public void Configure(MappingConfiguration config)
{
config.AutoMappings.Add(AutoMap.Assembly(_assemblyToMap, new AutoMapperConventions(_namespaces)).Conventions.Add(
new IConvention[]
{
ConventionBuilder.Class.Always(a => a.Table(GetTableName(a))),
ConventionBuilder.Id.When(a => a.Expect(i => ((PropertyInfo)i.Property.MemberInfo).PropertyType == typeof(Guid)),
c => c.GeneratedBy.Assigned()),
ConventionBuilder.Id.When(a => a.Expect(i => ((PropertyInfo)i.Property.MemberInfo).PropertyType == typeof(int)),
c => c.GeneratedBy.Identity()),
ConventionBuilder.HasMany.When(a => a.Expect(i => i.Member.GetCustomAttributes(typeof(PwnsAttribute), false).Any()),
c => c.Cascade.AllDeleteOrphan()),
ConventionBuilder.HasMany.When(a => a.Expect(i => RequiresCustomPropertyName(i.EntityType)),
c => c.Key.Column(GetCustomPropertyName(c.Relationship.EntityType))),
ConventionBuilder.Reference.When(a => a.Expect(i => RequiresCustomPropertyName(i.EntityType)),
c => c.Column(GetCustomPropertyName(c.EntityType)))
}).UseOverridesFromAssembly(_overrideAssembly));
}