public void SeederConfigurationTest()
{
var seederConfiguration = new SeederConfiguration();
seederConfiguration.Configure((c, b) =>
{
c.ConnectionString = "str";
c.CreateTags = false;
c.ClearDataBeforeSeed = false;
c.CreateUsers = false;
c.Database = "database";
c.DefaultCountSeed = 1000;
c.HideDetailsInfo = false;
c.RewriteIndexes = false;
c.TimeReportSec = 2;
b.AddInMemoryCollection(new KeyValuePair <string, string>[]
{
new("Database:ConnectionStrings:DefaultConnection", "DefaultConnection"),
new("Database:ConnectionStrings:Name", "Database"),
new("Database:RewriteIndexes", "true"),
new("Files:Path", "true"),
new("HideDetailsInfo", "true"),
new("ClearDataBeforeSeed", "true"),
new("CreateTags", "true"),
new("CreateUsers", "true"),
new("Destination", "fs"),
new("TimeReportSec", "1"),
new("DefaultCountSeed", "5000"),
});
});
public void EntitySeederSeedFromResource_RunsExtensionMethod_WhenCalled()
{
#region Setup
var dbSetHelperMock = new Mock <IDbSetHelper>();
dbSetHelperMock.Setup(helper => helper.AddOrUpdate(It.IsAny <DbSet <Product> >(), It.IsAny <Product>()));
var dbSetMock = new Mock <DbSet <Product> >();
SeederConfiguration.ResetConfiguration(assembly: typeof(SeederTests).GetTypeInfo().Assembly);
SeederConfiguration.DbSetHelper = dbSetHelperMock.Object;
#endregion
var results = dbSetMock.Object.SeedFromResource(nameof(Product));
dbSetHelperMock.Verify(helper => helper.AddOrUpdate(It.IsAny <DbSet <Product> >(), It.IsAny <Product>()), Times.Once);
Assert.True(results.Exists(product => product.Code == "ABCDE"));
var additionalMapping = new[]
{
new CsvColumnMapping <Product>("ExtraInformation", (product, extraInfo) => { product.Description = (string)extraInfo; })
};
results = dbSetMock.Object.SeedFromResource(nameof(Product), additionalMapping);
dbSetHelperMock.Verify(helper => helper.AddOrUpdate(It.IsAny <DbSet <Product> >(), It.IsAny <Product>()), Times.Exactly(2));
Assert.True(results.Exists(product => product.Description == "Extra Information"));
}
public FileUserSeed(SeederConfiguration configuration) : base(configuration)
{
CollectionName = "Users.json";
DefaultCountSeed = configuration.DefaultCountSeed;
Collection = FakeData.Users;
}
protected AbstractSeed(SeederConfiguration configuration)
{
_clearDbBeforeSeed = configuration.ClearDataBeforeSeed;
RewriteIndexes = configuration.RewriteIndexes;
ReportEverySec = configuration.TimeReportSec;
}
public FileTagSeed(SeederConfiguration configuration) : base(configuration)
{
CollectionName = "Tags.json";
DefaultCountSeed = configuration.DefaultCountSeed;
Collection = FakeData.Tags;
}
public FileProvider(SeederConfiguration configuration)
{
_configuration = configuration;
Collections = new List <ISeed>
{
new FileDiscountSeed(configuration),
new FileTagSeed(configuration),
new FileUserSeed(configuration),
new FileAllowedExternalUserSeed(configuration)
};
ActionWhenAborted += () =>
{
var fullName = Path.Combine(configuration.Path, "Discounts.json");
//for (var numTries = 0; numTries < 10; numTries++)
while (true)
{
try
{
FileDiscountSeed.ChangeSymbol(fullName);
Thread.Sleep(50);
break;
}
catch (IOException)
{
Thread.Sleep(150);
}
}
Console.WriteLine("Discounts seed aborted.");
};
}
private static Task Main(string[] args)
{
SetupLogger();
return(Parser
.Default
.ParseArguments <Options>(args)
.WithParsedAsync(async options =>
{
ValidateArguments(options);
Log.Logger.Information($"Data file path: {options.IndexDataFilePath}");
if (options.CreateIndexIfNotExists)
{
Log.Logger.Information($"Index creation body content: {options.IndexCreationBodyFilePath}");
}
var seederConfiguration = new SeederConfiguration
{
CreateIndexIfNotExists = options.CreateIndexIfNotExists,
DataFilePath = options.IndexDataFilePath,
CreateIndexRequestBodyContentFilePath = options.IndexCreationBodyFilePath
};
ElasticsearchConfiguration elasticConfiguration = GetElasticsearchConfiguration();
var seeder = new ElasticsearchSeeder(seederConfiguration, elasticConfiguration);
await seeder.SeedAsync();
}));
}
public ElasticsearchSeeder(
SeederConfiguration seederConfiguration,
ElasticsearchConfiguration elasticsearchConfiguration)
{
_seederConfiguration = seederConfiguration;
_elasticsearchConfiguration = elasticsearchConfiguration;
}
static void Main(string[] args)
{
CultureInfo.CurrentCulture = new CultureInfo("en-US");
var csvConfiguration = new CsvHelper.Configuration.CsvConfiguration(CultureInfo.CurrentCulture)
{
Delimiter = ",",
PrepareHeaderForMatch = (s, i) => s.TrimStart().TrimEnd(),
HasHeaderRecord = true,
SanitizeForInjection = true,
MissingFieldFound = null
};
var manifestConfiguration = new ManifestConfiguration
{
Format = "{delimiter}{resource}{delimiter}{extension}",
Delimiter = ".",
Extension = "csv",
ExtensionFieldName = "{extension}",
ResourceFieldName = "{resource}",
DelimiterFieldName = "{delimiter}"
};
SeederConfiguration.ResetConfiguration(csvConfiguration, manifestConfiguration, assembly: typeof(Program).GetTypeInfo().Assembly);
using (var context = new ProductsDbContext())
{
//context.Products.SeedDbSetIfEmpty(nameof(context.Products));
context.Suppliers.SeedFromResource(nameof(context.Suppliers));
context.SaveChanges();
}
}
public override void EnsureSeeded()
{
var csvConfig = new CsvConfiguration
{
Delimiter = "|",
SkipEmptyRecords = true,
TrimFields = true,
TrimHeaders = true,
WillThrowOnMissingField = false
};
SeederConfiguration.ResetConfiguration(csvConfig, null, typeof(SettingsContext).GetTypeInfo().Assembly);
Dockets.SeedDbSetIfEmpty($"{nameof(Dockets)}");
CentralRegistries.SeedDbSetIfEmpty($"{nameof(CentralRegistries)}");
EmrSystems.SeedDbSetIfEmpty($"{nameof(EmrSystems)}");
DatabaseProtocols.SeedDbSetIfEmpty($"{nameof(DatabaseProtocols)}");
RestProtocols.SeedDbSetIfEmpty($"{nameof(RestProtocols)}");
Resources.SeedDbSetIfEmpty($"{nameof(Resources)}");
var ex = Extracts.Where(e => e.EmrSystemId.ToString() == "a62216ee-0e85-11e8-ba89-0ed5f89f718b" ||
e.EmrSystemId.ToString() == "a6221856-0e85-11e8-ba89-0ed5f89f718b" ||
e.EmrSystemId.ToString() == "a6221857-0e85-11e8-ba89-0ed5f89f718b"
);
Extracts.RemoveRange(ex);
Extracts.SeedFromResource($"{nameof(Extracts)}");
SaveChanges();
}
public CherrySeeder(Action <ISeederConfigurationBuilder> configurationExpression)
{
_entityMetadataDict = new Dictionary <Type, EntityMetadata>();
_idMappingProvider = new IdMappingProvider();
var configBuilder = new SeederConfigurationBuilder();
configurationExpression(configBuilder);
_configuration = configBuilder.Build();
_objectListTransformation = new ObjectListTransformation(
new ObjectTransformation.ObjectTransformation(
new PropertyHandler(
_idMappingProvider,
new TypeTransformationProvider(_configuration.TypeTransformations)
)
)
);
foreach (var entitySetting in _configuration.EntitySettings)
{
_entityMetadataDict.Add(entitySetting.EntityType, new EntityMetadata
{
EntityType = entitySetting.EntityType,
EntitySetting = entitySetting
});
}
}
public FileAllowedExternalUserSeed(SeederConfiguration configuration) : base(configuration)
{
CollectionName = "AllowedExternalUsers.json";
DefaultCountSeed = configuration.DefaultCountSeed;
Collection = FakeData.AllowedExternalUsers;
}
public MongoDiscountSeed(SeederConfiguration configuration) : base(configuration)
{
CollectionName = "Discounts";
IndexModels = DbDiscountIndexes.GetIndexes;
DefaultCountSeed = configuration.DefaultCountSeed;
var client = new MongoClient(configuration.ConnectionString);
var db = client.GetDatabase(configuration.Database);
Collection = db.GetCollection <DbDiscount>(CollectionName);
}
public MongoTagSeed(SeederConfiguration configuration) : base(configuration)
{
CollectionName = "Tags";
IndexModels = DbTagIndexes.GetIndexes;
var client = new MongoClient(configuration.ConnectionString);
var db = client.GetDatabase(configuration.Database);
Collection = db.GetCollection <DbTag>(CollectionName);
_discounts = db.GetCollection <DbDiscount>("Discounts");
}
public MongoExternalUserSeed(SeederConfiguration configuration) : base(configuration)
{
CollectionName = "AllowedExternalUsers";
IndexModels = DbAllowedExternalUserIndexes.GetIndexes;
DefaultCountSeed = configuration.DefaultCountSeed;
var client = new MongoClient(configuration.ConnectionString);
var db = client.GetDatabase(configuration.Database);
Collection = db.GetCollection <DbAllowedExternalUser>(CollectionName);
}
public MongoProvider(SeederConfiguration configuration)
{
MongoDbConvention.SetCamelCaseElementNameConvention();
Collections = new List <ISeed>
{
new MongoDiscountSeed(configuration),
new MongoTagSeed(configuration),
new MongoUserSeed(configuration),
new MongoExternalUserSeed(configuration)
};
}
private void DetailsInfoConfiguration(SeederConfiguration seederConfiguration)
{
Console.WriteLine($"ConnectionString: {seederConfiguration.ConnectionString}");
Console.WriteLine($"Database: {seederConfiguration.Database}");
Console.WriteLine($"Path: {seederConfiguration.Path}");
Console.WriteLine($"Destination: {seederConfiguration.Destination}");
Console.WriteLine($"ClearDataBeforeSeed: {seederConfiguration.ClearDataBeforeSeed}");
Console.WriteLine($"RewriteIndexes: {seederConfiguration.RewriteIndexes}");
Console.WriteLine($"DefaultCountSeed: {seederConfiguration.DefaultCountSeed}");
Console.WriteLine($"TimeReportSec: {seederConfiguration.TimeReportSec}");
Console.WriteLine($"CreateTags: {seederConfiguration.CreateTags}");
Console.WriteLine($"CreateUsers: {seederConfiguration.CreateUsers}");
}
public override void EnsureSeeded()
{
var csvConfig = new Configuration()
{
Delimiter = "|"
};
SeederConfiguration.ResetConfiguration(csvConfig, null, typeof(HtsContext).GetTypeInfo().Assembly);
// MasterFacilities.SeedDbSetIfEmpty($"{nameof(MasterFacility)}");
Dockets.SeedDbSetIfEmpty($"{nameof(Docket)}");
SaveChanges();
Subscribers.SeedDbSetIfEmpty($"{nameof(Subscriber)}");
SaveChanges();
}
public override void EnsureSeeded()
{
var csvConfig = new CsvConfiguration
{
Delimiter = "|",
SkipEmptyRecords = true,
TrimFields = true,
TrimHeaders = true,
WillThrowOnMissingField = false
};
SeederConfiguration.ResetConfiguration(csvConfig, null, typeof(ExtractsContext).GetTypeInfo().Assembly);
Validator.RemoveRange(Validator);
Validator.SeedFromResource($"{nameof(Validator)}");
SaveChanges();
}
public override void EnsureSeeded()
{
var csvConfig = new CsvConfiguration
{
SkipEmptyRecords = true,
TrimFields = true,
TrimHeaders = true,
WillThrowOnMissingField = false
};
SeederConfiguration.ResetConfiguration(csvConfig, null, typeof(SettingsContext).GetTypeInfo().Assembly);
TestCars.SeedDbSetIfEmpty($"{nameof(TestCar)}");
TestModels.SeedDbSetIfEmpty($"{nameof(TestModel)}");
base.EnsureSeeded();
}
public override void EnsureSeeded()
{
var csvConfig = new CsvConfiguration
{
Delimiter = "|",
SkipEmptyRecords = true,
TrimFields = true,
TrimHeaders = true,
WillThrowOnMissingField = false
};
SeederConfiguration.ResetConfiguration(csvConfig, null, typeof(DwhDashboardContext).GetTypeInfo().Assembly);
Impersonators.SeedDbSetIfEmpty($"{nameof(Impersonator)}");
Organizations.SeedDbSetIfEmpty($"{nameof(Organization)}");
Users.SeedDbSetIfEmpty($"{nameof(User)}");
ViewConfigs.SeedDbSetIfEmpty($"{nameof(ViewConfig)}");
SaveChanges();
}
public void EntitySeederSeedFromResource_ThrowsException_WhenCalled()
{
#region Setup
var dbSetHelperMock = new Mock <IDbSetHelper>();
dbSetHelperMock.Setup(helper => helper.AddOrUpdate(It.IsAny <DbSet <Product> >(), It.IsAny <Product>()))
.Throws(new Exception());
var dbSetMock = new Mock <DbSet <Product> >();
SeederConfiguration.ResetConfiguration(assembly: typeof(SeederTests).GetTypeInfo().Assembly);
SeederConfiguration.DbSetHelper = dbSetHelperMock.Object;
#endregion
var exception = Assert.Throws <Exception>(() => dbSetMock.Object.SeedFromResource(nameof(Product)));
dbSetHelperMock.Verify(helper => helper.AddOrUpdate(It.IsAny <DbSet <Product> >(), It.IsAny <Product>()), Times.Once);
Assert.Contains("Error Seeding DbSet<Product>", exception.Message);
}
public override void EnsureSeeded()
{
var csvConfig = new CsvConfiguration
{
Delimiter = "|",
SkipEmptyRecords = true,
TrimFields = true,
TrimHeaders = true,
WillThrowOnMissingField = false
};
SeederConfiguration.ResetConfiguration(csvConfig, null, typeof(CbsContext).GetTypeInfo().Assembly);
MasterFacilities.SeedDbSetIfEmpty($"{nameof(MasterFacility)}");
Dockets.SeedDbSetIfEmpty($"{nameof(Docket)}");
SaveChanges();
Subscribers.SeedDbSetIfEmpty($"{nameof(Subscriber)}");
SaveChanges();
}
public override void EnsureSeeded()
{
var csvConfig = new CsvConfiguration
{
Delimiter = "|",
SkipEmptyRecords = true,
TrimFields = true,
TrimHeaders = true,
WillThrowOnMissingField = false
};
SeederConfiguration.ResetConfiguration(csvConfig, null, typeof(SettingsContext).GetTypeInfo().Assembly);
Dockets.SeedDbSetIfEmpty($"{nameof(Dockets)}");
CentralRegistries.SeedDbSetIfEmpty($"{nameof(CentralRegistries)}");
EmrSystems.SeedDbSetIfEmpty($"{nameof(EmrSystems)}");
DatabaseProtocols.SeedDbSetIfEmpty($"{nameof(DatabaseProtocols)}");
Extracts.SeedDbSetIfEmpty($"{nameof(Extracts)}");
SaveChanges();
}
public void EntitySeederSeedDbSetIfEmpty_RunsSeedFromResource_WhenCalled()
{
#region Setup
var dbSetHelperMock = new Mock <IDbSetHelper>();
dbSetHelperMock.Setup(helper => helper.AddOrUpdate(It.IsAny <DbSet <Product> >(), It.IsAny <Product>()));
dbSetHelperMock.Setup(helper => helper.Any(It.IsAny <DbSet <Product> >())).Returns(false);
var dbSetMock = new Mock <DbSet <Product> >();
const string verifiableCode = "ABCDE";
SeederConfiguration.ResetConfiguration(assembly: typeof(SeederTests).GetTypeInfo().Assembly);
SeederConfiguration.DbSetHelper = dbSetHelperMock.Object;
#endregion
var results = dbSetMock.Object.SeedDbSetIfEmpty(nameof(Product));
Assert.True(results.Exists(product => product.Code == verifiableCode));
}
public void EntitySeederSeedFromResource_ThrowsException_WhenCalledWithNullAssembly()
{
#region Setup
var dbSetHelperMock = new Mock <IDbSetHelper>();
dbSetHelperMock.Setup(helper => helper.AddOrUpdate(It.IsAny <DbSet <Product> >(), It.IsAny <Product>()));
var dbSetMock = new Mock <DbSet <Product> >();
SeederConfiguration.ResetConfiguration();
SeederConfiguration.DbSetHelper = dbSetHelperMock.Object;
#endregion
const string invalidManifestResourceName = "InvalidManifestName";
var exception = Assert.Throws <Exception>(() => dbSetMock.Object.SeedFromResource(invalidManifestResourceName));
dbSetHelperMock.Verify(helper => helper.AddOrUpdate(It.IsAny <DbSet <Product> >(), It.IsAny <Product>()), Times.Never);
Assert.Contains($"Invalid assembly or manifest resource name: {invalidManifestResourceName}", exception.Message);
}
public FileDiscountSeed(SeederConfiguration configuration) : base(configuration)
{
CollectionName = "Discounts.json";
DefaultCountSeed = configuration.DefaultCountSeed;
}
private void OnExecute()
{
SeederConfiguration seederConfiguration;
try
{
seederConfiguration = new SeederConfiguration();
seederConfiguration.Configure((c, b) =>
{
c.HideDetailsInfo = HideDetailsInfo;
c.ConnectionString = ConnectionString;
c.Database = Database;
c.ClearDataBeforeSeed = ClearDataBeforeSeed;
c.RewriteIndexes = RewriteIndexes;
c.DefaultCountSeed = DefaultCountSeed;
c.TimeReportSec = TimeReportSec;
c.CreateTags = CreateTags;
c.CreateUsers = CreateUsers;
c.Path = Path;
c.Destination = Destination;
});
}
catch (Exception e)
{
Console.WriteLine($"Error configuration file: {e.Message}");
return;
}
if (!seederConfiguration.HideDetailsInfo)
{
Console.WriteLine(Environment.NewLine);
DetailsInfoConfiguration(seederConfiguration);
}
Console.WriteLine(new string('*', 30));
_stateExecutionConfiguration = new StateExecutionConfiguration();
Task.Run(async() =>
{
var seeder = new SeedManager(seederConfiguration);
await seeder.Seed(_stateExecutionConfiguration);
_stateExecutionConfiguration.Success();
});
Console.WriteLine("Press any key to Abort.");
Console.WriteLine(new string('*', 30));
Console.ReadKey();
if (!_stateExecutionConfiguration.Aborted)
{
return;
}
Console.WriteLine("Execution aborted. Please wait.");
if (_stateExecutionConfiguration.ExecutionActionsAfterAbort == null)
{
return;
}
foreach (var action in _stateExecutionConfiguration.ExecutionActionsAfterAbort.GetInvocationList())
{
action.DynamicInvoke();
}
}
protected FileAbstractSeed(SeederConfiguration configuration) : base(configuration)
{
_configuration = configuration;
}
protected MongoAbstractSeed(SeederConfiguration configuration) : base(configuration)
{
}
