public UserController()
{
Microsoft.Extensions.Configuration.IConfigurationRoot appSettingsJson = AppSettingsJson.GetAppSettings();
string connectionString = appSettingsJson["DefaultConnection"];
ConnectionString = connectionString;
}
public NemoConfigurationService(Microsoft.Extensions.Configuration.IConfigurationRoot configuration, NemoConfigurationBuilder builder)
{
var config = ConfigurationFactory.Configure();
builder?.Build(config);
config.SetSystemConfiguration(configuration);
}
/// <summary>
/// Sets the execution path
/// </summary>
public static void SetExecutionPath
(
ExecutionContext context
#if NETSTANDARD2_0
, Microsoft.Extensions.Configuration.IConfigurationRoot config
#endif
)
{
#if NETSTANDARD2_0
SetConfigurationManager(config);
#endif
ConfigurationExtensions.GetExecutionPath = () => Path.Combine(context.FunctionDirectory, "..", "bin");
HasSetExecutionPath = true;
}
public override void ConfigureServices(ServiceConfigurationContext context)
{
IHostingEnvironment hostingEnvironment = context.Services.GetHostingEnvironment();
Microsoft.Extensions.Configuration.IConfigurationRoot configuration = context.Services.GetConfiguration();
ConfigureDatabaseServices();
ConfigureAutoMapper();
ConfigureVirtualFileSystem(hostingEnvironment);
ConfigureLocalizationServices();
ConfigureNavigationServices();
ConfigureAutoApiControllers();
ConfigureSwaggerServices(context.Services);
}
public Logger CreateLogger(Microsoft.Extensions.Configuration.IConfigurationRoot config,
LoggingLevelSwitch levelSwitch,
string version, string providerName)
{
var loggerConfiguration = new LoggerConfiguration()
.ReadFrom.Configuration(config)
.MinimumLevel.ControlledBy(levelSwitch)
.Enrich.WithProperty("version", version)
.Enrich.WithProperty("environment", $"{config[InfrastructureConfigurationKeys.EnvironmentTag]}")
.Enrich.WithProperty("providerName", providerName)
.WriteTo.Console(new JsonFormatter());
var logger = loggerConfiguration.CreateLogger();
return(logger);
}
public static async Task Main(string[] args)
{
var builder = WebAssemblyHostBuilder.CreateDefault(args);
builder.RootComponents.Add <App>("app");
Microsoft.Extensions.Configuration.IConfigurationRoot configurationRoot = builder.Configuration.Build();
builder.Services.AddHttpClient(configurationRoot["Service:Api:AnonymousApiName"], client => client.BaseAddress = new Uri(builder.HostEnvironment.BaseAddress));
builder.Services.AddHttpClient(configurationRoot["Service:Api:ApiName"], client => client.BaseAddress = new Uri(builder.HostEnvironment.BaseAddress))
.AddHttpMessageHandler <BaseAddressAuthorizationMessageHandler>();
// Supply HttpClient instances that include access tokens when making requests to the server project
builder.Services.AddTransient(sp => sp.GetRequiredService <IHttpClientFactory>().CreateClient(configurationRoot["Service:Api:ApiName"]));
builder.Services.AddLocalization();
builder.Services.AddApiAuthorization();
builder.Services.AddApiAuthorization();
builder.Services.AddScoped <StateTchatContainer>();
builder.Services.Configure <AnimateOptions>(options =>
{
options.Animation = Animations.FadeDown;
options.Duration = TimeSpan.FromMilliseconds(1000);
});
builder.Services.AddScoped <IAdPhotoRepository, AdHttpPhotoRepository>();
builder.Services.AddFileReaderService(o => o.UseWasmSharedBuffer = true);
builder.Services.AddAuthorizationCore(options => options.AddPolicy("OnlySubscribers",
policy => policy.Requirements.Add(new OnlySubscribersRequirement())));
builder.Services.AddSingleton <NavigationUrlService>();
builder.Services.AddCors((opt) => {
opt.AddDefaultPolicy(builder => builder.AllowAnyOrigin().AllowAnyMethod().AllowAnyMethod());
});
var gta = configurationRoot["Service:GoogleAnalytics:GTA"];
builder.Services.AddGoogleAnalytics(gta, true);
builder.Services.AddScoped <IResizeListener, ResizeListener>();
builder.Services.AddScoped <IMediaQueryService, MediaQueryService>();
await builder.Build().RunAsync();
}
/// <summary>
/// Configures the repository options using the specified configuration.
/// </summary>
/// <param name="configuration">The configuration.</param>
/// <returns>The same builder instance.</returns>
/// <remarks>Any element that is defined in the config file can be resolved using the <see cref="RepositoryDependencyResolver"/>.</remarks>
public virtual RepositoryOptionsBuilder UseConfiguration([NotNull] Microsoft.Extensions.Configuration.IConfigurationRoot configuration)
{
Guard.NotNull(configuration, nameof(configuration));
const string SectionName = DotNetToolkit.Repository.Internal.ConfigFile.Json.ConfigurationSection.SectionName;
var root = configuration.GetSection(SectionName);
if (root == null || !root.GetChildren().Any())
{
throw new InvalidOperationException(string.Format(Resources.UnableToFindConfigurationSection, SectionName));
}
var config = new DotNetToolkit.Repository.Internal.ConfigFile.Json.ConfigurationSection(root);
UseConfiguration(config);
return(this);
}
public static void ConfigureStackifyLogging(this Microsoft.AspNetCore.Builder.IApplicationBuilder app,
Microsoft.Extensions.Configuration.IConfigurationRoot configuration)
{
try
{
Configure.SubscribeToWebRequestDetails(app.ApplicationServices);
if (configuration != null)
{
StackifyLib.Config.SetConfiguration(configuration);
//tell it to load all the settings since we now have the config
Config.LoadSettings();
}
}
catch (Exception ex)
{
Debug.WriteLine("Error in AddStackifyLogging " + ex.ToString());
}
}
public ConfigurationSection(Microsoft.Extensions.Configuration.IConfigurationRoot root, string path)
{
}
public static string GetDebugView(this Microsoft.Extensions.Configuration.IConfigurationRoot root)
{
throw null;
}
public static void SetConfiguration(Microsoft.Extensions.Configuration.IConfigurationRoot configuration)
{
_configuration = configuration;
}
public static void ConfigureStackifyLogging(this Microsoft.Extensions.Configuration.IConfigurationRoot configuration)
{
Config.SetConfiguration(configuration);
//tell it to load all the settings since we now have the config
Config.LoadSettings();
}
public static void SetConf(Microsoft.Extensions.Configuration.IConfigurationRoot c)
{
conf = c;
}
public void Init(Microsoft.Extensions.Configuration.IConfigurationRoot configuration)
{
}
public static IServiceCollection ApplySecurityConfiguration(this IServiceCollection services, IConfigurationRoot Configuration, IWebHostEnvironment environment)
{
services.AddSingleton <IHttpContextAccessor, HttpContextAccessor>();
services.AddLogging(
builder =>
{
builder.AddFilter("Microsoft", Microsoft.Extensions.Logging.LogLevel.Warning)
.AddFilter("System", Microsoft.Extensions.Logging.LogLevel.Warning)
.AddFilter("NToastNotify", Microsoft.Extensions.Logging.LogLevel.Warning)
.AddConsole();
});
services.AddCors(options =>
{
options.AddPolicy(
"CorsPolicy",
bld => bld
//.WithOrigins(Configuration.GetSection("CommonSettings:CorsOriginsWhiteList").Value.Split(" "))
.AllowAnyOrigin()
.AllowAnyMethod()
.AllowAnyHeader());
});
services.AddRouting(options => options.LowercaseUrls = true);
//services.AddDataProtection();
services.AddAuthentication(o =>
{
o.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
o.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
}).AddJwtBearer(cfg =>
{
cfg.RequireHttpsMetadata = false;
cfg.SaveToken = true;
cfg.TokenValidationParameters = new TokenValidationParameters
{
ValidIssuer = Configuration.GetSection("Token:Issuer").Value,
ValidAudience = Configuration.GetSection("Token:Audience").Value,
ValidateAudience = false,
IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(Configuration.GetSection("Token:Key").Value))
};
}).AddCookie();
services.AddSession(options =>
{
options.IdleTimeout = TimeSpan.FromDays(1);
options.IOTimeout = TimeSpan.FromDays(1);
});
services.AddDistributedMemoryCache();
services.Configure <FormOptions>(x =>
{
x.ValueLengthLimit = int.MaxValue;
x.MultipartBodyLengthLimit = int.MaxValue;
});
return(services);
}
