/// <summary>
/// Creates and seeds a new part.
/// </summary>
/// <param name="item">The item this part should belong to.</param>
/// <param name="roleId">The optional part role ID.</param>
/// <param name="factory">The part seeder factory. This is used
/// for layer parts, which need to seed a set of fragments.</param>
/// <returns>A new part.</returns>
/// <exception cref="ArgumentNullException">item or factory</exception>
public override IPart GetPart(IItem item, string roleId,
PartSeederFactory factory)
{
if (item == null)
{
throw new ArgumentNullException(nameof(item));
}
if (factory == null)
{
throw new ArgumentNullException(nameof(factory));
}
MsPlacePart part = new Faker <MsPlacePart>()
.RuleFor(p => p.Area,
f => f.PickRandom("France", "Germany", "Italy"))
.RuleFor(p => p.Address, f => $"{f.Lorem.Word()}, {f.Lorem.Word()}")
.RuleFor(p => p.City, f => f.Address.City())
.RuleFor(p => p.Site, f => f.PickRandom("A library", "A monastery"))
.RuleFor(p => p.Subscriber, f => f.Lorem.Word())
.RuleFor(p => p.SubscriptionLoc, f =>
new MsLocation
{
N = (short)f.Random.Number(20, 60),
S = f.Random.Bool() ?
"v" : "r",
L = (short)f.Random.Number(1, 20)
})
.RuleFor(p => p.Sources, SeederHelper.GetDocReferences(1, 3))
.Generate();
SetPartMetadata(part, roleId, item);
return(part);
}
/// <summary>
/// Creates and seeds a new part.
/// </summary>
/// <param name="item">The item this part should belong to.</param>
/// <param name="roleId">The optional part role ID.</param>
/// <param name="factory">The part seeder factory. This is used
/// for layer parts, which need to seed a set of fragments.</param>
/// <returns>A new part.</returns>
/// <exception cref="ArgumentNullException">item or factory</exception>
public override IPart GetPart(IItem item, string roleId,
PartSeederFactory factory)
{
if (item == null)
{
throw new ArgumentNullException(nameof(item));
}
if (factory == null)
{
throw new ArgumentNullException(nameof(factory));
}
CorrExchangesPart part = new CorrExchangesPart();
SetPartMetadata(part, roleId, item);
for (int n = 1; n <= Randomizer.Seed.Next(1, 3 + 1); n++)
{
part.Exchanges.Add(new Faker <CorrExchange>()
.RuleFor(e => e.IsDubious, f => f.Random.Bool(0.3f))
.RuleFor(e => e.IsIndirect, f => f.Random.Bool())
.RuleFor(e => e.IsFromParticipant, f => f.Random.Bool())
.RuleFor(e => e.Chronotopes,
new List <Chronotope> {
SeederHelper.GetChronotope("from", 1200)
})
.RuleFor(e => e.Participants, SeederHelper.GetDecoratedIds(1, 2))
.RuleFor(e => e.Sources, SeederHelper.GetDocReferences(1, 3))
.RuleFor(e => e.Attachments, SeederHelper.GetAttachments(1, 3))
.Generate());
}
return(part);
}
/// <summary>
/// Creates and seeds a new part.
/// </summary>
/// <param name="item">The item this part should belong to.</param>
/// <param name="roleId">The optional part role ID.</param>
/// <param name="factory">The part seeder factory. This is used
/// for layer parts, which need to seed a set of fragments.</param>
/// <returns>A new part.</returns>
/// <exception cref="ArgumentNullException">item or factory</exception>
public override IPart GetPart(IItem item, string roleId,
PartSeederFactory factory)
{
if (item == null)
{
throw new ArgumentNullException(nameof(item));
}
if (factory == null)
{
throw new ArgumentNullException(nameof(factory));
}
PersonWorksPart part = new PersonWorksPart();
SetPartMetadata(part, roleId, item);
string[] languages = new[] { "eng", "ita", "fra", "deu", "spa" };
for (int n = 1; n <= Randomizer.Seed.Next(1, 3 + 1); n++)
{
part.Works.Add(new Faker <PersonWork>()
.RuleFor(a => a.Language, f => f.PickRandom(languages))
.RuleFor(a => a.IsDubious, f => f.Random.Bool(0.2f))
.RuleFor(a => a.IsLost, f => f.Random.Bool(0.2f))
.RuleFor(a => a.Genre, f => f.Lorem.Word())
.RuleFor(a => a.Titles, f => new List <string>(new[] { f.Lorem.Sentence() }))
.RuleFor(a => a.Chronotopes, SeederHelper.GetChronotopes(1, 3))
.RuleFor(a => a.References, SeederHelper.GetDocReferences(1, 3))
.RuleFor(a => a.Note,
f => f.Random.Bool(0.2f)? f.Lorem.Sentence() : null)
.Generate());
}
return(part);
}
/// <summary>
/// Creates and seeds a new part.
/// </summary>
/// <param name="item">The item this part should belong to.</param>
/// <param name="roleId">The optional part role ID.</param>
/// <param name="factory">The part seeder factory. This is used
/// for layer parts, which need to seed a set of fragments.</param>
/// <returns>A new part.</returns>
/// <exception cref="ArgumentNullException">item or factory</exception>
public override IPart GetPart(IItem item, string roleId,
PartSeederFactory factory)
{
if (item == null)
{
throw new ArgumentNullException(nameof(item));
}
if (factory == null)
{
throw new ArgumentNullException(nameof(factory));
}
CorrPseudonymsPart part = new CorrPseudonymsPart();
SetPartMetadata(part, roleId, item);
part.Pseudonyms.Add(new Faker <CorrPseudonym>()
.RuleFor(p => p.Language, f => f.PickRandom("lat", "ita"))
.RuleFor(p => p.Value, f => f.Lorem.Word())
.RuleFor(p => p.IsAuthor, f => f.Random.Bool())
.RuleFor(p => p.Sources, SeederHelper.GetDocReferences(1, 3))
.Generate());
return(part);
}
/// <summary>
/// Creates and seeds a new part.
/// </summary>
/// <param name="item">The item this part should belong to.</param>
/// <param name="roleId">The optional part role ID.</param>
/// <param name="factory">The part seeder factory. This is used
/// for layer parts, which need to seed a set of fragments.</param>
/// <returns>A new part.</returns>
/// <exception cref="ArgumentNullException">item or factory</exception>
public override IPart GetPart(IItem item, string roleId,
PartSeederFactory factory)
{
if (item == null)
{
throw new ArgumentNullException(nameof(item));
}
if (factory == null)
{
throw new ArgumentNullException(nameof(factory));
}
MsWatermarksPart part = new MsWatermarksPart();
SetPartMetadata(part, roleId, item);
for (int n = 1; n <= Randomizer.Seed.Next(1, 3 + 1); n++)
{
part.Watermarks.Add(new Faker <MsWatermark>()
.RuleFor(w => w.Subject, f => f.Lorem.Word())
.RuleFor(w => w.SimilarityRank, f => f.Random.Short(1, 5))
.RuleFor(w => w.Description, f => f.Lorem.Sentence())
.RuleFor(w => w.Place, f => f.Lorem.Word())
.RuleFor(w => w.Date, HistoricalDate.Parse($"{1200 + n} AD"))
.RuleFor(w => w.ExternalIds, SeederHelper.GetExternalIds(1, 3))
.Generate());
}
return(part);
}
private MsDecorationArtist GetArtist()
{
return(new Faker <MsDecorationArtist>()
.RuleFor(a => a.Type, f => f.PickRandom("draftsman", "miniator"))
.RuleFor(a => a.Id, f => f.Lorem.Word())
.RuleFor(a => a.Name, f => f.Person.FirstName)
.RuleFor(a => a.Note, f => f.Lorem.Sentence())
.RuleFor(a => a.Sources, SeederHelper.GetDocReferences(1, 3))
.Generate());
}
protected override void Seed(PlayNGo.Data.DataContext context)
{
// This method will be called after migrating to the latest version.
// You can use the DbSet<T>.AddOrUpdate() helper extension method
// to avoid creating duplicate seed data.
var persons = SeederHelper.CreateInitialListOfPerson();
context.Persons.AddRange(persons);
}
/// <summary>
/// Creates and seeds a new part.
/// </summary>
/// <param name="item">The item this part should belong to.</param>
/// <param name="roleId">The optional part role ID.</param>
/// <param name="factory">The part seeder factory. This is used
/// for layer parts, which need to seed a set of fragments.</param>
/// <returns>A new part.</returns>
/// <exception cref="ArgumentNullException">item or factory</exception>
public override IPart GetPart(IItem item, string roleId,
PartSeederFactory factory)
{
if (item == null)
{
throw new ArgumentNullException(nameof(item));
}
if (factory == null)
{
throw new ArgumentNullException(nameof(factory));
}
int birthYear = Randomizer.Seed.Next(1200, 1300);
PersonPart part = new Faker <PersonPart>()
.RuleFor(p => p.PersonId, f => f.Lorem.Word())
.RuleFor(p => p.ExternalIds, SeederHelper.GetExternalIds(1, 2))
.RuleFor(p => p.Names, new List <PersonName>(new[]
{
new Faker <PersonName>()
.RuleFor(pn => pn.Language, "lat")
.RuleFor(pn => pn.Parts, f =>
new List <PersonNamePart>(new[]
{
new PersonNamePart
{
Type = "first",
Value = f.Lorem.Word(),
},
new PersonNamePart
{
Type = "last",
Value = f.Lorem.Word(),
}
}))
.Generate()
}))
.RuleFor(p => p.Sex, f => f.PickRandom('M', 'F'))
.RuleFor(e => e.Chronotopes, new List <Chronotope>
{
SeederHelper.GetChronotope("birth", birthYear),
SeederHelper.GetChronotope("death", birthYear + 80),
})
.RuleFor(p => p.Bio, f => f.Lorem.Sentence())
.Generate();
SetPartMetadata(part, roleId, item);
return(part);
}
/// <summary>
/// Creates and seeds a new part.
/// </summary>
/// <param name="item">The item this part should belong to.</param>
/// <param name="roleId">The optional part role ID.</param>
/// <param name="factory">The part seeder factory. This is used
/// for layer parts, which need to seed a set of fragments.</param>
/// <returns>A new part.</returns>
/// <exception cref="ArgumentNullException">item or factory</exception>
public override IPart GetPart(IItem item, string roleId,
PartSeederFactory factory)
{
if (item == null)
{
throw new ArgumentNullException(nameof(item));
}
if (factory == null)
{
throw new ArgumentNullException(nameof(factory));
}
MsBindingPart part = new Faker <MsBindingPart>()
.RuleFor(p => p.Century, f => f.Random.Short(8, 15))
.RuleFor(p => p.Description, f => f.Lorem.Sentence())
.RuleFor(p => p.CoverMaterial,
f => f.PickRandom("parchment", "paper"))
.RuleFor(p => p.SupportMaterial,
f => f.PickRandom("parchment", "paper"))
.RuleFor(p => p.Size, f =>
{
return(new PhysicalSize
{
W = new PhysicalDimension
{
Value = (float)SeederHelper.Truncate(
f.Random.Float(6, 21), 2),
Unit = "cm"
},
H = new PhysicalDimension
{
Value = (float)SeederHelper.Truncate(
f.Random.Float(8, 29), 2),
Unit = "cm"
},
D = new PhysicalDimension
{
Value = (float)SeederHelper.Truncate(
f.Random.Float(0.5f, 1.5f), 2),
Unit = "cm"
},
});
}).Generate();
SetPartMetadata(part, roleId, item);
return(part);
}
private static List <PhysicalDimension> GetDimensions(int count)
{
List <PhysicalDimension> dimensions = new List <PhysicalDimension>();
for (int n = 1; n <= count; n++)
{
dimensions.Add(new Faker <PhysicalDimension>()
.RuleFor(d => d.Tag, f => f.Lorem.Word())
.RuleFor(d => d.Value, f => (float)SeederHelper.Truncate(
f.Random.Float(2, 10), 2))
.RuleFor(d => d.Unit, "cm")
.Generate());
}
return(dimensions);
}
/// <summary>
/// Creates and seeds a new part.
/// </summary>
/// <param name="item">The item this part should belong to.</param>
/// <param name="roleId">The optional part role ID.</param>
/// <param name="factory">The part seeder factory. This is used
/// for layer parts, which need to seed a set of fragments.</param>
/// <returns>A new part.</returns>
/// <exception cref="ArgumentNullException">item or factory</exception>
public override IPart GetPart(IItem item, string roleId,
PartSeederFactory factory)
{
if (item == null)
{
throw new ArgumentNullException(nameof(item));
}
if (factory == null)
{
throw new ArgumentNullException(nameof(factory));
}
AttachmentsPart part = new AttachmentsPart();
SetPartMetadata(part, roleId, item);
part.Attachments = SeederHelper.GetAttachments(1, 3);
return(part);
}
/// <summary>
/// Creates and seeds a new part.
/// </summary>
/// <param name="item">The item this part should belong to.</param>
/// <param name="roleId">The optional part role ID.</param>
/// <param name="factory">The part seeder factory. This is used
/// for layer parts, which need to seed a set of fragments.</param>
/// <returns>A new part.</returns>
/// <exception cref="ArgumentNullException">item or factory</exception>
public override IPart GetPart(IItem item, string roleId,
PartSeederFactory factory)
{
if (item == null)
{
throw new ArgumentNullException(nameof(item));
}
if (factory == null)
{
throw new ArgumentNullException(nameof(factory));
}
MsDecorationsPart part = new MsDecorationsPart();
SetPartMetadata(part, roleId, item);
int count = Randomizer.Seed.Next(1, 3);
for (int n = 1; n <= count; n++)
{
int sn = (n - 1) * 2;
part.Decorations.Add(new Faker <MsDecoration>()
.RuleFor(d => d.Id, f => "d" + f.UniqueIndex)
.RuleFor(d => d.Name, f => f.Lorem.Word())
.RuleFor(d => d.Type, f => f.PickRandom(_types))
.RuleFor(d => d.Date, HistoricalDate.Parse($"{1300 + n} AD"))
.RuleFor(d => d.Flags,
f => new List <string>(new[] { f.PickRandom(_flags) }))
.RuleFor(d => d.Place, f => f.Address.Country())
.RuleFor(d => d.Artist, GetArtist())
.RuleFor(d => d.Note, f => f.Random.Bool(0.25f)
? f.Lorem.Sentence() : null)
.RuleFor(d => d.References, SeederHelper.GetDocReferences(1, 3))
.RuleFor(d => d.Elements, f => GetElements(f.Random.Number(1, 3), f))
.Generate());
}
return(part);
}
/// <summary>
/// Creates and seeds a new part.
/// </summary>
/// <param name="item">The item this part should belong to.</param>
/// <param name="roleId">The optional part role ID.</param>
/// <param name="factory">The part seeder factory. This is used
/// for layer parts, which need to seed a set of fragments.</param>
/// <returns>A new part.</returns>
/// <exception cref="ArgumentNullException">item or factory</exception>
public override IPart GetPart(IItem item, string roleId,
PartSeederFactory factory)
{
if (item == null)
{
throw new ArgumentNullException(nameof(item));
}
if (factory == null)
{
throw new ArgumentNullException(nameof(factory));
}
PersonHandPart part = new Faker <PersonHandPart>()
.RuleFor(p => p.PersonId, f => f.Lorem.Word())
.RuleFor(p => p.Job, f => f.PickRandom("copyst", "writer", "poet"))
.RuleFor(p => p.Others, SeederHelper.GetDocReferences(0, 3))
.Generate();
SetPartMetadata(part, roleId, item);
return(part);
}
/// <summary>
/// Creates and seeds a new part.
/// </summary>
/// <param name="item">The item this part should belong to.</param>
/// <param name="roleId">The optional part role ID.</param>
/// <param name="factory">The part seeder factory. This is used
/// for layer parts, which need to seed a set of fragments.</param>
/// <returns>A new part.</returns>
/// <exception cref="ArgumentNullException">item or factory</exception>
public override IPart GetPart(IItem item, string roleId,
PartSeederFactory factory)
{
if (item == null)
{
throw new ArgumentNullException(nameof(item));
}
if (factory == null)
{
throw new ArgumentNullException(nameof(factory));
}
PersonEventsPart part = new PersonEventsPart();
SetPartMetadata(part, roleId, item);
for (int n = 1; n <= Randomizer.Seed.Next(1, 3 + 1); n++)
{
part.Events.Add(new Faker <BioEvent>()
.RuleFor(e => e.Type, f => n == 1?
"birth" : f.PickRandom("work", "marriage"))
.RuleFor(e => e.Date, HistoricalDate.Parse($"{n} AD"))
.RuleFor(e => e.Places,
f => new List <string>(new[] { f.Lorem.Word() }))
.RuleFor(e => e.Description, f => f.Lorem.Sentence())
.RuleFor(e => e.Sources, SeederHelper.GetDocReferences(1, 3))
.RuleFor(e => e.Participants, SeederHelper.GetDecoratedIds(1, 3))
.RuleFor(e => e.Work, f => f.Lorem.Sentence(1, 3))
.RuleFor(e => e.Rank, f => f.Random.Short(0, 3))
.RuleFor(e => e.IsWorkDubious, f => f.Random.Bool(0.2f))
.RuleFor(e => e.IsWorkLost, f => f.Random.Bool(0.2f))
.RuleFor(e => e.ExternalIds, SeederHelper.GetExternalIds(1, 3))
.Generate());
}
return(part);
}
/// <summary>
/// Creates and seeds a new part.
/// </summary>
/// <param name="item">The item this part should belong to.</param>
/// <param name="roleId">The optional part role ID.</param>
/// <param name="factory">The part seeder factory. This is used
/// for layer parts, which need to seed a set of fragments.</param>
/// <returns>A new part.</returns>
/// <exception cref="ArgumentNullException">item or factory</exception>
public override IPart GetPart(IItem item, string roleId,
PartSeederFactory factory)
{
if (item == null)
{
throw new ArgumentNullException(nameof(item));
}
if (factory == null)
{
throw new ArgumentNullException(nameof(factory));
}
SerialTextInfoPart part = new Faker <SerialTextInfoPart>()
.RuleFor(p => p.TextId, f => f.Lorem.Word().ToLowerInvariant())
.RuleFor(p => p.Language, f => f.PickRandom("ita", "fra", "lat"))
.RuleFor(p => p.Subject, f => f.Lorem.Sentence(2, 4))
.RuleFor(p => p.Genre, f => f.PickRandom(new string[]
{ "lettera", "canzone" }))
.RuleFor(p => p.Verse, f => f.PickRandom(new string[]
{ "settenario", "ottonario" }))
.RuleFor(p => p.Rhyme, f => f.PickRandom(new string[]
{
"AABBCC", "ABCA"
}))
.RuleFor(p => p.Authors, SeederHelper.GetCitedPersons(1, 3))
.RuleFor(p => p.Headings, f =>
new List <string>(new[] { f.Lorem.Sentence(3, 5) }))
.RuleFor(p => p.Recipients, SeederHelper.GetDecoratedIds(1, 3))
.RuleFor(p => p.ReplyingTo, SeederHelper.GetDecoratedIds(1, 3))
.RuleFor(p => p.Note, f => f.Lorem.Sentence())
.Generate();
SetPartMetadata(part, roleId, item);
return(part);
}
private static void Seed()
{
// var dbConnection =
// new MySqlConnection(connectionString);
// dbConnection.Open();
// Seeder.DbConnection = dbConnection;
// if (dbConnection.State != ConnectionState.Open)
// {
// return;
// }
Seeder.WipeTable(typeof(StoreAddress));
Seeder.WipeTable(typeof(Stock));
Seeder.WipeTable(typeof(Store));
Seeder.WipeTable(typeof(CustomerReview));
Seeder.WipeTable(typeof(ProductSalesStatistic));
Seeder.WipeTable(typeof(Product));
Seeder.WipeTable(typeof(Brand));
Seeder.WipeTable(typeof(Category));
Seeder.WipeTable(typeof(Customer));
Seeder.WipeTable(typeof(Account));
Seeder.Seed <Account>(() =>
{
int customerCounter = 1;
var fakeAccounts = new Faker <Account>()
.RuleFor(a => a.AccountId, f => customerCounter++)
.RuleFor(a => a.Email, f => f.Person.Email)
.RuleFor(a => a.Password, SeederHelper.CreateMd5(SeederHelper.RandomString(16)))
.RuleFor(a => a.DeletedAt, f => DateTime.Now)
.RuleFor(a => a.Deleted, f => false);
return(fakeAccounts);
}, customerCount);
Seeder.Seed <Customer>(() =>
{
int customerCounter = 1;
var fakeCustomers = new Faker <Customer>()
.RuleFor(u => u.CustomerId, f => customerCounter)
.RuleFor(u => u.AccountId, f => customerCounter++)
.RuleFor(u => u.FirstName, f => f.Name.FirstName())
.RuleFor(u => u.LastName, f => f.Name.LastName())
.RuleFor(u => u.ProfilePictureUrl, f => f.Internet.Avatar())
.RuleFor(u => u.PhoneNumber, f => f.Random.Int(1000, 2000).ToString());
return(fakeCustomers);
}, customerCount);
Seeder.Seed <Brand>(() =>
{
int brandCounter = 1;
var fakeBrands = new Faker <Brand>()
.RuleFor(b => b.BrandId, f => brandCounter++)
.RuleFor(b => b.BrandName, f => f.Company.CompanyName());
return(fakeBrands);
}, brandCount);
Seeder.Seed <Category>(() =>
{
int categoryCounter = 1;
var fakeCategories = new Faker <Category>()
.RuleFor(c => c.CategoryName, f => CategoryNames[categoryCounter - 1])
.RuleFor(c => c.CategoryId, f => categoryCounter++);
return(fakeCategories);
}, categoryCount);
// Seeder.Seed<CustomerAddress>(() =>
// {
// int customerCounter = 1;
// var fakeCustomerAddresses = new Faker<CustomerAddress>()
// .RuleFor(u => u.CustomerId, f => customerCounter++)
// .RuleFor(u => u.Country, f => f.Address.Country())
// .RuleFor(u => u.Province, f => f.Address.City())
// .RuleFor(u => u.District, f => f.Address.City())
// .RuleFor(u => u.AddressTextPrimary, f => f.Address.FullAddress())
// .RuleFor(u => u.AddressTextSecondary, f => f.Address.FullAddress())
// .RuleFor(s => s.ZipCode, f => f.PickRandom(new []{"20000","34000","06090","01010","07010"}));
// return fakeCustomerAddresses;
// }, customerCount);
//
Seeder.Seed <Store>(() =>
{
int storeCounter = 1;
var fakeStores = new Faker <Store>()
.RuleFor(s => s.StoreId, f => storeCounter++)
.RuleFor(s => s.Email, f => f.Person.Email)
.RuleFor(s => s.PhoneNumber, f => f.Person.Phone)
.RuleFor(s => s.StoreName, f => f.Company.CompanyName());
return(fakeStores);
}, storeCount);
Seeder.Seed <StoreAddress>(() =>
{
int storeCounter = 1;
var fakeStoreAddresses = new Faker <StoreAddress>()
.RuleFor(s => s.StoreId, f => storeCounter++)
.RuleFor(s => s.CountryTag, f => "TR")
.RuleFor(s => s.Province, f => f.Address.City())
.RuleFor(s => s.District, f => f.Address.City())
.RuleFor(s => s.Neighborhood, f => f.Address.StreetAddress())
.RuleFor(s => s.ZipCode, f => f.PickRandom(new [] { "20000", "34000", "06090", "01010", "07010" }))
.RuleFor(s => s.AddressTextPrimary, f => f.Address.FullAddress())
.RuleFor(s => s.AddressTextSecondary, f => "");
return(fakeStoreAddresses);
}, storeCount);
Seeder.Seed <Product>(() =>
{
string[] productNames =
{
new Faker().Music.Genre() + " Chair",
new Faker().Music.Genre() + " Armchair",
new Faker().Music.Genre() + " Deck chair",
new Faker().Music.Genre() + " Cantilever Chair",
new Faker().Music.Genre() + " Deck",
new Faker().Music.Genre() + " Desk",
new Faker().Music.Genre() + " Stool",
new Faker().Music.Genre() + " Sofa",
new Faker().Music.Genre() + " Sofa",
new Faker().Music.Genre() + " Sofa",
new Faker().Music.Genre() + " Sofa",
};
int productCounter = 1;
var fakeProducts = new Faker <Product>()
.RuleFor(p => p.ProductColor, f => ColorNames[f.Random.Int(0, ColorNames.Length - 1)])
.RuleFor(p => p.CategoryId, f => f.Random.Int(1, CategoryNames.Length))
.RuleFor(p => p.ProductId, f => productCounter++)
.RuleFor(p => p.ProductName,
(f, u) => $"{u.ProductColor} {f.Lorem.Word()} {CategoryNames[u.CategoryId - 1]}")
.RuleFor(p => p.SubType, (f, u) => f.PickRandom(SubCategories[CategoryNames[u.CategoryId - 1]]))
.RuleFor(p => p.ProductImage, (f, u) => $"{PhotoServer}{u.ProductColor}-{CategoryNames[u.CategoryId - 1]}-{1}.jpg")
.RuleFor(p => p.ProductWidth, f => f.Random.Float(50, 120))
.RuleFor(p => p.ProductHeight, f => f.Random.Float(50, 120))
.RuleFor(p => p.ProductWeight, f => f.Random.Int(15, 100))
.RuleFor(p => p.BoxPieces, f => f.Random.Int(20, 50))
.RuleFor(p => p.BrandId, f => f.Random.Int(1, brandCount))
.RuleFor(p => p.ModelYear, f => f.Random.Int(2000, 2020))
.RuleFor(p => p.ListPrice, f => f.Random.Double(25, 150))
.RuleFor(p => p.Discount, f => f.PickRandom(0, 0, 0, 0, 0, 0, 0, 5, 10, 20))
.RuleFor(p => p.Description, f => f.Commerce.ProductDescription());
return(fakeProducts);
}, productCount);
Seeder.Seed <Stock>(() =>
{
int productCounter = 1;
var fakeStoreStocks = new Faker <Stock>()
.RuleFor(s => s.StockId, f => productCounter)
.RuleFor(s => s.ProductId, f => productCounter++)
.RuleFor(s => s.StoreId, f => f.Random.Int(1, 2))
.RuleFor(s => s.Quantity, f => f.Random.Int(50, 120));
return(fakeStoreStocks);
}, productCount);
Seeder.Seed <CustomerReview>(() =>
{
var fakeComments = new Faker <CustomerReview>()
.RuleFor(s => s.CustomerId, f => f.Random.Int(1, customerCount))
.RuleFor(s => s.ProductId, f => f.Random.Int(1, productCount))
.RuleFor(s => s.CustomerComment, f => f.Lorem.Paragraph(4))
.RuleFor(s => s.CustomerRating, f => f.Random.Float(0, 5))
.RuleFor(s => s.ReplyReviewId, f => 0);
return(fakeComments);
}, productCount * 4);
Seeder.Seed <PostalService>(() =>
{
int postalServiceCounter = 1;
var fakeComments = new Faker <PostalService>()
.RuleFor(s => s.ServiceId, f => postalServiceCounter++)
// .RuleFor(s => s.PostalServiceName, f => f.Company.CompanyName())
.RuleFor(s => s.Price, f => f.Random.Double(25, 100));
return(fakeComments);
}, storeCount);
Seeder.Seed <ProductSalesStatistic>(() =>
{
int productCounter = 1;
var productStatistic = new Faker <ProductSalesStatistic>()
.RuleFor(p => p.ProductId, f => productCounter++)
.RuleFor(p => p.NumberSold, f => f.Random.Int(20, 500))
.RuleFor(p => p.NumberViewed, f => f.Random.Int(100, 6000))
.RuleFor(p => p.DateAdded, f => SeederHelper.GetRandomDate(2019));
return(productStatistic);
}, productCount);
}
private void SeedByAlgorithm(GradeBookContext context)
{
try
{
logger.Info("Seeding began");
UserManager <GradeBookUser, int> _userManager =
new UserManager <GradeBookUser, int>(
new UserStore <GradeBookUser, CustomRole, int, CustomUserLogin, CustomUserRole, CustomUserClaim>(context));
RoleManager <CustomRole, int> _roleManager =
new RoleManager <CustomRole, int>(new RoleStore <CustomRole, int, CustomUserRole>(context));
#region Roles
CustomRole adminRole = new CustomRole()
{
Name = "admins"
};
CustomRole studentRole = new CustomRole()
{
Name = "students"
};
CustomRole teacherRole = new CustomRole()
{
Name = "teachers"
};
CustomRole parentRole = new CustomRole()
{
Name = "parents"
};
_roleManager.Create(adminRole);
_roleManager.Create(studentRole);
_roleManager.Create(teacherRole);
_roleManager.Create(parentRole);
#endregion
logger.Info("Roles created");
#region Admins
AdminUser admin_pera = new AdminUser()
{
UserName = "******", FirstName = "Pera", LastName = "Peric"
};
AdminUser admin_milan = new AdminUser()
{
UserName = "******", FirstName = "Milan", LastName = "Milic"
};
_userManager.Create(admin_pera, "password");
_userManager.Create(admin_milan, "password");
_userManager.AddToRole(admin_pera.Id, "admins");
_userManager.AddToRole(admin_milan.Id, "admins");
#endregion
logger.Info("Admins created");
#region Courses, FOR NOW LET's use these
List <Course> courses = new List <Course>();
courses.Add(new Course()
{
Name = "Mathematics", ColloqialName = "Matis"
});
courses.Add(new Course()
{
Name = "Chemistry", ColloqialName = "Hemija"
});
courses.Add(new Course()
{
Name = "Biology", ColloqialName = "Biologija"
});
courses.Add(new Course()
{
Name = "Informatics", ColloqialName = "Informatika"
});
courses.Add(new Course()
{
Name = "German", ColloqialName = "Nemacki"
});
courses.Add(new Course()
{
Name = "History", ColloqialName = "Istorija"
});
courses.Add(new Course()
{
Name = "English", ColloqialName = "Engleski"
});
context.Courses.AddRange(courses);
context.SaveChanges();
#endregion
logger.Info("Courses cretated");
#region Students
List <StudentUser> students = SeederHelper.CreateStudents(20);
foreach (var s in students)
{
context.Users.Add(s);
context.SaveChanges();
CustomUserRole st = new CustomUserRole()
{
RoleId = studentRole.Id, UserId = s.Id
};
context.SaveChanges();
}
#endregion
logger.Info("Students created");
#region Teachers
List <TeacherUser> teachers = SeederHelper.CreateTeachers(10);
foreach (var t in teachers)
{
context.Users.Add(t);
context.SaveChanges();
CustomUserRole st = new CustomUserRole()
{
RoleId = teacherRole.Id, UserId = t.Id
};
context.SaveChanges();
}
#endregion
logger.Info("Teachers created");
#region Parents
List <StudentParent> studentParents = SeederHelper.CreateRealisticParents(students);
List <ParentUser> parents = studentParents.Select(sp => sp.Parent).Distinct().ToList();
foreach (var p in parents)
{
context.Users.Add(p);
context.SaveChanges();
CustomUserRole st = new CustomUserRole()
{
RoleId = parentRole.Id, UserId = p.Id
};
context.SaveChanges();
}
context.StudentParents.AddRange(studentParents);
context.SaveChanges();
#endregion
logger.Info("Parents created");
#region Teaching (assignments)
// --- Teaching assignments *** This one could have been added to curriculum....
List <Teaching> teachings = SeederHelper.AssignTeaching(teachers, courses);
context.TeachingAssignments.AddRange(teachings);
context.SaveChanges();
#endregion
logger.Info("Teaching assignments created");
#region Classrooms
List <ClassRoom> classes = SeederHelper.CreateSchoolClasses(2, 5, 6);
context.ClassRooms.AddRange(classes);
context.SaveChanges();
#endregion
logger.Info("Classrooms created");
#region Student enrollments, Programs
SeederHelper.AssignStudentsToClasses(students, classes, 2);
context.SaveChanges();
logger.Info("Students assigned to classrooms");
List <Program> programs = SeederHelper.AssignProgram(teachings, classes);
context.Programs.AddRange(programs);
logger.Info("Students assigned to takings");
context.SaveChanges();
#endregion
logger.Info("Students enrolled, programs created");
#region Learning (student learning a subject)
List <Taking> takings = SeederHelper.AssignTakings(students, programs);
context.Takings.AddRange(takings);
context.SaveChanges();
#endregion
logger.Info("Takings creadte");
#region Grades
List <Grade> grades = SeederHelper.AssignGrades(takings, new DateTime(2018, 9, 1), new DateTime(2018, 12, 31), 1, 2, 5);
context.Grades.AddRange(grades);
context.SaveChanges();
#endregion
logger.Info("Grades assigned");
#region Final Grades
List <FinalGrade> finalGrades = SeederHelper.AssignFinalGrades(takings, new DateTime(2018, 9, 1), new DateTime(2018, 12, 31), 1);
context.FinalGrades.AddRange(finalGrades);
context.SaveChanges();
#endregion
logger.Info("Final grades assigned");
}
catch (SqlException ex)
{
Debug.WriteLine("Database cannot be accessed.");
throw ex;
}
catch (Exception ex)
{
Debug.WriteLine("Seeding the database failed");
throw ex;
}
}
/// <summary>
/// Creates and seeds a new part.
/// </summary>
/// <param name="item">The item this part should belong to.</param>
/// <param name="roleId">The optional part role ID.</param>
/// <param name="factory">The part seeder factory. This is used
/// for layer parts, which need to seed a set of fragments.</param>
/// <returns>A new part.</returns>
/// <exception cref="ArgumentNullException">item or factory</exception>
public override IPart GetPart(IItem item, string roleId,
PartSeederFactory factory)
{
if (item == null)
{
throw new ArgumentNullException(nameof(item));
}
if (factory == null)
{
throw new ArgumentNullException(nameof(factory));
}
MsHistoryPart part = new Faker <MsHistoryPart>()
.RuleFor(p => p.Provenances, GetProvenances(2))
.RuleFor(p => p.History, f => f.Lorem.Sentence())
.Generate();
SetPartMetadata(part, roleId, item);
// persons
for (int n = 1; n <= Randomizer.Seed.Next(1, 3 + 1); n++)
{
part.Persons.Add(new Faker <MsHistoryPerson>()
.RuleFor(p => p.Role,
f => f.PickRandom("scribe", "corrector", "owner"))
.RuleFor(p => p.Name, new Faker <PersonName>()
.RuleFor(pn => pn.Language, "lat")
.RuleFor(pn => pn.Parts, f =>
new List <PersonNamePart>(new[]
{
new PersonNamePart
{
Type = "first",
Value = f.Lorem.Word(),
},
new PersonNamePart
{
Type = "last",
Value = f.Lorem.Word(),
}
}))
.Generate())
.RuleFor(p => p.Date, HistoricalDate.Parse($"{1200 + n} AD"))
.RuleFor(p => p.Note, f => f.PickRandom(null, f.Lorem.Sentence()))
.RuleFor(p => p.ExternalIds, f => new List <string>(new[]
{
$"www.someurl.org/entities/{f.Random.Number()}"
}))
.RuleFor(p => p.Sources, SeederHelper.GetDocReferences(1, 3))
.Generate());
}
// annotations
for (int n = 1; n <= Randomizer.Seed.Next(1, 3 + 1); n++)
{
part.Annotations.Add(new Faker <MsAnnotation>()
.RuleFor(a => a.Language, f => f.PickRandom("lat", "ita"))
.RuleFor(a => a.Type, f => f.Lorem.Word())
.RuleFor(a => a.Text, f => f.Lorem.Sentence())
.RuleFor(a => a.PersonId, f => f.Person.FirstName)
.RuleFor(r => r.Ranges, new List <MsLocationRange>(new[]
{
new MsLocationRange
{
Start = new MsLocation
{
N = n,
S = n % 2 == 0 ? "v" : "r",
L = n * 5
},
End = new MsLocation
{
N = n + 1,
S = n % 2 == 0 ? "r" : "v",
L = n * 5
}
}
}))
.RuleFor(f => f.Sources, SeederHelper.GetDocReferences(1, 3))
.Generate());
}
// restorations
for (int n = 1; n <= Randomizer.Seed.Next(1, 3 + 1); n++)
{
part.Restorations.Add(new Faker <MsRestoration>()
.RuleFor(r => r.Type, f => f.Lorem.Word())
.RuleFor(r => r.Place, f => f.Lorem.Word())
.RuleFor(r => r.Date, HistoricalDate.Parse($"{1200 + n} AD"))
.RuleFor(r => r.PersonId, f => f.Person.FirstName)
.RuleFor(r => r.Note, f => f.PickRandom(null, f.Lorem.Sentence()))
.RuleFor(r => r.Sources, SeederHelper.GetDocReferences(1, 3))
.Generate());
}
return(part);
}
protected override void Seed(MyDbContext context)
{
SeederHelper.Seed(context);
}
