private async Task SeedSingleSeed(int seedingStep, ServiceProvider serviceProvider, SeedInfo seedInfo)
{
Assert(seedingStep > 0);
Assert(serviceProvider != null);
Assert(seedInfo != null);
Preparing?.Invoke(this, new SeedingEventArgs(seedingStep, seedInfo));
var seed = (ISeed)ActivatorUtilities.GetServiceOrCreateInstance(serviceProvider, seedInfo.SeedType);
foreach (var seedOutputProperty in seedInfo.SeedOutputProperties)
{
// We always want to create a new instance of a seed output class.
// Why? Because in a general case seed output classes will have dependency constructors
// that can potentially have transient dependencies.
var propertyValue = ActivatorUtilities.GetServiceOrCreateInstance(serviceProvider, seedOutputProperty.PropertyType);
seedOutputProperty.SetValue(seed, propertyValue);
}
if (await seed.OutputAlreadyExists())
{
Skipping?.Invoke(this, new SeedingEventArgs(seedingStep, seedInfo));
return;
}
Seeding?.Invoke(this, new SeedingEventArgs(seedingStep, seedInfo));
await seed.Seed();
SeedingEnded?.Invoke(this, new SeedingEventArgs(seedingStep, seedInfo));
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env, Seeding seed)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
seed.Seed();
}
app.UseHttpsRedirection();
app.UseSwagger();
app.UseSwaggerUI(c =>
{
c.SwaggerEndpoint("/swagger/v1/swagger.json", "Projeto Quiver");
});
app.UseRouting();
app.UseCors(x => x
.AllowAnyOrigin()
.AllowAnyMethod()
.AllowAnyHeader());
app.UseAuthorization();
app.UseAuthentication();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllers();
});
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env, PermissionContext context)
{
context.Database.Migrate();
Seeding seeding = new Seeding(context);
seeding.Init();
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
app.UseBrowserLink();
}
else
{
app.UseExceptionHandler("/Home/Error");
}
app.UseStaticFiles();
app.UseMvc(routes =>
{
routes.MapRoute(
name: "default",
template: "{controller=Home}/{action=Index}/{id?}");
});
}
/// <summary>
/// Randomizes the clusters inside a dataset.
/// </summary>
///
/// <param name="points">The data to randomize the algorithm.</param>
/// <param name="strategy">The seeding strategy to be used. Default is <see cref="Seeding.KMeansPlusPlus"/>.</param>
/// <param name="parallelOptions">The parallelization options for this procedure.
/// Only relevant for the <see cref="Seeding.PamBuild"/>. </param>
///
public virtual int[] Randomize(TData[] points, Seeding strategy = Seeding.KMeansPlusPlus, ParallelOptions parallelOptions = null)
{
if (points == null)
{
throw new ArgumentNullException("points");
}
Owner.NumberOfInputs = Tools.GetNumberOfInputs(points);
switch (strategy)
{
case Seeding.Fixed:
return(DoFixedSeeding(points));
case Seeding.Uniform:
return(DoUniformSeeding(points));
case Seeding.KMeansPlusPlus:
return(DoKMeansPlusPlusSeeding(points));
case Seeding.PamBuild:
return(DoPamBuildSeeding(points, parallelOptions));
}
throw new ArgumentException("Uknown strategy: {0}".Format(strategy));
}
void HandleStateChanged(object sender, StateChangedEventArgs args)
{
Download manager = (Download)sender;
if (args.OldState == State.Downloading)
{
logger.Debug("Removing " + manager.Torrent.Name + " from download label");
Downloading.RemoveTorrent(manager);
}
else if (args.OldState == State.Seeding)
{
logger.Debug("Removing " + manager.Torrent.Name + " from upload label");
Seeding.RemoveTorrent(manager);
}
if (args.NewState == State.Downloading)
{
logger.Debug("Adding " + manager.Torrent.Name + " to download label");
Downloading.AddTorrent(manager);
}
else if (args.NewState == State.Seeding)
{
logger.Debug("Adding " + manager.Torrent.Name + " to upload label");
Seeding.AddTorrent(manager);
}
}
// Creates and seeds an ApplicationContext with test data; then calls test action.
private async Task PrepareTestContext(TestAction testAction)
{
// Database is in memory as long the connection is open
var connection = new SqliteConnection("DataSource=:memory:");
try
{
connection.Open();
var options = new DbContextOptionsBuilder <ApplicationContext>()
.UseSqlite(connection)
.Options;
// Create the schema in the database and seeds with test data
using (var context = new ApplicationContext(options))
{
context.Database.EnsureCreated();
Seeding.Initialize(context);
await testAction(context);
}
}
finally
{
connection.Close();
}
}
public static void Main(string[] args)
{
var host = CreateWebHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
try
{
var context = services.GetRequiredService <ApplicationDbContext>();
var serviceProvider = services.GetRequiredService <IServiceProvider>();
var configuration = services.GetRequiredService <IConfiguration>();
context.Database.Migrate();
Seeding.CreateRoles(serviceProvider, configuration).Wait();
}
catch (Exception ex)
{
var logger = services.GetRequiredService <ILogger <Program> >();
logger.LogError(ex, "An error occurred seeding the DB.");
}
}
host.Run();
}
public static void Main(string[] args)
{
var host = CreateWebHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
try
{
var context = services.
GetRequiredService <ApplicationContext>();
// Seeding de datos.
Seeding.Initialize(services);
}
catch (Exception ex)
{
var logger = services.GetRequiredService <ILogger <Program> >();
logger.LogError(ex, "An error occurred seeding the DB.");
}
}
host.Run();
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
modelBuilder.Entity <Word>()
.Property(x => x.Id).ValueGeneratedOnAdd();
modelBuilder.Entity <Word>()
.HasIndex(x => x.Name).IsUnique();
modelBuilder.Entity <Example>()
.Property(x => x.Id).ValueGeneratedOnAdd();
modelBuilder.Entity <User>()
.Property(x => x.Id).ValueGeneratedOnAdd();
modelBuilder.Entity <WordExample>()
.HasKey(x => new { x.WordId, x.ExampleId });
modelBuilder.Entity <WordExample>()
.HasOne(x => x.Word)
.WithMany(x => x.Examples)
.HasForeignKey(x => x.WordId);
modelBuilder.Entity <WordExample>()
.HasOne(x => x.Example)
.WithMany(x => x.Words)
.HasForeignKey(x => x.ExampleId);
Seeding.Seed(modelBuilder);
}
public static async Task TestSeedDb(IHost host)
{
using (IServiceScope scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
await Seeding.Initialize(services);
}
}
void Start()
{
seeding = GameObject.FindObjectOfType <Seeding>();
perlinValues = new float[dungeonSize.x, dungeonSize.y];
map = new string[dungeonSize.x, dungeonSize.y];
GenerateDungeon();
}
private void OnDeserializedMethod(StreamingContext context)
{
if (this.Iterations == 0 && MaxIterations == 0 && Tolerance == 0)
{
this.Tolerance = 1e-5;
this.ComputeCovariances = true;
this.UseSeeding = Seeding.KMeansPlusPlus;
this.ComputeError = true;
}
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env, UserManager <MyMeetupUser> userManager,
RoleManager <MyMeetupRole> roleManager, MyMeetupContext context)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
app.UseDatabaseErrorPage();
}
else
{
// app.UseDeveloperExceptionPage();
// app.UseDatabaseErrorPage();
app.UseExceptionHandler("/Home/Error");
app.UseHsts();
}
// app.UseDeveloperExceptionPage();
var supportedCultures = new List <CultureInfo>
{
new CultureInfo("fr"),
new CultureInfo("fr-FR"),
//new CultureInfo("en"),
//new CultureInfo("en-US")
};
var localizationOptions = new RequestLocalizationOptions
{
DefaultRequestCulture = new RequestCulture("fr-FR"),
SupportedCultures = supportedCultures,
SupportedUICultures = supportedCultures
};
app.UseRequestLocalization(localizationOptions);
app.UseElmah();
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseCookiePolicy();
context.Database.Migrate();
app.UseAuthentication();
Seeding.SeedRoles(roleManager);
Seeding.SeedUsers(userManager);
Seeding.SeedData(context);
app.UseMvc(routes =>
{
routes.MapRoute(
name: "areas",
template: "{area:exists}/{controller=Home}/{action=Index}"
);
routes.MapRoute(
name: "default",
template: "{controller=Home}/{action=Index}/{id?}");
});
}
IAllowedMemberValues Register(IServiceProvider arg)
{
IParameterizedSource <MemberInfo, IAllowedValueSpecification>
seed = new Seeding(Specifications, Instances, _allowed).Get(),
fallback = _allowed == AllowAssignedValues
? Source.Default
: new FixedInstanceSource <MemberInfo, IAllowedValueSpecification>(_allowed);
var source = this.Appending(fallback)
.Aggregate(seed, (current, item) => current.Or(item));
var result = new AllowedMemberValues(source);
return(result);
}
public static void Main(string[] args)
{
var host = CreateWebHostBuilder(args)
.ConfigureAppConfiguration(configs => GetConfigurations())
.Build();
host.MigrateDbContext <IdentityContext>((context, serviceProvider) =>
{
Seeding.SeedPermissions(context);
context.SaveChanges();
});
CreateHostBuilder(args).Build().Run();
}
public static void Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
var serviceProvider = services.GetRequiredService <IServiceProvider>();
var service = scope.ServiceProvider.GetRequiredService <Context>();
Seeding.MigrateDatabase(service);
Seeding.Seed(serviceProvider).Wait();
}
host.Run();
}
public static void Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
using (var scope = host.Services.CreateScope()){
var services = scope.ServiceProvider;
try{
var context = services.GetRequiredService <DataContext>();
context.Database.Migrate();
Seeding.Seed(context);
} catch (Exception e) {
var logger = services.GetRequiredService <ILogger <Program> >();
logger.LogError(e, $"Error occured migrating DB");
}
}
host.Run();
}
protected override void ConfigureWebHost(IWebHostBuilder builder)
{
builder.ConfigureServices(services =>
{
var dbContextDescriptor = services.Single(d => d.ServiceType == typeof(DbContextOptions <CarManagerContext>));
services.Remove(dbContextDescriptor);
services.AddDbContext <CarManagerContext>(options => options.UseInMemoryDatabase(nameof(CarManagerContext)));
using var scope = services.BuildServiceProvider().CreateScope();
var scopedProvider = scope.ServiceProvider;
var context = scopedProvider.GetRequiredService <CarManagerContext>();
if (context.Database.EnsureCreated())
{
Seeding.Initialize(context);
}
});
}
private static void CreateDbIfNotExists(IHost host)
{
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
try
{
// Seed the Identity-related database if have not done so
var UR_context = services.GetRequiredService <UserRoleDB>();
Seeding.Initialize(UR_context);
}
catch (Exception ex)
{
var logger = services.GetRequiredService <ILogger <Program> >();
logger.LogError(ex, "An error occurred creating the DB.");
}
}
}
/// <summary>
/// Initializes a new instance of PartitioningAroundMedoids algorithm
/// </summary>
///
/// <param name="k">The number of clusters to divide input data.</param>
/// <param name="distance">The distance function to use. Default is to
/// use the <see cref="Accord.Math.Distance.Euclidean(double[], double[])"/> distance.</param>
///
public KMedoids(int k, IDistance <T[]> distance)
{
if (k <= 0)
{
throw new ArgumentOutOfRangeException("k");
}
if (distance == null)
{
throw new ArgumentNullException("distance");
}
// Create the object-oriented structure to hold
// information about the k-Medoids' clusters.
clusters = new KMedoidsClusterCollection <T>(k, distance);
Initialization = Seeding.PamBuild;
Tolerance = 1e-5;
MaxIterations = 100;
}
/// <summary>
/// Initializes a new instance of KModes algorithm
/// </summary>
///
/// <param name="k">The number of clusters to divide input data.</param>
/// <param name="distance">The distance function to use. Default is to
/// use the <see cref="Accord.Math.Distance.SquareEuclidean(double[], double[])"/> distance.</param>
///
public KModes(int k, IDistance <T[]> distance)
{
if (k <= 0)
{
throw new ArgumentOutOfRangeException("k");
}
if (distance == null)
{
throw new ArgumentNullException("distance");
}
// Create the object-oriented structure to hold
// information about the k-modes' clusters.
this.clusters = new KModesClusterCollection <T>(k, distance);
this.Initialization = Seeding.KMeansPlusPlus;
this.Tolerance = 1e-5;
this.MaxIterations = 100;
}
/// <summary>
/// Initializes a new instance of the KMeans algorithm
/// </summary>
///
/// <param name="k">The number of clusters to divide the input data into.</param>
/// <param name="distance">The distance function to use. Default is to use the
/// <see cref="Accord.Math.Distance.SquareEuclidean(double[], double[])"/> distance.</param>
///
public KMeans(int k, IDistance <double[]> distance)
{
if (k <= 0)
{
throw new ArgumentOutOfRangeException("k");
}
if (distance == null)
{
throw new ArgumentNullException("distance");
}
this.Tolerance = 1e-5;
this.ComputeCovariances = true;
this.ComputeError = true;
this.UseSeeding = Seeding.KMeansPlusPlus;
this.MaxIterations = 0;
// Create the object-oriented structure to hold
// information about the k-means' clusters.
this.clusters = new KMeansClusterCollection(k, distance);
}
public async Task <ActionResult <Seeding> > AddSeeding([FromBody] SeedingViewModel input)
{
try
{
Seeding seeding = null;
if (input != null)
{
seeding = input.Adapt <Seeding>();
var user = _context.Users.Where(s => s.ID == input.UserId).FirstOrDefault();
if (user == null)
{
return(new JsonResult(new { ErrorMessage = "The given user id not found." }));
}
seeding.User = user;
var PartLandDetails = _context.PartitionLandDetails.Where(p => p.ID == input.PartitionLandDetailId).FirstOrDefault();
if (PartLandDetails == null)
{
return(new JsonResult(new { ErrorMessage = "The given land details id not found." }));
}
seeding.PartitionLandDetail = PartLandDetails;
//Deciding whether the action is Add or Update
if (input.ID <= 0) //Add
{
_context.Seedings.Add(seeding);
}
else
{ //Update
_context.Seedings.Update(seeding);
}
}
await _context.SaveChangesAsync();
return(new JsonResult(seeding));
}
catch (Exception _ex)
{
return(new JsonResult(new { ErrorMessage = _ex.Message }));
}
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env, UserManager <AppUser> userManager, RoleManager <AppRole> roleManager, IKategoriService kategoriService, ITagService tagService)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseExceptionHandler("/Home/Error");
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
Seeding.SeedData(userManager, roleManager, kategoriService, tagService).Wait();
app.UseStaticFiles(new StaticFileOptions
{
FileProvider = new PhysicalFileProvider(
Path.Combine(env.ContentRootPath, "wwwroot/AnaKlasor/Resimler")),
RequestPath = "/wwwroot/AnaKlasor/Resimler"
});
app.UseStaticFiles(new StaticFileOptions
{
FileProvider = new PhysicalFileProvider(
Path.Combine(env.ContentRootPath, "wwwroot/AnaKlasor/Yazilar")),
RequestPath = "/wwwroot/AnaKlasor/Yazilar"
});
app.UseRouting();
app.UseAuthentication();
app.UseAuthorization();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllerRoute(
name: "default",
pattern: "{controller=Home}/{action=Index}/{id?}");
});
}
private static void Main(string[] args)
{
CountryDBSettings countryDBSettings = new CountryDBSettings()
{
ConnectionString = "mongodb://127.0.0.1:27017",
DatabaseName = "CountryDB"
};
FlagService flagService = new FlagService(countryDBSettings);
CountryService countryService = new CountryService(countryDBSettings);
Stopwatch sw = new Stopwatch();
sw.Start();
var dataSeeding = new Seeding(countryService, flagService);
dataSeeding.Run();
sw.Stop();
Console.WriteLine($"Load Complete : {sw.Elapsed.TotalSeconds}");
Console.ReadKey();
}
private void CalculateRanks(IEnumerable <SeedingInfo> seedings)
{
var context = DataEntitiesProvider.Provide();
var sortedSeedings = seedings.OrderBy(x => x.GameCode)
.ThenByDescending(x => x.Score)
.ThenByDescending(x => x.LastGoldYear)
.ThenByDescending(x => x.LastSilverYear)
.ThenByDescending(x => x.LastBronzeYear)
.ToList();
var lastEventCode = "";
var rank = 1;
foreach (var seeding in sortedSeedings)
{
if (seeding.GameCode != lastEventCode)
{
lastEventCode = seeding.GameCode;
rank = 1;
}
else
{
rank++;
}
var dbSeeding = new Seeding()
{
ContestantId = seeding.ContestantId,
EventCode = seeding.GameCode,
Rank = rank,
Score = seeding.Score
};
context.Seedings.Add(dbSeeding);
context.SaveChanges();
}
}
private void StartUp()
{
Log("Instantiating");
Log("\tUtilities");
Utils = new Utilities();
Log("\tSeeding Class");
Seeding = new Seeding();
Log("Subscribing to Seeding Events");
Seeding.AddUrlEvent += Seeding_AddUrlEvent;
Seeding.DeleteAllUrlsEvent += Seeding_DeleteAllUrlsEvent;
Log("Subscribing to Globally Shared Events");
Log("\t Logging");
Seeding.LogEvent += LogEvent;
// Log("\t Broadcast Messages");
Log("Starting The TCP Server");
Log("Application Loaded");
}
/// <summary>
/// Randomizes the clusters inside a dataset.
/// </summary>
///
/// <param name="points">The data to randomize the algorithm.</param>
/// <param name="strategy">The seeding strategy to be used. Default is <see cref="Seeding.KMeansPlusPlus"/>.</param>
///
public void Randomize(T[][] points, Seeding strategy = Seeding.KMeansPlusPlus)
{
collection.Randomize(points, strategy);
}
//---------------------------------------------------------------------
//public static void Initialize(double[,] establishProbabilities,
public static void Initialize(SeedingAlgorithm seedingAlgorithm,
Delegates.AddNewCohort addNewCohort)
{
// Reproduction.establishProbabilities = establishProbabilities;
seeding = new Seeding(seedingAlgorithm);
Reproduction.addNewCohort = addNewCohort;
SiteVars.Cohorts = Model.Core.GetSiteVar<SiteCohorts>("Succession.Cohorts");
speciesDataset = Model.Core.Species;
int speciesCount = speciesDataset.Count;
resprout = Model.Core.Landscape.NewSiteVar<BitArray>();
serotiny = Model.Core.Landscape.NewSiteVar<BitArray>();
noEstablish = Model.Core.Landscape.NewSiteVar<bool>();
foreach (ActiveSite site in Model.Core.Landscape.ActiveSites) {
resprout[site] = new BitArray(speciesCount);
serotiny[site] = new BitArray(speciesCount);
}
noEstablish.ActiveSiteValues = false;
planting = new Planting();
}
//---------------------------------------------------------------------
public static void Initialize(SeedingAlgorithm seedingAlgorithm)
{
seeding = new Seeding(seedingAlgorithm);
speciesDataset = Model.Core.Species;
int speciesCount = speciesDataset.Count;
resprout = Model.Core.Landscape.NewSiteVar<BitArray>();
serotiny = Model.Core.Landscape.NewSiteVar<BitArray>();
noEstablish = Model.Core.Landscape.NewSiteVar<bool>();
foreach (ActiveSite site in Model.Core.Landscape.ActiveSites) {
resprout[site] = new BitArray(speciesCount);
serotiny[site] = new BitArray(speciesCount);
}
noEstablish.ActiveSiteValues = false;
planting = new Planting();
}
public virtual void Seed(int?seed = null)
{
RandomState = Seeding.GetState(seed);
}
public SeedingController(CountryService countryService, FlagService flagService)
{
_countryService = countryService;
_flagService = flagService;
_seeding = new Seeding(_countryService, _flagService);
}
