private static FluentMappingBuilder RegisterThemeAggregates(this FluentMappingBuilder builder)
{
builder.Entity <ThemeAggregates::Theme>()
.HasSchemaName(ThemeAggregatesSchema)
.HasPrimaryKey(x => x.Id);
builder.Entity <ThemeAggregates::Theme.InvalidCategory>()
.HasSchemaName(ThemeAggregatesSchema)
.HasPrimaryKey(x => new { x.ThemeId, x.CategoryId });
builder.Entity <ThemeAggregates::Order>()
.HasSchemaName(ThemeAggregatesSchema)
.HasPrimaryKey(x => x.Id);
builder.Entity <ThemeAggregates::Order.OrderTheme>()
.HasSchemaName(ThemeAggregatesSchema)
.HasPrimaryKey(x => new { x.OrderId, x.ThemeId });
builder.Entity <ThemeAggregates::Project>()
.HasSchemaName(ThemeAggregatesSchema)
.HasPrimaryKey(x => x.Id);
builder.Entity <ThemeAggregates::Project.ProjectDefaultTheme>()
.HasSchemaName(ThemeAggregatesSchema)
.HasPrimaryKey(x => new { x.ProjectId, x.ThemeId });
return(builder);
}
public override void Map(FluentMappingBuilder builder)
{
builder.Entity <UserAttribute>().HasTableName(nameof(UserAttribute))
.HasSchemaName(TableSchemaConst.Auth)
.HasIdentity(x => x.Id)
.HasPrimaryKey(x => x.Id);
}
private static FluentMappingBuilder RegisterFirmAggregates(this FluentMappingBuilder builder)
{
builder.Entity <FirmAggregates::Firm>()
.HasSchemaName(FirmAggregatesSchema)
.HasPrimaryKey(x => x.Id);
builder.Entity <FirmAggregates::Firm.CategoryPurchase>()
.HasSchemaName(FirmAggregatesSchema)
.HasIndex(x => new { x.FirmId, x.Begin, x.End, x.CategoryId }, x => new { x.Scope });
builder.Entity <FirmAggregates::Order>()
.HasSchemaName(FirmAggregatesSchema)
.HasPrimaryKey(x => x.Id)
.HasIndex(x => new { x.FirmId, x.Begin, x.End }, x => new { x.Id, x.Scope });
builder.Entity <FirmAggregates::Order.FirmOrganiationUnitMismatch>()
.HasSchemaName(FirmAggregatesSchema);
builder.Entity <FirmAggregates::Order.InvalidFirm>()
.HasSchemaName(FirmAggregatesSchema);
builder.Entity <FirmAggregates::Order.PartnerPosition>()
.HasSchemaName(FirmAggregatesSchema);
builder.Entity <FirmAggregates::Order.FmcgCutoutPosition>()
.HasSchemaName(FirmAggregatesSchema);
return(builder);
}
private static FluentMappingBuilder RegisterFirmAggregates(this FluentMappingBuilder builder)
{
builder.Entity <FirmAggregates::Firm>()
.HasSchemaName(FirmAggregatesSchema)
.HasPrimaryKey(x => x.Id);
builder.Entity <FirmAggregates::Firm.CategoryPurchase>()
.HasSchemaName(FirmAggregatesSchema)
.HasPrimaryKey(x => new { x.FirmId, x.Start, x.End, x.Scope, x.CategoryId });
builder.Entity <FirmAggregates::Order>()
.HasSchemaName(FirmAggregatesSchema)
.HasPrimaryKey(x => x.Id)
.HasIndex(x => new { x.Start, x.End }, x => x.Scope);
builder.Entity <FirmAggregates::Order.FirmOrganizationUnitMismatch>()
.HasSchemaName(FirmAggregatesSchema)
.HasPrimaryKey(x => x.OrderId);
builder.Entity <FirmAggregates::Order.InvalidFirm>()
.HasSchemaName(FirmAggregatesSchema)
.HasPrimaryKey(x => x.OrderId);
builder.Entity <FirmAggregates::Order.PartnerPosition>()
.HasSchemaName(FirmAggregatesSchema)
.HasPrimaryKey(x => new { x.DestinationFirmAddressId, x.OrderPositionId })
.HasIndex(x => x.OrderId, x => x.DestinationFirmId)
.HasIndex(x => x.DestinationFirmId, x => x.OrderId);
builder.Entity <FirmAggregates::Order.PremiumPartnerPosition>()
.HasSchemaName(FirmAggregatesSchema)
.HasPrimaryKey(x => x.OrderId);
builder.Entity <FirmAggregates::Order.FmcgCutoutPosition>()
.HasSchemaName(FirmAggregatesSchema)
.HasPrimaryKey(x => x.OrderId);
builder.Entity <FirmAggregates::Order.AddressAdvertisementNonOnTheMap>()
.HasSchemaName(FirmAggregatesSchema)
.HasPrimaryKey(x => new { x.OrderId, x.OrderPositionId, x.PositionId, x.AddressId });
// таблица маленькая, нет PK
builder.Entity <FirmAggregates::Order.MissingValidPartnerFirmAddresses>()
.HasSchemaName(FirmAggregatesSchema)
.HasIndex(x => x.OrderId);
builder.Entity <FirmAggregates::Order.InvalidFirmAddress>()
.HasSchemaName(FirmAggregatesSchema)
.HasPrimaryKey(x => new { x.OrderId, x.OrderPositionId, x.PositionId, x.FirmAddressId });
builder.Entity <FirmAggregates::Order.InvalidCategory>()
.HasSchemaName(FirmAggregatesSchema)
.HasPrimaryKey(x => new { x.OrderId, x.OrderPositionId, x.PositionId, x.CategoryId });
// таблица маленькая, можно обойтись без индексов
builder.Entity <FirmAggregates::Order.CategoryNotBelongsToAddress>()
.HasSchemaName(FirmAggregatesSchema);
return(builder);
}
public static FluentMappingBuilder ApplyMappingBuilder <TEntity>(this FluentMappingBuilder fluentMappingBuilder,
EntityMapBuilder <TEntity> entityTypeBuilder)
{
entityTypeBuilder.Map(fluentMappingBuilder);
return(fluentMappingBuilder);
}
/// <summary>
/// Add and configure any of the middleware
/// </summary>
/// <param name="services">Collection of service descriptors</param>
/// <param name="configuration">Configuration of the application</param>
public void ConfigureServices(IServiceCollection services, IConfiguration configuration)
{
var mappingBuilder = new FluentMappingBuilder(NopDataConnection.AdditionalSchema);
//find database mapping configuration by other assemblies
var typeFinder = new AppDomainTypeFinder();
var typeConfigurations = typeFinder.FindClassesOfType <IMappingConfiguration>().ToList();
foreach (var typeConfiguration in typeConfigurations)
{
var mappingConfiguration = (IMappingConfiguration)Activator.CreateInstance(typeConfiguration);
mappingConfiguration.ApplyConfiguration(mappingBuilder);
}
//further actions are performed only when the database is installed
if (!DataSettingsManager.DatabaseIsInstalled)
{
return;
}
DataConnection.DefaultSettings = Singleton <DataSettings> .Instance;
MappingSchema.Default.SetConvertExpression <string, Guid>(strGuid => new Guid(strGuid));
services
// add common FluentMigrator services
.AddFluentMigratorCore()
.ConfigureRunner(rb => rb.SetServer()
.WithVersionTable(new MigrationVersionInfo())
// define the assembly containing the migrations
.ScanIn(typeConfigurations.Select(p => p.Assembly).Distinct().ToArray()).For.Migrations());
}
public BaseSqlJobQueuePurger(IJobQueueDataConnectionFactory jobQueueConnectionFactory,
ISqlDbJobQueueTableConfiguration tableConfig)
{
_jobQueueConnectionFactory = jobQueueConnectionFactory;
_mappingSchema = Mapping.BuildMappingSchema(tableConfig);
}
public override void Map(FluentMappingBuilder builder)
{
builder.Entity <User>()
.HasTableName(nameof(User))
.HasSchemaName(TableSchemaConst.Auth)
.HasIdentity(x => x.Id)
.HasPrimaryKey(x => x.Id)
.Association(e => e.UserInfo, (user, userInfo) => user.Id == userInfo.Id)
.Association(e => e.CreatedBy, (user, createdBy) => user.CreatedById == createdBy.Id)
.Association(e => e.CreatedUsers, (user, createdUsers) => user.Id == createdUsers.Id)
.Association(e => e.UpdatedBy, (user, updatedBy) => user.UpdatedById == updatedBy.Id)
.Association(e => e.UpdatedUsers, (user, updatedUsers) => user.Id == updatedUsers.Id)
.Association(e => e.UserRoles, (user, userRoles) => user.Id == userRoles.UserId)
.Association(e => e.CreatedRoles, (user, role) => user.Id == role.CreatedById)
.Association(e => e.UpdatedRoles, (user, role) => user.Id == role.UpdatedById)
.Association(e => e.Status, (user, status) => user.StatusId == status.Id)
.Association(e => e.CreatedAuthorizationPolicies,
(user, authorizationPolicy) => user.Id == authorizationPolicy.CreatedById)
.Association(e => e.UpdatedAuthorizationPolicies,
(user, authorizationPolicy) => user.Id == authorizationPolicy.UpdatedById)
.Association(e => e.UserAuthorizationPolicies,
(user, userAuthorizationPolicy) => user.Id == userAuthorizationPolicy.UserId)
.Association(e => e.GrantedRoleAuthorizationPolicies,
(user, roleAuthorizationPolicy) => user.Id == roleAuthorizationPolicy.GrantedById);
}
public BudgetLogMappingSchema()
{
FluentMappingBuilder b = GetFluentMappingBuilder();
Configure <Transaction>(b, "Transactions");
Configure <Forecast>(b, "Forecasts");
}
private static FluentMappingBuilder RegisterAdvertisementAggregates(this FluentMappingBuilder builder)
{
builder.Entity <AdvertisementAggregates::Order>()
.HasSchemaName(AdvertisementAggregatesSchema)
.HasPrimaryKey(x => x.Id);
builder.Entity <AdvertisementAggregates::Order.MissingAdvertisementReference>()
.HasSchemaName(AdvertisementAggregatesSchema)
.HasPrimaryKey(x => new { x.OrderId, x.OrderPositionId, x.CompositePositionId, x.PositionId })
.HasIndex(x => x.AdvertisementIsOptional);
builder.Entity <AdvertisementAggregates::Order.MissingOrderPositionAdvertisement>()
.HasSchemaName(AdvertisementAggregatesSchema)
.HasPrimaryKey(x => new { x.OrderId, x.OrderPositionId, x.PositionId });
builder.Entity <AdvertisementAggregates::Order.AdvertisementFailedReview>()
.HasSchemaName(AdvertisementAggregatesSchema)
.HasPrimaryKey(x => new { x.OrderId, x.AdvertisementId });
// таблица маленькая, можно обойтись без индексов
builder.Entity <AdvertisementAggregates::Order.AdvertisementNotBelongToFirm>()
.HasSchemaName(AdvertisementAggregatesSchema);
return(builder);
}
/// <summary>
/// Apply this mapping configuration
/// </summary>
/// <param name="modelBuilder">The builder being used to construct the model for the database context</param>
public void ApplyConfiguration(FluentMappingBuilder modelBuilder)
{
var builder = modelBuilder.Entity <TEntity>();
builder.HasPrimaryKey(entity => entity.Id).HasIdentity(entity => entity.Id);
Configure(builder);
}
public override void Map(FluentMappingBuilder builder)
{
builder.Entity <RoleClaim>().HasTableName(nameof(RoleClaim))
.HasSchemaName(TableSchemaConst.Auth)
.HasIdentity(x => x.Id)
.HasPrimaryKey(x => x.Id)
.Association(c => c.Role, (roleClaim, role) => roleClaim.RoleId == role.Id);
}
public override void Map(FluentMappingBuilder builder)
{
builder.Entity <UserClaim>().HasTableName(nameof(UserClaim))
.HasSchemaName(TableSchemaConst.Auth)
.HasIdentity(x => x.Id)
.HasPrimaryKey(x => x.Id)
.Association(c => c.User, (userClaim, user) => userClaim.UserId == user.Id);
}
private static FluentMappingBuilder RegisterWebApp(this FluentMappingBuilder builder)
{
builder.Entity <Lock>()
.HasSchemaName(WebAppSchema)
.HasPrimaryKey(x => x.Id);
return(builder);
}
public override void Map(FluentMappingBuilder builder)
{
builder.Entity <Shortcut>()
.HasTableName(nameof(Shortcut))
.HasSchemaName(TableSchemaConst.Dbo)
.HasIdentity(x => x.Id)
.HasPrimaryKey(x => x.Id);
}
public BaseSqlJobQueueAdder(IJobQueueDataConnectionFactory jobQueueDataConnectionFactory,
IJobAdderQueueTableResolver tableResolver)
{
_jobQueueConnectionFactory = jobQueueDataConnectionFactory;
_mappingSchema = MappingSchema.Default.GetFluentMappingBuilder();
_tableResolver = tableResolver;
}
public override void Map(FluentMappingBuilder builder)
{
builder.Entity <Status>().HasTableName(nameof(Status))
.HasSchemaName(TableSchemaConst.Auth)
.HasPrimaryKey(x => x.Id)
.HasIdentity(x => x.Id)
.Association(c => c.Users, (status, users) => status.Id == users.StatusId);
}
private static FluentMappingBuilder RegisterSystemAggregates(this FluentMappingBuilder builder)
{
builder.Entity <SystemAggregates::SystemStatus>()
.HasSchemaName(SystemAggregatesSchema)
.HasPrimaryKey(x => x.Id);
return(builder);
}
protected SqlServerDataConnection(LinqToDbConnectionOptions <CaminoDataConnection> options) : base(options)
{
var mappingSchema = new MappingSchema();
FluentMapBuilder = mappingSchema.GetFluentMappingBuilder();
AddMappingSchema(mappingSchema);
OnMappingSchemaCreating();
}
static void MapAa(FluentMappingBuilder fb)
{
fb.Entity <Aa>()
.HasTableName("Aa")
.Ignore(x => x.NotInDb)
.Property(x => x.Id).IsPrimaryKey()
.Property(x => x.Name).HasColumnName("Name");
}
private static FluentMappingBuilder RegisterEvents(this FluentMappingBuilder builder)
{
builder.Entity <EventRecord>()
.HasSchemaName(EventsSchema)
.HasPrimaryKey(x => x.Id)
.HasIdentity(x => x.Id);
return(builder);
}
public static FluentMappingBuilder ApplyMappingBuilder <T>(this FluentMappingBuilder fluentMappingBuilder)
where T : EntityMapBuilder, new()
{
var entityTypeBuilder = new T();
entityTypeBuilder.Map(fluentMappingBuilder);
return(fluentMappingBuilder);
}
public override void Map(FluentMappingBuilder builder)
{
builder.Entity <UserPhoto>()
.HasTableName(nameof(UserPhoto))
.HasSchemaName(TableSchemaConst.Dbo)
.HasIdentity(x => x.Id)
.HasPrimaryKey(x => x.Id)
.Association(x => x.UserPhotoType, (userPhoto, type) => userPhoto.TypeId == type.Id);
}
public override void Map(FluentMappingBuilder builder)
{
builder.Entity <Country>()
.HasTableName(nameof(Country))
.HasSchemaName(TableSchemaConst.Auth)
.HasIdentity(x => x.Id)
.HasPrimaryKey(x => x.Id)
.Association(c => c.UserInfos, (country, userInfos) => country.Id == userInfos.CountryId);
}
public override void Map(FluentMappingBuilder builder)
{
builder.Entity <ProductPrice>()
.HasTableName(nameof(ProductPrice))
.HasSchemaName(TableSchemaConst.Dbo)
.HasPrimaryKey(x => x.Id)
.HasIdentity(x => x.Id)
.Association(x => x.Product,
(productPrice, product) => productPrice.ProductId == product.Id);
}
public override void Map(FluentMappingBuilder builder)
{
builder.Entity <ProductAttribute>()
.HasTableName(nameof(ProductAttribute))
.HasSchemaName(TableSchemaConst.Dbo)
.HasIdentity(x => x.Id)
.HasPrimaryKey(x => x.Id)
.Association(x => x.ProductAttributeRelations,
(attribute, relation) => attribute.Id == relation.ProductAttributeId);
}
public BaseSqlJobQueueManager(IJobQueueDataConnectionFactory jobQueueConnectionFactory,
ISqlDbJobQueueTableConfiguration jobQueueTableConfiguration, IJobTypeResolver typeResolver)
{
_jobQueueConnectionFactory = jobQueueConnectionFactory;
_jobQueueTableConfiguration = jobQueueTableConfiguration;
_typeResolver = typeResolver;
_mappingSchema = MappingSchema.Default.GetFluentMappingBuilder();
}
public override void Map(FluentMappingBuilder builder)
{
builder.Entity <UserInfo>()
.HasTableName(nameof(UserInfo))
.HasSchemaName(TableSchemaConst.Auth)
.HasPrimaryKey(x => x.Id)
.Association(e => e.User, (userInfo, user) => userInfo.Id == user.Id)
.Association(e => e.Gender, (user, gender) => user.GenderId == gender.Id)
.Association(e => e.Country, (user, country) => user.CountryId == country.Id);
}
public override void Map(FluentMappingBuilder builder)
{
builder.Entity <Farm>()
.HasTableName(nameof(Farm))
.HasSchemaName(TableSchemaConst.Dbo)
.HasIdentity(x => x.Id)
.HasPrimaryKey(x => x.Id)
.Association(x => x.FarmType,
(farm, farmType) => farm.FarmTypeId == farmType.Id);
}
public override void Map(FluentMappingBuilder builder)
{
builder
.Entity <Gender>()
.HasTableName(nameof(Gender))
.HasSchemaName(TableSchemaConst.Auth)
.HasIdentity(x => x.Id)
.HasPrimaryKey(x => x.Id)
.Association(x => x.UserInfos, (gender, userInfo) => gender.Id == userInfo.GenderId);
}
