// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
try
{
services.Configure <CookiePolicyOptions>(options =>
{
// This lambda determines whether user consent for non-essential cookies is needed for a given request.
options.CheckConsentNeeded = context => true;
options.MinimumSameSitePolicy = SameSiteMode.None;
});
services.AddMvc(opt => { opt.EnableEndpointRouting = true; });
services.AddControllersWithViews().AddRazorRuntimeCompilation();
services.AddControllers();
services.AddRazorPages();
services.AddCors();
services.AddSingleton <IHttpContextAccessor, HttpContextAccessor>();
services.AddTransient <IPrincipal>(provider => provider.GetService <IHttpContextAccessor>().HttpContext.User);
// APPSETTINGS
var appSettings = AppSettingsBuilder.Build();
services.AddSingleton(x => appSettings);
AddBusinesLogic(services, Configuration, _env, appSettings);
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public static void AddStartupEnvironmentsWithServices(
string solutionDirectory,
string projectName,
string dbName,
List <ApiEnvironment> environments,
SwaggerConfig swaggerConfig,
int port,
bool useJwtAuth,
string projectBaseName,
IFileSystem fileSystem)
{
AppSettingsBuilder.CreateWebApiAppSettings(solutionDirectory, dbName, projectBaseName);
if (environments.Where(e => e.EnvironmentName == "Development").Count() == 0)
{
environments.Add(new ApiEnvironment {
EnvironmentName = "Development", ProfileName = $"{projectName} (Development)"
});
}
foreach (var env in environments)
{
WebApiLaunchSettingsModifier.AddProfile(solutionDirectory, env, port, projectBaseName);
}
if (!swaggerConfig.IsSameOrEqualTo(new SwaggerConfig()))
{
SwaggerBuilder.RegisterSwaggerInStartup(solutionDirectory, projectBaseName);
}
}
public AppSettingsDecoratorBuilder(
[NotNull] AppSettingsBuilder appSettingsBuilder,
[NotNull] IKeyValueConfigurationDecorator decorator)
{
AppSettingsBuilder = appSettingsBuilder ?? throw new ArgumentNullException(nameof(appSettingsBuilder));
Decorator = decorator ?? throw new ArgumentNullException(nameof(decorator));
}
private static void AddStartupEnvironmentsWithServices(string solutionDirectory, ApiTemplate template)
{
// add a development environment by default for local work if none exists
if (template.Environments.Where(e => e.EnvironmentName == "Development").Count() == 0)
{
template.Environments.Add(new ApiEnvironment {
EnvironmentName = "Development", ProfileName = $"{template.SolutionName} (Development)"
});
}
foreach (var env in template.Environments)
{
// default startup is already built in cleanup phase
if (env.EnvironmentName != "Startup")
{
StartupBuilder.CreateStartup(solutionDirectory, env.EnvironmentName, template);
}
AppSettingsBuilder.CreateAppSettings(solutionDirectory, env, template.DbContext.DatabaseName, template);
LaunchSettingsModifier.AddProfile(solutionDirectory, env);
//services
if (!template.SwaggerConfig.IsSameOrEqualTo(new SwaggerConfig()))
{
SwaggerBuilder.RegisterSwaggerInStartup(solutionDirectory, env);
}
}
}
private static AppSettingsBuilder AddUserSettings(this AppSettingsBuilder builder, string?basePath)
{
if (string.IsNullOrWhiteSpace(basePath))
{
return(builder);
}
return(builder.Add(new UserJsonConfiguration(basePath)));
}
protected virtual void Dispose(bool isDisposing)
{
if (isDisposing && !_isDisposed)
{
Previous?.Dispose();
AppSettingsBuilder?.Dispose();
_isDisposed = true;
}
}
public void Then_the_user_should_have_no_special_claims()
{
_action.ActionAgainst.Email = "*****@*****.**";
AppSettingsBuilder.WithSetting(AppSettingKey.AdminEmailWhitelist, "|[email protected]|");
PerformAction();
Assert.IsEmpty(_action.ActionAgainst.Claims);
}
public void Then_the_user_should_have_special_claims()
{
_action.ActionAgainst.Email = "*****@*****.**";
AppSettingsBuilder.WithSetting(AppSettingKey.AdminEmailWhitelist, String.Format("|{0}|", _action.ActionAgainst.Email));
PerformAction();
Assert.IsNotEmpty(_action.ActionAgainst.Claims);
}
private static AppSettingsBuilder AddReflectionSettings(this AppSettingsBuilder appSettingsBuilder,
IReadOnlyCollection <Assembly>?scanAssemblies,
IKeyValueConfiguration?configuration = null)
{
if (scanAssemblies is null)
{
return(appSettingsBuilder);
}
foreach (var currentAssembly in scanAssemblies.Where(assembly => assembly.FullName is { })
/// <summary>
/// Adds an <see cref="IConfigurationSource"/> for app settings to the given <see cref="IConfigurationBuilder"/>.
/// </summary>
/// <param name="configurationBuilder">The configuration builder.</param>
/// <param name="buildAction">The action to build app settings.</param>
/// <returns>The configuration builder.</returns>
/// <remarks>
/// This extension provides a simple way to add default values as well as descriptions for app settings
/// directly into an application. The source for these is a simple in-memory collection, and additional
/// key/value pairs are added so that the initial value and descriptions of these settings can still be
/// retrieved even if the settings themselves get overridden by another configuration source.
/// </remarks>
public static IConfigurationBuilder AddAppSettings(this IConfigurationBuilder configurationBuilder, Action <IAppSettingsBuilder> buildAction)
{
IAppSettingsBuilder appSettingsBuilder = new AppSettingsBuilder();
buildAction(appSettingsBuilder);
IEnumerable <KeyValuePair <string, string> > appSettings = appSettingsBuilder.Build();
configurationBuilder.AddInMemoryCollection(appSettings);
return(configurationBuilder);
}
public static AppSettingsBuilder AddEnvironmentVariables(
this AppSettingsBuilder builder,
IReadOnlyDictionary <string, string> environmentVariables)
{
var nameValueCollection = new NameValueCollection();
foreach (var environmentVariable in environmentVariables)
{
nameValueCollection.Add(environmentVariable.Key, environmentVariable.Value);
}
return(builder.Add(new InMemoryKeyValueConfiguration(nameValueCollection)));
}
public static AppSettingsBuilder AddCommandLineArgsSettings(
this AppSettingsBuilder builder,
IEnumerable <string> args)
{
if (args is null)
{
return(builder);
}
var inMemoryKeyValueConfiguration = args.ToKeyValueConfiguration();
return(builder.Add(inMemoryKeyValueConfiguration));
}
private static AppSettingsBuilder AddLoggingSettings(this AppSettingsBuilder builder)
{
var loggingSettings = new NameValueCollection
{
{ "Logging:LogLevel:Default", "Warning" },
{ "Logging:LogLevel:System.Net.Http.HttpClient", "Warning" },
{ "LogLevel:System.Net.Http.HttpClient", "Warning" }
};
var memoryKeyValueConfiguration = new InMemoryKeyValueConfiguration(loggingSettings);
return(builder.Add(memoryKeyValueConfiguration));
}
public static AppSettingsBuilder AddUserSettings([NotNull] this AppSettingsBuilder builder, string basePath)
{
if (builder is null)
{
throw new ArgumentNullException(nameof(builder));
}
if (string.IsNullOrWhiteSpace(basePath))
{
return(builder);
}
return(builder.Add(new UserJsonConfiguration(basePath)));
}
public static AppSettingsBuilder AddReflectionSettings(
[NotNull] this AppSettingsBuilder appSettingsBuilder,
IEnumerable <Assembly>?scanAssemblies,
Action <Exception>?exceptionHandler = null)
{
if (appSettingsBuilder is null)
{
throw new ArgumentNullException(nameof(appSettingsBuilder));
}
if (scanAssemblies is null)
{
return(appSettingsBuilder);
}
foreach (var currentAssembly in scanAssemblies.OrderBy(assembly => assembly.FullName))
{
if (currentAssembly.IsDynamic)
{
continue;
}
try
{
appSettingsBuilder =
appSettingsBuilder.Add(
new ReflectionKeyValueConfiguration(currentAssembly));
}
catch (FileLoadException ex)
{
exceptionHandler?.Invoke(ex);
}
catch (FileNotFoundException ex)
{
exceptionHandler?.Invoke(ex);
}
catch (TypeLoadException ex)
{
exceptionHandler?.Invoke(ex);
}
catch (ReflectionTypeLoadException ex)
{
exceptionHandler?.Invoke(ex);
}
}
return(appSettingsBuilder);
}
public void AppSettingIsAddForEverySettingNode()
{
AppSettingsNode settingsNode = new AppSettingsNode();
base.ApplicationNode.AddNode(settingsNode);
settingsNode.AddNode(new AppSettingNode("key", "value"));
AppSettingsBuilder settingsBuilder = new AppSettingsBuilder(settingsNode);
AppSettingsSection settingsSection = settingsBuilder.Build();
Assert.IsNotNull(settingsSection);
Assert.AreEqual(1, settingsSection.Settings.Count);
Assert.AreEqual("key", settingsSection.Settings.AllKeys[0]);
Assert.AreEqual("value", settingsSection.Settings["key"].Value);
}
public static void AddAuthServer(string solutionDirectory, IFileSystem fileSystem, AuthServerTemplate template)
{
SolutionBuilder.BuildAuthServerProject(solutionDirectory, template.Name, fileSystem);
AuthServerLaunchSettingsBuilder.CreateLaunchSettings(solutionDirectory, template.Name, template.Port, fileSystem);
StartupBuilder.CreateAuthServerStartup(solutionDirectory, template.Name, fileSystem);
ProgramBuilder.CreateAuthServerProgram(solutionDirectory, template.Name, fileSystem);
AuthServerConfigBuilder.CreateConfig(solutionDirectory, template, fileSystem);
AppSettingsBuilder.CreateAuthServerAppSettings(solutionDirectory, template.Name, fileSystem);
AuthServerPackageJsonBuilder.CreatePackageJson(solutionDirectory, template.Name, fileSystem);
AuthServerTailwindConfigBuilder.CreateTailwindConfig(solutionDirectory, template.Name, fileSystem);
AuthServerPostCssBuilder.CreatePostCss(solutionDirectory, template.Name, fileSystem);
// controllers
AuthServerAccountControllerBuilder.CreateAccountController(solutionDirectory, template.Name, fileSystem);
AuthServerExternalControllerBuilder.CreateExternalController(solutionDirectory, template.Name, fileSystem);
// AuthServerHomeControllerBuilder.CreateHomeController(projectDirectory, template.Name, fileSystem);
// view models + models
AuthServerAccountViewModelsBuilder.CreateViewModels(solutionDirectory, template.Name, fileSystem);
AuthServerSharedViewModelsBuilder.CreateViewModels(solutionDirectory, template.Name, fileSystem);
AuthServerExternalModelsBuilder.CreateModels(solutionDirectory, template.Name, fileSystem);
AuthServerAccountModelsBuilder.CreateModels(solutionDirectory, template.Name, fileSystem);
// views
AuthServerAccountViewsBuilder.CreateLoginView(solutionDirectory, template.Name, fileSystem);
AuthServerAccountViewsBuilder.CreateLogoutView(solutionDirectory, template.Name, fileSystem);
AuthServerAccountViewsBuilder.CreateAccessDeniedView(solutionDirectory, template.Name, fileSystem);
AuthServerSharedViewsBuilder.CreateLayoutView(solutionDirectory, template.Name, fileSystem);
AuthServerSharedViewsBuilder.CreateStartView(solutionDirectory, template.Name, fileSystem);
AuthServerSharedViewsBuilder.CreateViewImports(solutionDirectory, template.Name, fileSystem);
// css files for TW
AuthServerCssBuilder.CreateOutputCss(solutionDirectory, template.Name, fileSystem);
AuthServerCssBuilder.CreateSiteCss(solutionDirectory, template.Name, fileSystem);
// helpers
AuthServerTestUsersBuilder.CreateTestModels(solutionDirectory, template.Name, fileSystem);
AuthServerExtensionsBuilder.CreateExtensions(solutionDirectory, template.Name, fileSystem);
SecurityHeadersAttributeBuilder.CreateAttribute(solutionDirectory, template.Name, fileSystem);
}
static async Task Main(string[] args)
{
await new HostBuilder()
.ConfigureHostConfiguration((configHost) =>
{
configHost.AddEnvironmentVariables("DOTNET_");
})
.ConfigureAppConfiguration((hostBuilder, config) =>
{
config.SetBasePath(Directory.GetCurrentDirectory());
config.AddJsonFile("appsettings.json", optional: true);
config.AddJsonFile($"appsettings.{hostBuilder.HostingEnvironment.EnvironmentName}.json", optional: true);
config.AddEnvironmentVariables("fiksArkivMock_");
})
.ConfigureServices((hostContext, services) =>
{
services.AddSingleton(AppSettingsBuilder.CreateAppSettings(hostContext.Configuration));
services.AddHostedService <ArkivService>();
})
.RunConsoleAsync();
}
public static MultiSourceKeyValueConfiguration InitializeConfiguration(
[NotNull] Func <string, string> basePath,
ILogger logger)
{
if (basePath == null)
{
throw new ArgumentNullException(nameof(basePath));
}
string environmentBasedSettingsPath =
Environment.GetEnvironmentVariable(Configuration.ConfigurationConstants.JsonSettingsFile);
string environmentName = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") ?? "Production";
AppSettingsBuilder appSettingsBuilder = KeyValueConfigurationManager
.Add(new ReflectionKeyValueConfiguration(typeof(ConfigurationInitialization).Assembly))
.Add(new JsonKeyValueConfiguration(basePath("settings.json"), false))
.Add(new JsonKeyValueConfiguration(basePath($"settings.{environmentName}.json"), false))
.Add(new JsonKeyValueConfiguration(basePath($"settings.{Environment.MachineName}.json"), false));
if (environmentBasedSettingsPath.HasValue() && File.Exists(environmentBasedSettingsPath))
{
appSettingsBuilder =
appSettingsBuilder.Add(new JsonKeyValueConfiguration(environmentBasedSettingsPath,
true));
logger.Information("Added environment based configuration from key '{Key}', file '{File}'", Configuration.ConfigurationConstants.JsonSettingsFile, environmentBasedSettingsPath);
}
MultiSourceKeyValueConfiguration multiSourceKeyValueConfiguration = appSettingsBuilder
.Add(new EnvironmentVariableKeyValueConfigurationSource())
.Add(new UserConfiguration())
.DecorateWith(new ExpandKeyValueConfigurationDecorator())
.Build();
logger.Information("Configuration done using chain {Chain}",
multiSourceKeyValueConfiguration.SourceChain);
return(multiSourceKeyValueConfiguration);
}
public static void Main(string[] args)
{
var appSettings = new AppSettingsBuilder().Build();
var dataReciever = new DataReciever();
var stack = new ConcurrentStack <int>();
const int numbersCount = 2018;
using (var coundownEvent = new CountdownEvent(numbersCount))
{
Enumerable
.Range(0, numbersCount)
.ToList()
.ForEach(i =>
{
var state = new DataRecieverTaskState(i + 1, appSettings.Host, appSettings.Port, stack, coundownEvent);
ThreadPool.QueueUserWorkItem(dataReciever.PrcessNumber, state);
});
coundownEvent.Wait();
}
var mediana = CalculateMediana(stack);
Console.Out.WriteLine($"Mediana: {mediana}");
}
public static MultiSourceKeyValueConfiguration InitializeConfiguration(
IReadOnlyList <string> args,
[NotNull] Func <string, string> basePath,
ILogger logger,
IReadOnlyCollection <Assembly> scanAssemblies,
string contentBasePath)
{
if (basePath == null)
{
throw new ArgumentNullException(nameof(basePath));
}
string environmentBasedSettingsPath =
Environment.GetEnvironmentVariable(ConfigurationConstants.JsonSettingsFile);
string environmentName = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") ?? "Production";
AppSettingsBuilder appSettingsBuilder = KeyValueConfigurationManager
.Add(new InMemoryKeyValueConfiguration(new NameValueCollection()));
foreach (Assembly currentAssembly in scanAssemblies.OrderBy(assembly => assembly.FullName))
{
appSettingsBuilder =
appSettingsBuilder.Add(
new ReflectionKeyValueConfiguration(currentAssembly));
}
var loggingSettings = new NameValueCollection
{
{ "Logging:LogLevel:Default", "Warning" },
{ "Logging:LogLevel:System.Net.Http.HttpClient", "Warning" },
{ "LogLevel:System.Net.Http.HttpClient", "Warning" }
};
FileInfo MachineSpecificConfig(DirectoryInfo directoryInfo)
{
return(directoryInfo.GetFiles($"settings.{Environment.MachineName}.json").SingleOrDefault());
}
string MachineSpecificFile()
{
var baseDirectory = new DirectoryInfo(basePath(null));
FileInfo machineSpecificConfig = null;
DirectoryInfo currentDirectory = baseDirectory;
while (machineSpecificConfig is null && currentDirectory != null)
{
try
{
machineSpecificConfig = MachineSpecificConfig(currentDirectory);
currentDirectory = currentDirectory.Parent;
}
catch (Exception ex) when(!ex.IsFatal())
{
logger.Warning(ex, "Could not find machine specific config file in any parent directory starting with base directory {BaseDirectory}", baseDirectory.FullName);
return(null);
}
}
return(machineSpecificConfig?.FullName);
}
appSettingsBuilder = appSettingsBuilder
.Add(new InMemoryKeyValueConfiguration(loggingSettings))
.Add(new JsonKeyValueConfiguration(basePath("settings.json"), false))
.Add(new JsonKeyValueConfiguration(basePath($"settings.{environmentName}.json"), false));
string machineSpecificFile = MachineSpecificFile();
if (!string.IsNullOrWhiteSpace(machineSpecificFile))
{
appSettingsBuilder = appSettingsBuilder.Add(new JsonKeyValueConfiguration(machineSpecificFile));
}
if (environmentBasedSettingsPath.HasValue() && File.Exists(environmentBasedSettingsPath))
{
appSettingsBuilder =
appSettingsBuilder.Add(new JsonKeyValueConfiguration(environmentBasedSettingsPath,
true));
logger.Information("Added environment based configuration from key '{Key}', file '{File}'",
ConfigurationConstants.JsonSettingsFile,
environmentBasedSettingsPath);
}
var nameValueCollection = new NameValueCollection(StringComparer.OrdinalIgnoreCase);
const char variableAssignmentCharacter = '=';
foreach (string arg in args.Where(a => a.Count(c => c == variableAssignmentCharacter) == 1 && a.Length >= 3))
{
string[] parts = arg.Split(variableAssignmentCharacter, StringSplitOptions.RemoveEmptyEntries);
if (parts.Length != 2)
{
Console.WriteLine($"arg {arg} has length {parts.Length}");
continue;
}
string key = parts[0];
string value = parts[1];
nameValueCollection.Add(key, value);
}
var inMemoryKeyValueConfiguration = new InMemoryKeyValueConfiguration(nameValueCollection);
MultiSourceKeyValueConfiguration multiSourceKeyValueConfiguration = appSettingsBuilder
.Add(new JsonKeyValueConfiguration(Path.Combine(contentBasePath, "config.user"), throwWhenNotExists: false))
.Add(new EnvironmentVariableKeyValueConfigurationSource())
.Add(inMemoryKeyValueConfiguration)
.DecorateWith(new ExpandKeyValueConfigurationDecorator())
.Build();
logger.Information("Configuration done using chain {Chain}",
multiSourceKeyValueConfiguration.SourceChain);
return(multiSourceKeyValueConfiguration);
}
public DecoratorDelegator(AppSettingsBuilder appSettingsBuild) : base(appSettingsBuild, new NullDecorator())
{
}
public static AppSettingsBuilder Add(this AppSettingsBuilder builder, AppSettingsBuilder next) => builder.Add(next.KeyValueConfiguration);
